Our call on test-time compute, one week on: the capital case is borne out, but the "budget" has split into four axes

Key takeaways

Test-time compute (TTC) is the compute a model spends at inference time, before it answers, rather than during training. The claim under review, that capability grows with the TTC budget, comes from OpenAI reasoning researcher Noam Brown. A week ago, our call on his claim was that the core holds, but the strong reading, that models can think for weeks without hitting a wall, is held down by research on where domain gains stop. Confidence sat on the cautious side, and that call left three things to watch. This piece checks each of the three. No earlier piece is needed; the background is given where each point comes up.

The result, on our read: the capital leg of the TTC thesis is borne out at the macro level. Inference spending has passed training spending, and three independent sources point the same way. The same week's evidence broke the budget itself into pieces. Tokens, money, latency and verification compute are four axes that do not trade one for one. An arXiv study that compared early-exit strategies across 18 task-model settings found that the same compute-saving strategy cut tokens by 32% on serving setups that reuse already-computed prefixes, and raised cost by 121% on setups that must recompute the whole sequence. Noam Brown also loosened his own strongest argument for slow AI progress, waiting time. The evidence is one math-proof example from his own product, and it covers only work that can run in parallel. The TTC thesis still stands. What a given budget buys now depends on the domain, the task structure and the serving architecture, so the single curve has become a map drawn domain by domain.

Where this trend sits on this publication's map:

Three rewrites, one week, each with new evidence that points two ways

Noam Brown's claim rewrote three things at once: evaluation should put budget on the x-axis, safety evaluations run at a fixed budget miss dangerous capabilities that only appear at high budgets, and real-world waiting holds back the takeoff timeline. This week all three moved:

• Evaluation: the cost-axis redraw arrived, but what it drew is a live contradiction, covered below.
• Safety: version 3 of Anthropic's Responsible Scaling Policy, Anthropic's framework for tying safeguards to model capability levels, said in so many words that governance by pre-set capability thresholds has partly failed. That is a second lab corroborating Noam Brown's criticism, but Anthropic's reason for the failure goes deeper than Noam Brown's (Anthropic).
• Takeoff: Noam Brown released a parallel-TTC product and wrote that it cut the time to produce one math proof from "perhaps a whole day" to a single hour, roughly 24 times. The figure is illustrative and comes from the interested party. The person who made the bottleneck argument has supplied the first product-level data point that loosens it, so far in one domain (Noam Brown).

At the macro level, the thesis has turned into industry pricing

The first leg to check is the money. Inference spending passed training spending in early 2026. That direction now has three independent sources and is no longer a single-company rumor. The three use different measures. Zylos Research, which publishes research on inference economics, uses cumulative spending. Deloitte estimates that inference's share of all AI compute rises from about half in 2025 to about two-thirds in 2026. Industry press reported that inference passed 55% of AI cloud infrastructure spending for the first time in early 2026. The three indicators use different denominators. They point the same way, but no single figure has been checked by three parties. Together they support the direction and timing of the flip, not any specific share. This report checked the direction on July 12, and it held (Zylos Research). This is the macro payoff of the thesis's capital implication: demand for inference compute flexes with the budget buyers are willing to pay. A week ago our call was "bullish if true"; this week the evidence for it got harder.

At the same time, turning TTC budget into capability has become a product layer that can be sold. There are three independent signals:

• AI21 Labs, which builds language models and a deep-research agent product called Maestro, has parameterized the whole toolkit: multiple attempts, mixed model combinations, parallel versus serial runs, critique-then-repair. Maestro estimates the full accuracy-cost-latency trade-off frontier offline and picks a strategy per request online. TTC scheduling has moved from research technique to product (AI21 Labs Blog). That account comes from a single source, AI21 itself, and it is promotional.
• OpenAI turned parallel TTC directly into a model tier, GPT-5.6 Sol Ultra, which trades parallel search for latency (Noam Brown).
• On the user side, 2 modes times 3 models times 5 effort levels make 30 configurations, more choice than users can sort through. Practitioners have started writing their own value-for-money rules of thumb, and Sebastian Raschka asked what had happened to the Auto mode (X / @rasbt).

TTC has become a pricing structure. A year ago "think a little longer" was a trick in papers; now it is a priced option on a dropdown menu. Which effort level, whether to run in parallel, fast or cheap: every cell has a price on it.

At the micro level, the budget axis itself has split

The money leg held up; the measurement leg did not stay in one piece. A week ago the conclusion was that evaluation must put tokens or cost on the x-axis. This week's evidence says the x-axis is not one axis.

First split: one cost curve, two opposite readings

Moskovitz, Anthropic's scaling lead, cited Noam Brown's cost-axis curves to argue that smarter models use tokens more efficiently, so that on the total cost of solving a task, asking the large model directly is cheaper (AI Supremacy). Moskovitz is on the selling side and has an interest in that conclusion. The same week, the practitioner Sebastian Raschka observed the opposite: unless the very best output is required, a cheaper model at a higher effort setting is usually the better deal (X / @rasbt). That observation comes from one person, with no benchmark. Actual company behavior sits in a third place. Ramp, the corporate-card and spend-management company, steers employees away from the most expensive Opus model for writing email, a sign that, in practice, work is still routed by tier. This piece does not link a source for the Ramp example. The judgment already on this publication's map, that organizations use models in tiers, has academic support from RouteLLM, a research system that routes each query to a strong or a weak model. That judgment collides head-on with Moskovitz's argument, and both sides stay on the books.

The contradiction turns on the unit. Price per token is the wrong one. The total bill per solved task is the right one; that is a unit-economics conversion. The two readings differ because the large model costs more per token but may finish in a few hundred tokens, while the small model costs less per token but may grind through tens of thousands. Which side is right depends on the mix of task difficulty and on the gap in token efficiency between the two models. A mix heavy in easy tasks favors tiering; a mix heavy in hard tasks favors the large model. This can be settled with data: tracking cost per solved task across the major APIs would decide it. Our call is to keep both lines open and not name a winner.

Second split: saving tokens is not saving money, and serving architecture can flip the bill

The cost-per-task argument assumes a token costs the same everywhere. A controlled study of early exit, compared across 18 task-model settings, produced the most counterintuitive number of the week. The same compute-saving strategy saves 32% of tokens on an architecture that can reuse an already-computed prefix, and costs 121% more on an architecture that must recompute the whole sequence (arXiv). That is a single study and has not been replicated. Early exit also has no universal winner. Free-form math, multiple choice, and small sets of hard competition problems are each their own regime, and for the last kind the study found no active saving that could be certified.

For the thesis, this is confirmation with a narrower scope. The study confirms that the value of TTC really does vary with the workload, and it shows that a single performance-versus-budget curve is not enough. The shape of the curve depends on whether the serving infrastructure can reuse work it has already computed. For this study alone, evaluation needs three dimensions: tokens, money and serving architecture.

Third split: Noam Brown loosened his own takeoff argument, but only where work can run in parallel

The third split concerns time rather than money. In June 2025, Noam Brown said that waiting time was the strongest argument for the view that AI progress will take a long time, and that most experimental work cannot be parallelized. On July 10, 2026, Noam Brown released Sol Ultra and wrote that "the time taken to generate a proof to a 50-year-old problem drops from perhaps a whole day to a single hour" (Noam Brown; Noam Brown). That is roughly 24 times, an illustrative figure from the interested party, and the post itself says "perhaps". In the same week, a long-running agent experiment by the independent practitioner Aran Komatsuzaki pointed the other way. Many research problems are deeply serial, and spawning 50 agents does not solve them from scratch; a single agent running autonomously for eight hours or more has instead produced what looks like publishable progress (X / @arankomatsuzaki). This is one practitioner's own impression. The academic counter-evidence, that time horizon is itself a training bottleneck, also still stands.

Two things need to be kept apart. That a math proof can use parallel search to cut latency is an engineering fact, and so far only the interested party has shown it, in one domain. That the takeoff timeline splits by domain is a macro inference; the engineering fact is the first data point for it, not proof. This piece's call stays at the weaker level: the coordinates of the takeoff debate have moved, from "fast or slow overall" to "in which domains can waiting time be engineered around". Domains that allow parallel search and machine verification are piling up such cases. Gemini semi-autonomously worked through 700 open Erdős conjectures and produced new results on 5 of them (X / @quocleix). A separate line, test-time training, keeps updating the model's weights with reinforcement learning at test time. Test-time training is a different family from ordinary test-time methods, which only sample and never change the weights. With open models, test-time training has reached state-of-the-art results on open problems at a cost of a few hundred dollars per problem (arXiv). In domains that have to wait for experimental results, such as drugs and materials, the bottleneck is unchanged. The half-sentence Noam Brown wrote in June 2025, that most experimental work cannot be parallelized, has not been overturned by anyone, Brown included. The call that takeoff will not happen overnight has not been overturned either, but its edges now show a first product-level dent.

Fourth split: verification can also absorb compute

If waiting can be engineered around only in some domains, the next question is what decides which ones. A preprint from authors in the Stanford and Berkeley circle argues that verification, judging whether a solution is right, is a fourth scaling axis alongside pretraining, post-training and TTC. The preprint's levers are continuous scores, granularity, repeated evaluation and decomposition into criteria, and the authors report best results on four agentic benchmarks (arXiv). It has a strong author list but no second source yet.

That gives the claim that TTC gains depend on the domain a possible mechanism. The step is deductive reasoning, not a causal observation. Our reading: if TTC gains need something that can tell right from wrong in order to be harvested, then TTC compounds in domains where the verifier can absorb compute, and in domains without a verifier more thinking only means more mistakes. The domain boundary would then follow whether a verifier exists. The verifier explanation is not the only one. The lack of TTC gains in medicine could also come from causal complexity itself, from verification being too expensive, or from data and ethics constraints. These alternatives can be told apart from the verifier explanation: under them, a stronger verifier would not fix the problem. The test is whether a stronger verifier improves TTC gains in medicine. The verifier explanation says it would; the alternatives say it would not. If the verifier idea gets a second independent source, the verifier idea becomes the mechanistic foundation for "reasoning scaling is conditional on the domain"; for now it stands only as a possible explanation.

The domain boundary itself got finer again on July 15. A study that breaks planning into sub-skills shows that planning is not one ability. Reasoning about local actions and state transitions improves with larger models and longer reasoning traces. Structural enumeration such as goal reachability is almost insensitive to scale and to the reasoning budget (arXiv). That is a single source, and another counterexample at the domain boundary. The boundary cuts not only between domains but between sub-skills of the same task. The resolution needed for "capability is a function of budget" has gone up another notch.

The reason governance failed runs deeper than Noam Brown said

The four splits are about measuring capability, and governance depends on that measurement. Noam Brown's criticism was that safety-preparedness frameworks do not account for the TTC budget. Anthropic's self-review in version 3 of its Responsible Scaling Policy, on February 24, 2026, went further: capability-threshold governance as a whole has hit a methodological ceiling. In Anthropic's words, "The science of model evaluation isn't well-developed enough to provide dispositive answers." Biological risk sits in what Anthropic calls a "zone of ambiguity": Anthropic can no longer argue the risk is low, and the tests are not enough to argue it is high. The policy has moved to two tracks of mitigations plus a non-binding roadmap, with risk reports every 3 to 6 months (Anthropic). This is the company's own account. The cross-lab corroboration holds: two frontier labs, from different angles, concede the same thing: a fixed-snapshot capability evaluation cannot measure capability in the TTC era. One item is unverified: whether the full RSP v3 text explicitly accounts for the TTC budget has not been checked online. If it does, "governance lags" should be rewritten as "governance is starting to catch up".

The thesis now reads as a map by domain, not one curve

Stacking the four splits gives the thesis a new shape:

Capability = f(budget | whether the domain has a verifier, whether the task can run in parallel, whether the serving architecture can reuse computed work).

• Macro (capital): borne out. Several sources confirm the flip in inference spending, and TTC scheduling has become a product. The evidence for last week's "bullish" call got harder; this leg has moved from a working read to something that can be cited.
• Micro (engineering and procurement): split apart. The budget is at least four axes, tokens, money, latency and verification, and the exchange rate between them is set by serving architecture and task structure. There is no global constant.
• The claim itself: the strong reading, thinking for weeks without hitting a wall, stays held down; the weak reading, capability rises with budget, still holds. The new call: the next thing to watch is who builds the scheduling layer that converts budget into capability, not who burns the most GPUs.

Our call

The capital leg of the TTC thesis has landed at the macro level, but the budget is splitting into several axes (tokens, cost, latency, verification), the capability function is becoming conditional on the domain, and whether a verifier exists is a possible mechanism. The scheduling problem of converting budget into capability will become the point where the contest is decided. Who owns that layer is open: the effort tiers and parallel modes that frontier labs build into their models compete head-on with independent third-party scheduling layers. Users now face 30 combinations of mode, model and effort level, and Sebastian Raschka asked what had happened to the Auto mode. That gap can be read either as an opening for third-party scheduling or as a sign that scheduling is hard to turn into a standalone product.

Readings to monitor, which are also what would prove this wrong: ① whether, within 12 months, scheduling becomes an independent layer that earns its own margin; if it stays a built-in feature of model vendors, the call on a third-party scheduling layer is dead and the value goes to the model vendors; ② whether the major APIs get public comparisons on a cost-per-solved-task basis; ③ whether TTC gains in domains without a verifier keep staying at no more than one-third of the gains inside verifiable domains. The one-third line is the threshold this call sets; no study in this piece measures it yet.

What this changes, and for whom

• Investors making inference-capex calls: a week ago this report pointed to the slope of the performance-versus-budget curve as the thing to watch. This week's update is that the slope has become a matrix. The return on the same inference budget depends at once on the domain, the task structure and the serving architecture. The bullish logic holds at the level of total spending. At the level of who captures that spending, margin flows to whoever can manage the matrix, not to whoever simply stacks GPUs.
• Companies building agents and buying AI: both sides of the argument showed up this week, "the large model is actually cheaper" against "a cheap model at higher effort". Neither side's universal claim is established. The one internal metric that matters is cost per solved task, measured on a company's own mix of task difficulty. That single measure settles both narratives at once.
• AI safety and evaluation: Anthropic's self-review moves the problem from "preparedness frameworks are missing one TTC variable" to "snapshot capability measurement as a whole has hit a wall". If capability is a function of budget and domain, then "does this model have a dangerous capability?" is not a well-defined question. "At what budget, in which domain, with which verifier?" is. The first institution to write those three conditions into a protocol will define the next generation of standards.
• Product teams building TTC or reasoning products: reading ① in Our call above, whether an independent, margin-earning scheduling layer appears within 12 months, is the roadmap signal. Whether to build an in-house effort-scheduling layer now, or to wait for a third-party standard, turns on that reading.

Written from the same research and judgments as the Traditional Chinese edition. Sources are linked; we distinguish original documents from reporting and mark what we could not verify.