The reasoning-model era ran on renting intelligence at inference time. The next era ships it pre-installed, and that quietly rewrites the economics of running an agent.
The great discovery of the reasoning-model era, as The Sequence puts it, was that you could buy intelligence at test time. Let a model think longer, sample sixteen candidates and vote, run a tree search over reasoning paths, draft and self-verify, and accuracy climbs, often dramatically, without touching a single weight. Test-time compute became the third scaling axis, after parameters and data. Every frontier lab reoriented around it.
That reorientation was rational. It was also a financing arrangement with a hidden interest rate. When a model needs sixteen samples and a majority vote to answer a hard question, you are not paying once for a hard-won capability. You are paying every single time the question comes up, forever, at inference. The industry treated this as a permanent feature of the landscape. It is starting to look more like a transitional one.
The conceptual oddity is the tell. There is something strange about paying for the same cognition repeatedly, and the labs have noticed. The move now underway is to push that deliberation back into the weights, so the model arrives already knowing how to think rather than being coaxed into it at runtime. This is not a feature bump. It changes what an agent costs to run, how it is trained, and where the competitive advantage in this market actually sits.
Test-time compute was a loan against inference, not a free lunch
Start with what the reasoning-model era actually sold. The pitch, well captured in The Sequence's framing, was that you could hold the weights fixed and buy accuracy at test time: longer chains of thought, self-verification, multi-sample voting, tree search over candidate reasoning paths. The appeal was obvious. You did not need a new training run to get a smarter model. You needed more compute at the moment of the question.
The problem is that this structure pushes the cost onto the part of the system that runs most often. Training happens once. Inference happens every time a user or an agent asks anything. A model that sings only when it samples sixteen candidates and votes is a model whose best behavior carries a per-query tax.
For a chatbot answering one question at a time, that tax is tolerable. For an agent, it compounds. An autonomous workflow does not ask one question. It asks hundreds, chained, each step feeding the next, and if every step is silently running a 16x sampling budget under the hood, the operator is paying a multiple they may never see itemized.
This is why the diminishing-returns story matters. When each additional increment of test-time compute buys less accuracy than the last, you are financing a shrinking return on a recurring cost. That is the worst kind of bill: large, repeated, and flattening. The labs building the models see the aggregate inference load across their whole customer base, which means they feel this arithmetic long before any individual operator does.
Moving reasoning into the weights is a Wardley shift, not a tweak
The cleaner way to see what is happening is on an evolution axis. In Wardley Mapping terms, reasoning-via-test-time-compute is a component in the custom-built stage: bespoke, expensive, assembled fresh for each query out of sampling and search machinery bolted onto a frozen model. It works, but it is artisanal. Every answer is hand-crafted at runtime.
Baking deliberation into training moves that component rightward, toward product and eventually commodity. The reasoning stops being something you construct per query and becomes something the model simply has, the way a well-trained model already has grammar or arithmetic without being prompted to search for it.
The direction of that evolution is the whole point. Components do not usually move leftward, from commodity back to custom. Once a capability can be embedded and shipped, the market stops paying a premium to reassemble it live. The labs are not choosing between two equally good options. They are following the gradient, because the version that is cheaper to serve at scale wins the volume, and volume is where inference economics are decided.
The framing to resist is the one most coverage adopts: that test-time compute is a stable third pillar of scaling alongside parameters and data. It reads more like scaffolding. Scaffolding is essential while you are building the thing that makes it unnecessary, and then it comes down.
The agent operator's bill is about to change shape
Here is where this stops being a lab-internal curiosity and reaches anyone running agents. If reasoning lives in the weights, the runtime no longer needs to pay for multi-sample voting or tree search to get good answers. The deliberation is priced into the model call itself, not stacked on top of it.
Consider the two cost structures side by side. Under test-time reasoning, a single hard step in an agent workflow might fan out into sixteen sampled completions plus a verification pass, and you are billed for all of it. Under weights-embedded reasoning, that same step is closer to one call. The unit economics of an autonomous workflow, which is really just a long chain of such steps, move accordingly.
This matters most for the deployments that were marginal on cost. Plenty of promising agent use cases die in the spreadsheet, not the demo, because the token math at any real volume is brutal. A structural reduction in the reasoning tax does not make a bad idea good, but it moves a band of use cases from uneconomic to viable.
- Fewer runtime knobs to tune. Operators spend real effort today deciding how many samples, how deep a search, how much of a per-task compute budget to grant. Embedded reasoning quietly retires some of that dial-turning.
- Less variance per run. Sampling-and-voting introduces cost and latency that swing with problem difficulty. A model that deliberates internally is more predictable to budget against.
- A different comparison sheet. "Cost per run" starts to mean something more stable, which is exactly the number that decides whether an agent deployment survives contact with finance.
The honest caveat: none of this is free, it is relocated. The compute did not vanish. It moved into training runs the operator does not pay for directly and cannot see. That is a better deal for the operator and a heavier one for the lab, which brings us to who can actually afford to play this game.
This is Aggregation Theory with a compute bill attached
Relocating reasoning into training concentrates advantage upstream, and the shape of that concentration is worth naming plainly. Aggregation Theory says platforms win by aggregating demand and then commoditizing supply, with the party that owns the user relationship taking the prize. The reasoning-in-weights move is a supply-side maneuver in that game.
The lab that can absorb the training cost of embedded deliberation gets to offer cheaper, more predictable inference to the widest base of agent traffic. Cheaper inference wins more of the demand. More demand justifies bigger training runs. Bigger training runs deepen the capability the smaller players cannot match on cost. It is a familiar loop, and it favors whoever already has the balance sheet and the aggregate query volume to feel the economics first.
That balance sheet question is not abstract right now. The same week this reasoning shift surfaced, Stratechery was cataloguing Nvidia backing another frontier-lab data center and Anthropic's revenue continuing to climb. The capital and the compute are pooling at the top of the stack. Embedding reasoning into training is precisely the kind of move that rewards that pooling, because it trades a recurring inference cost that everyone pays for a one-time training cost only the well-capitalized can front.
The strategic reading follows directly. When a capability migrates from runtime, where anyone with an API key competes, into training, where only a handful of firms can operate, the market structure tightens. The reasoning tax coming down for operators is the same event as the moat going up for the labs. Both statements describe one movement of the cost from the many to the few.
Where this leaves the harness
If the model arrives already deliberating, does the surrounding machinery matter less? The instinct is to say yes, and the instinct is wrong. This is where the Harness Hypothesis earns its keep: the value in AI is not in the model, it is in the harness that connects the model to the world.
Embedded reasoning changes what the harness does, not whether it is needed. Today a meaningful chunk of harness engineering is compensating for the model's lack of built-in deliberation: orchestrating sampling, running verification passes, managing search over reasoning paths, stitching together the scaffolding that turns a raw model into something that thinks before it acts. Move that into the weights and that specific labor becomes redundant.
But the harness never existed only to make the model think. It exists to give the model tools, memory, permissions, and a connection to real systems where actions have consequences. None of that migrates into the weights. A model that reasons beautifully in isolation still cannot read your calendar, file your ticket, or refuse to wire money to the wrong account without a harness mediating every one of those boundaries.
So the harness's center of gravity shifts. It sheds the reasoning-scaffolding work and keeps, arguably intensifies, the integration and governance work. The interesting agent products will differentiate less on "how well did we bolt reasoning onto the model" and more on "what can this agent safely touch, and how do we know." That is a healthier place for the value to sit, because it is closer to the actual problem the operator has.
What to watch, and what would falsify the thesis
A thesis you cannot disprove is just a mood, so here are the tells that would confirm or break this one.
Confirming signals. Frontier releases that quietly drop or de-emphasize explicit per-query reasoning budgets while holding or improving accuracy. Pricing that stops charging separately for extended-thinking modes because the thinking is no longer a separate mode. Benchmark parity achieved with fewer sampled candidates. Any of these is the reasoning tax coming down in public.
Falsifying signals. If test-time compute keeps buying meaningful accuracy gains, generation after generation, then it is a durable scaling axis after all and this whole argument is premature. If embedded reasoning turns out to be brittle, degrading on genuinely novel problems in ways that runtime search still handles better, the scaffolding stays up because it earns its place. The diminishing-returns premise is doing real load-bearing work here; if it is wrong, the conclusion is wrong.
For the operator, the practical posture is patience with a bias. Do not re-architect a working agent around a shift that is still in motion. Do treat elaborate runtime reasoning configuration as a depreciating asset. The effort you sink today into hand-tuning sampling budgets and search depth is effort you are likely to throw away, and sooner than the current tooling suggests.
The larger point is one this title keeps returning to. Capabilities in this market do not stay where they first appear. They start as expensive, custom, runtime-assembled tricks, and they migrate toward cheap, embedded, and assumed. Test-time reasoning was never going to be the exception. It was just early.
/Figures
| Dimension | Test-time reasoning | Weights-embedded reasoning |
|---|---|---|
| Where compute is spent | Every query, at inference | Once, during training |
| Who pays it directly | The operator, per run | The lab, up front |
| Runtime tuning burden | High (samples, search depth, budget) | Low |
| Cost variance per run | Swings with problem difficulty | More predictable |
| Who can afford the strategy | Anyone with an API key | Well-capitalized frontier labs |
/Sources
/Key Takeaways
- Test-time compute made models smarter by paying for the same cognition on every query. That recurring reasoning tax falls hardest on agents, which chain hundreds of reasoning steps per workflow.
- The frontier labs are moving deliberation from runtime into training. In Wardley terms, reasoning is evolving from a custom, per-query trick toward an embedded, assumed capability.
- For operators, this reshapes the bill: fewer runtime reasoning knobs, less cost variance, and a more stable cost-per-run that pushes marginal agent use cases from uneconomic to viable.
- The compute did not vanish, it relocated into training runs only well-capitalized labs can afford. The reasoning tax coming down for operators is the same event as the moat going up for the labs.
- The harness still matters. It sheds reasoning-scaffolding work but keeps integration, permissions, and governance, which was always the harder and more valuable part.
