u/dahiparatha

Looking at Anthropic’s last two Managed Agents updates, I can understand why people would be tempted: memory, outcomes, multi-agent orchestration, webhooks, audit trails—the whole runtime is becoming more and more complete.
The problem lies there: once memory, grading, and orchestration all become smoother inside a single vendor runtime, are you really buying capability, or are you buying default judgment? The official docs emphasize exportable memory, audit logs, and execution tracing, which are all good things; but on HN, many people still keep asking the same question.
I’ve been thinking lately that models like Ling 2.6 1T, which seem better suited as non-thinking model / routing layer candidates, may belong more in the layer you control yourself: only maintaining the full workflow state, handoffs, escalation conditions, and permission boundaries, while leaving the actual execution to other layers.
The downside of this approach is obvious too: you have to take on more architectural and debugging complexity yourself. Which side are you leaning toward now? Do you first take the complete vendor-runtime experience, or would you rather keep the control layer yourself, even if it means a bit more hassle?

A lot of model discussion still gets pulled toward visible reasoning traces and “look how much it thought” moments.
What I keep wondering is whether builders are underweighting a different kind of strength: models that spend fewer tokens on reasoning theater and more on understanding, planning, and clean execution.
That is why Ling-2.6-1T caught my attention. The positioning is not “most reflective chatbot.” It is more like: a 1T model built for complex task planning, tool calling, real repo edits/patches, long-context material handling, and multi-step agent progress under production constraints.
The part that feels relevant to this sub is the tradeoff:
- lower token overhead
- stronger instruction discipline
- better fit for real workflows that need repeated use
- less emphasis on flashy reasoning presentation
In practice, I suspect a lot of agent systems care more about useful work per token than about maximum visible reasoning depth. If the model can keep structure, stay on task, and move the chain forward without constant retries, that is often the higher-value behavior.
Do people here think “fast-thinking but disciplined” models are getting underrated for planner / coordinator roles in agent stacks?

Codex and Claude Code give me two different feelings.
One feels like a collaborator: you steer it mid-execution, stay in the loop, and course-correct as it works.
The other feels more like an autonomous, agentic, thoughtful system that plans more deeply, runs longer, and asks less of me.
For me, the real question isn't "steering or autonomy?"
It's that the system using different depths of reasoning at different stages creates a very different UX.
That's also why I find product design around explicit thinking modes more interesting than the usual agent hype. With a thinking model like Ring 2.6 1T, it makes a lot more sense to me if I think of it as shifting gears for different phases of work.
When the task is still fuzzy and you need plan-first reasoning, multi-path analysis, or deeper review, use xhigh. When the task has already become concrete and you need stable execution on complex tasks without wasting unnecessary budget, use high.
That kind of mode switching gives me a different UX, and it lets me give the system steering and autonomy at different stages.

I’ve been wondering whether non-thinking models are only good when the surrounding structure is doing a lot of the work.
Like, if I use something like Ling 2.6 1T for execution-heavy tasks, is the real trick the model itself — or the fact that I gave it a very clear prompt, step boundaries, output format, and failure rules?
My intuition is execution-first models probably need better rails. Clear goal, explicit constraints, maybe even a lightweight harness around them.
But I’m not sure how far people actually go with this in practice. Are you just writing better prompts, or are you building real scaffolding around the model?
Would be curious to hear where people think the reliability is really coming from.

I need to pick a reasoning model for production agent work. The usual suspects are obvious (o3, Claude extended thinking, Gemini 2.5 Pro), but I'm also looking at Ring 2.6 1T, which has two reasoning effort modes — high for fast multi-step agent loops and xhigh for harder problems.
The dual-mode approach appeals to me because not every agent call needs maximum reasoning depth. But I can't find much real-world feedback on it. The benchmarks exist (PinchBench 87.60, Tau2-Bench Telecom 95.32) but I don't trust benchmarks to tell me how it handles real multi-step agent tasks with messy intermediate states.
How does the high/xhigh split work in practice is the speed difference noticeable? Does it stay stable on longer agent runs?

Finally got footage this week that didn't make me wince. Writing it down while it's fresh.
I was choosing between the Godox SL60W and the Neewer HB80C, similar price range. The Godox is a well-established light with a ton of real-world footage online. 60W daylight-only, quiet, build feels serious. If consistent white output in a stable environment is all you need, it's hard to argue against.
I went with the HB80C for two reasons. First, RGBWW. My apartment gets warm afternoon light through a south-facing window that fights with a daylight-only source unless I block the window completely. The HB80C lets me dial down toward 3200K to match the room without gelling. Second, I wanted the option to put a color accent on the background eventually, and having RGBWW already in the key meant I didn't need a dedicated second light for that.
80W is a real ceiling. On gray afternoons or with heavy diffusion I can feel it. For bigger spaces or two-person setups I'd be looking at the Neewer MS150C. But for solo talking-head in a 9x10 it's been enough, and the improvement came from finally getting placement and diffusion right, not from the wattage number.
Godox is the move for simplicity and a proven track record. I chose the HB80C because color flexibility mattered more than raw daylight output for my specific room. Curious if others in a similar situation went daylight-only and found it fine, or ended up wishing for the extra color range.

Used Roo code, I setup the model so planning is executed by Ling 2.6 1T and coding is executed by Ling flash, which optimizes my model use. Ever since this was implemented, I have not written a single line of code myself. I detail exactly what the AI should do, and then it does it. Even trivial things such as variable renaming. Obviously, higher-abstraction level architecture can't be handled by the AI well, nor can it find the optimal implementations; this is where my experience pays off. Prompts need to be precise for sure on the implementation. If I don't find the cleanest architecture, everything will go down the drain real fast. Still, amazing that I do not have to write code at all. This is akin to telling a junior exactly what to do and they do it instantly.

ngl i thought the venom horse was just gonna be a 2-second gag for the trailer, but seeing him actually use it to travel was so cool. it makes me wonder what else venom could bond with if he really wanted to. imagine a venom shark or a venom eagle lol. the "animal bonding" stuff was such a fun addition to the symbiote powers. what animal do you wish we got to see him bond with?

What makes you stop trusting a model in Cursor after a week?

Not first impression, week-one trust.

For me the biggest red flags aren’t that a model gets one thing wrong. It’s when it starts doing stuff like touching unrelated files, silently undoing earlier decisions, drifting style for no reason, or creating the feeling of progress without actually closing anything.

That’s usually when I stop caring how smart the first reply looked.

It’s also why I’m curious about Ling-2.6-1T in this context, since the more interesting pitch is execution discipline and lower overhead, not just a flashy first answer.

I’m curious what gets a model benched for other people here. What’s the behavior that makes you say “yeah, this is not going to be my default”?

The more I watch open-model discussion, the less I think “best overall” is the real question anymore.

What seems more true now is that the field is separating into different kinds of usefulness. Some models are optimized to look brilliant in one turn. Some are better at long structured tasks. Some are better at tool use. Some are better at staying cheap enough to sit inside real workflows without turning every task into a cost problem.

That is why Ling-2.6-1T is interesting to me less as a hype object and more as a signal. The pitch is not really “look how magical this chat feels.” It is much more about execution, structure, long task handling, and lower token waste.

So I’m curious whether people here feel the same shift. Are we now looking at separate frontiers for raw reasoning, execution reliability, long-context organization, and cost per useful action?

Because if that split is real, then a lot of leaderboard talk is going to look increasingly incomplete.