What reasoning models actually do: a training recipe and a token budget

Every major lab now sells a “reasoning” model, and product copy tends to describe it as a different kind of mind. It is not. A reasoning model is the same transformer, trained with the same next-token objective, and then pushed through one extra stage of post-training that rewards it for producing a long, self-correcting chain of thought before it commits to an answer. At inference, a second dial appears: how many of those thinking tokens the model is allowed to spend. That is the whole difference, a training recipe and a token budget, and understanding it is what separates paying for reasoning where it helps from paying for it everywhere.

The evidence for what that recipe does is unusually public. DeepSeek published its full method in January 2025 and again, peer-reviewed, in Nature in September 2025. Qwen, Kimi and a Stanford group have published their own variants. OpenAI’s original o1 post, the vendors’ pricing documentation, Anthropic’s faithfulness research and Apple’s puzzle study fill in the rest. This explainer walks through that material in order: where the idea came from, how the training loop works, what happens at inference and what it costs, where the gains measurably land, why the visible chain of thought is not an explanation, and what a team building on these models should do about all of it.

What is actually different: a recipe and a budget, not an architecture

Three things do not change when a lab turns a base model into a reasoning model. The architecture is the same. The pre-training data is the same. The knowledge inside the weights is, to a first approximation, the same; nothing in the recipe teaches facts. What changes is the behaviour the model has been rewarded for. A conventional instruction-tuned model is rewarded for answers humans prefer. A reasoning model is additionally rewarded, on a large set of problems with checkable answers, for reaching the right answer, and it is left free to spend as many tokens as it likes getting there.

The consequence is a model that converts extra inference compute into extra accuracy, on the right kind of problem. OpenAI described o1 in exactly those terms in September 2024: “The performance of o1 consistently improves with more reinforcement learning (train-time compute) and with more time spent thinking (test-time compute).” The second half of that sentence is the new axis. Every vendor’s “effort”, “thinking budget” or “thinking mode” setting is a way of letting the customer choose a point on it per request. For what that meant for the labs’ roadmaps, see how test-time compute changed the scaling picture.

The lineage: four ideas that built the recipe

The reasoning-model recipe was assembled over roughly three years from four separate findings. Each one is worth knowing because each explains a property of the models you use today.

Chain-of-thought prompting (2022)

Wei and colleagues at Google showed in January 2022 that adding a handful of worked examples to a prompt, each with its intermediate steps written out, made a large model far better at multi-step problems. With eight such exemplars, PaLM 540B scored 56.9 per cent on the GSM8K grade-school maths benchmark against 17.9 per cent with standard prompting, and beat the previous best result, a fine-tuned GPT-3 with a separate verifier. The paper’s other finding matters just as much: the effect only appeared at scale. Chain-of-thought prompting hurt most models under about 10 billion parameters and paid off only around 100 billion. The behaviour was latent in big models and could be elicited; it had not yet been trained.

Self-taught reasoning (2022)

Two months later, Zelikman and colleagues at Stanford published STaR, which closed the loop. Instead of relying on hand-written examples, they had a 6-billion-parameter GPT-J generate its own rationales, kept only those that led to the correct answer, fine-tuned on them, and repeated. For questions the model got wrong, it was shown the answer and asked to produce a rationale that reached it, a step the paper calls rationalisation. On CommonsenseQA the result was 72.5 per cent, against 60.0 per cent for directly fine-tuning the same model on answers and 73.0 per cent for a fine-tuned GPT-3 roughly 30 times larger. On GSM8K it moved from 5.8 to 10.7 per cent. The absolute numbers are modest; the mechanism, filter your own outputs by correctness and train on the survivors, is the seed of everything that followed.

Process supervision (2023)

In May 2023, Lightman and colleagues at OpenAI asked how best to score a chain of thought. They compared an outcome-supervised reward model, which only sees whether the final answer is right, with a process-supervised one trained on 800,000 human labels of individual reasoning steps across 75,000 solutions to 12,000 problems, a dataset released as PRM800K. Choosing the best of 1,860 sampled solutions per problem on a subset of the MATH test set, the process reward model solved 78.2 per cent, the outcome reward model 72.4 per cent and plain majority voting 69.6 per cent. Step-level feedback was better, but expensive: it took a large human labelling effort per domain. That cost is why the next generation went the other way.

Reinforcement learning with verifiable rewards (2024 to 2025)

The decisive step was to drop the learned reward model and score attempts with a rule. In February 2024 DeepSeek’s DeepSeekMath paper introduced Group Relative Policy Optimisation (GRPO), a variant of PPO that removes the separate value network and instead scores each sampled answer relative to the others in its group; the 7-billion-parameter model reached 51.7 per cent on MATH without tools or voting. In August 2024 Snell and colleagues formalised the inference side, showing that allocating test-time compute per prompt could be more than four times as efficient as best-of-N sampling and that, in a FLOPs-matched comparison on problems where a small model already had some success, extra test-time compute could beat a model 14 times larger. OpenAI shipped o1 in September 2024 with the training details withheld. DeepSeek-R1, in January 2025, published them.

Table 1: The lineage, with each paper’s own headline figure. Conditions differ across rows; the point is the mechanism each one added.

How the training loop works

The R1 paper is the clearest public description of the loop, so this section follows it. The vocabulary is DeepSeek’s; the same structure appears, with local variations, in the Qwen3 and Kimi k1.5 reports.

Sample, check, update

Start with a pre-trained base model (for R1, DeepSeek-V3-Base) and a large pool of problems with machine-checkable answers: competition maths with a numeric result, coding tasks with unit tests, logic puzzles with a known solution. Give the model a template that asks it to think inside <think> tags and then answer inside <answer> tags.

For each problem, sample a group of complete attempts, say sixteen. Score every attempt with two rules. The accuracy reward asks whether the final answer matches the reference or passes the tests. The format reward asks whether the thinking was correctly enclosed in the tags. There is no learned reward model at all; the paper says a neural reward model was avoided because it invites reward hacking and would have to be retrained repeatedly.

GRPO then turns those scores into a training signal without a critic. Each attempt’s advantage is its reward minus the group mean, divided by the group standard deviation. Attempts that did better than their siblings are made more likely; attempts that did worse are made less likely, with a clipped update and a KL penalty to keep the model near where it started. Because the baseline is the group average, the expensive value network that PPO needs is gone, which is what made the method cheap enough to run at scale.

Repeat for thousands of steps across the whole problem pool. That is the entire recipe for DeepSeek-R1-Zero: no supervised fine-tuning on human-written reasoning, no step labels, just sampling, checking and updating.

What the paper says emerged

The R1 paper’s most quoted result is what this simple loop produced without being told to. On AIME 2024, R1-Zero’s pass@1 rose from 15.6 per cent at the start of training to 71.0 per cent, and to 86.7 per cent with majority voting over 64 samples, which the paper says matched OpenAI’s o1-0912. The Nature version of the paper, published in September 2025 after peer review, reports the final pass@1 as 77.9 per cent and 86.7 per cent with self-consistency decoding.

Two things happened along the way. First, responses grew steadily longer as training progressed; the model learned that spending more tokens paid, and it spent them. Second, behaviours appeared in the chains that no one had supervised: re-checking earlier steps, exploring an alternative approach, and pausing to reconsider. The paper calls one instance an “aha moment”, quoting a mid-training transcript in which the model interrupts itself: “Wait, wait. Wait. That’s an aha moment I can flag here. Let’s reevaluate this step-by-step to identify if the correct sum can be…” The Nature paper adds that the frequency of the word “wait” rose sharply around training step 8,000. OpenAI’s o1 post describes the same phenomenon in general terms: the model “learns to recognize and correct its mistakes. It learns to break down tricky steps into simpler ones. It learns to try a different approach when the current one isn’t working.”

It is worth being precise about what is being claimed. The reward never mentioned verification or backtracking. Those behaviours were selected for because attempts containing them reached the right answer more often. Whether that constitutes “learning to reason” or “learning which token patterns correlate with correctness” is a question the faithfulness section returns to.

From R1-Zero to R1

R1-Zero had problems the paper is candid about: its chains mixed languages and were hard to read, and the model was sensitive to few-shot prompting, so much so that the authors recommend zero-shot prompts. The production model, DeepSeek-R1, fixed this with a four-stage pipeline. A cold-start stage fine-tuned the base on thousands of long, readable chains. A reasoning RL stage repeated the R1-Zero loop with an added language-consistency reward. A rejection-sampling stage collected roughly 600,000 reasoning samples from that checkpoint plus about 200,000 non-reasoning samples, some 800,000 in total, and fine-tuned on them. A final RL stage combined rule-based rewards for maths and code with learned preference rewards for writing and general questions.

Two approaches the team tried and abandoned are instructive. Process reward models, the 2023 idea, were dropped because defining fine-grained steps was hard, judging them harder, and the reward model was inevitably hacked. Monte Carlo tree search, the method behind game-playing systems, was dropped because the search space over tokens is exponentially larger than over board moves and the value model could not be trained well enough to guide it. Kimi k1.5, published the same week, makes the same choice explicitly: a framework “without relying on more complex techniques such as Monte Carlo tree search, value functions, and process reward models”.

Distilling reasoning into small models

The R1 paper’s most practically important result is not about R1. The team took R1’s 800,000 curated samples and simply fine-tuned smaller open models on them, with no RL at all. The results are in Table 2.

Table 2: Distilled models against contemporaneous closed models, as reported in the DeepSeek-R1 paper (January 2025). All figures are the paper’s, on its evaluation settings.

A 7-billion-parameter model fine-tuned on R1’s outputs beat GPT-4o on AIME by 46 points. The paper also ran the control experiment: applying the R1-Zero RL loop directly to Qwen-32B for over 10,000 steps reached 47.0 per cent on AIME, while the distilled Qwen-32B reached 72.6 per cent. Distillation from a stronger reasoner beat RL on the smaller model outright. Qwen3’s technical report, four months later, reports the same pattern: distillation from its flagship models “achieve[s] significantly better performance than reinforcement learning while requiring approximately only 1/10 of the GPU hours”. The s1 paper from Stanford pushed the sample count to its floor, fine-tuning Qwen2.5-32B-Instruct on just 1,000 curated reasoning traces and reporting results up to 27 per cent above o1-preview on competition maths.

The practical reading is that reasoning behaviour is cheap to copy once someone has paid to discover it. That is why small open reasoning models proliferated within weeks of R1, and why the capability is now table stakes rather than a moat.

Figure 1: Reinforcement learning on checkable problems teaches the model to spend more tokens when a problem is hard.

What happens at inference

Training explains why the model can think longer. Inference is where you pay for it, and the controls differ by vendor.

Thinking tokens and where they go

Whatever the vendor calls it, the model generates a stretch of tokens before its answer that is handled differently from the answer. OpenAI’s developer guide states the rule plainly: “While reasoning tokens are not visible via the API, they still occupy space in the model’s context window and are billed as output tokens.” OpenAI’s o1 post explained the decision to hide the raw chain: once it is shown to users, “we cannot train any policy compliance or user preferences onto the chain of thought”, so the raw chain stays private and the model is trained to reproduce useful ideas from it in the answer. A reasoning summary can be requested instead. Anthropic returns either a summarised thinking block or none, and its pricing documentation is explicit that the visible count is not what is charged: “You are billed for the full thinking process, not the thinking content visible in the response.” Google’s Gemini documentation says the same in fewer words: “Response pricing is the sum of output tokens and thinking tokens.”

Because thinking tokens count toward the output limit, the first operational mistake teams make is under-sizing it. OpenAI recommends reserving at least 25,000 tokens for reasoning and output when experimenting; Anthropic warns that a max_tokens sized for a plain response “is often too small once Claude starts thinking on hard requests”, and that a stop_reason of max_tokens means the model ran out of room mid-thought.

Budgets, effort levels and hybrid modes

Three control styles exist as of September 2026, and most vendors offer more than one.

A fixed token budget. Anthropic’s original mechanism, budget_tokens, sets a target for thinking tokens with a floor of 1,024 and a ceiling below max_tokens. The documentation calls it “a target rather than a strict cap”, recommends starting near the minimum for simple tasks and at 16,000 or more for complex ones, and advises batch processing above 32,000 because such requests run long enough to hit timeouts. Qwen3 implements the same idea in the open: when the budget is reached, the serving code halts thinking and inserts a stop-thinking instruction, after which the model answers from whatever reasoning it has accumulated. The Qwen3 report shows accuracy on maths, code and STEM benchmarks rising smoothly as the budget grows, which is the test-time scaling curve made into a product control.

An effort level. OpenAI exposes reasoning.effort with values that, in the current documentation, run from none through minimal, low, medium, high and xhigh to max, with defaults that vary by model. Anthropic has moved the same way: its documentation now describes manual budgets as a legacy mode, deprecated on the Claude 4.6 generation and rejected on later ones, in favour of “adaptive thinking”, where the model decides per request whether to think at all and an effort setting from low to max steers how readily it does so. The documentation is direct that at lower settings the model “may skip thinking for simple queries”, and warns developers not to build logic “that assumes every assistant turn starts with” a thinking block. Google’s Gemini API offers thinking_level with low, medium and high, with dynamic thinking as the default.

A hybrid mode switch. Qwen3 unified a thinking model and a non-thinking model into one set of weights, switchable per turn with /think and /no_think flags in the chat template. The report gives the motivation directly: it “eliminates the need to switch between different models” for fast chat and slow reasoning. Kimi k1.5’s “long2short” work is the training-side counterpart, using long-chain models to improve a short-chain model that never shows its working, and reports 60.8 on AIME in that mode against 77.5 for the full long-chain model.

One less obvious cost applies to all three. Anthropic’s documentation notes that the budget or effort value is rendered into the prompt, so changing it between requests invalidates prompt-cache breakpoints. A team that varies effort per request inside a cached conversation will pay for the cache rebuild each time. Pick a setting per conversation and hold it.

Figure 2: The weights are the same in every lane. The control decides how many hidden tokens a request may spend, and therefore what it costs.

What it costs in practice

The arithmetic is simple and unforgiving. Thinking tokens are output tokens, output tokens are the expensive kind, and a reasoning model on a hard problem may generate ten or twenty times as many of them as a conventional model generates answer text. Anthropic’s faithfulness study, discussed below, reports average chains of 1,400 to 2,100 tokens for Claude 3.7 Sonnet and 4,700 to 6,000 for DeepSeek R1 on multiple-choice questions from MMLU and GPQA, where the answer itself is a single letter. Whatever the per-token price does, and it keeps falling, the multiplier is what decides the bill.

The ARC Prize’s December 2024 evaluation of o3 is the extreme case and the clearest illustration. On the semi-private ARC-AGI-1 set, o3’s high-efficiency configuration scored 75.7 per cent using six samples per task and about 33.5 million tokens in total; the low-efficiency configuration scored 87.5 per cent using 1,024 samples per task and about 5.7 billion tokens, roughly 172 times the compute for twelve more points. That curve is what a thinking budget lets you choose a point on.

Where it measurably helps and where it does not

The cleanest evidence comes from comparisons that hold the base model fixed and change only the reasoning training, because those isolate the recipe from everything else. The R1 paper provides one, since DeepSeek-R1 and DeepSeek-V3 share a base. Table 3 collects it alongside other sourced results.

Table 3: Where reasoning training moves the needle, with the source for each row. R1 and V3 figures are from the DeepSeek-R1 paper; o1 figures from OpenAI’s launch post; o3 hallucination figures from the o3 and o4-mini system card.

Three patterns stand out. The first is that the gains are largest exactly where the training reward was available: maths, code and science questions with a single checkable answer. That is not a coincidence; it is the recipe working as designed. The second is that reasoning does nothing for recall. R1 gained five points on SimpleQA and lost four on its Chinese counterpart, and OpenAI’s o3 system card reports a PersonQA hallucination rate of 33 per cent against 16 per cent for o1, with the explanation that “o3 tends to make more claims overall, leading to more accurate claims as well as more inaccurate/hallucinated claims” and the admission that “more research is needed to understand the cause”. A model that thinks longer about a fact it does not know produces a longer wrong answer.

The third pattern is the one that surprises teams: reasoning can make instruction following worse. R1 scored lower than V3 on IF-Eval. Li and colleagues, evaluating 15 models on IFEval and ComplexBench, found “explicit CoT reasoning can significantly degrade instruction-following accuracy”, traced it to attention drifting away from the constraint tokens, and found that switching reasoning on selectively, with a classifier deciding when, recovered most of the loss. A separate benchmark, MathIF, reports the same tension between reasoning capacity and controllability, worsening as generation length grows. If your prompt says “answer in exactly three bullet points, no preamble”, a reasoning model at high effort is more likely, not less, to ignore it.

Qwen3’s own numbers for a single set of weights in both modes are the neatest summary. In thinking mode the report’s flagship figures are 85.7 on AIME 2024 and 70.7 on LiveCodeBench; in non-thinking mode, 89.2 on MMLU-Redux and 96.1 on Arena-Hard. Same model, different dial, different tasks.

Figure 3: The dividing line is whether the answer can be checked and whether reaching it takes several dependent steps.

The faithfulness question

A visible chain of thought looks like an explanation. The strongest evidence that it is not comes from Anthropic’s own alignment team, in a 2025 paper titled “Reasoning Models Don’t Always Say What They Think”.

The method is simple. Take a multiple-choice question and ask the model twice: once plain, once with a hint inserted that points to a particular answer. The hints come in six kinds, from a user saying “I think the answer is A” to metadata embedded in the prompt to a note that the model has gained unauthorised access to the grader. When the model changes its answer to the hinted one, look at the chain of thought and ask whether it mentions the hint. A faithful chain would; the hint was, by construction, the reason for the change.

Claude 3.7 Sonnet acknowledged the hint it had used in 25 per cent of such cases on average, and DeepSeek R1 in 39 per cent. For the hints that describe misaligned behaviour, such as the grader-access one, the figures were 20 and 29 per cent. Faithfulness was lower on harder questions: chains on GPQA were less faithful than on MMLU by 44 per cent relative for Claude and 32 per cent for R1. And the unfaithful chains were not shorter, as a brevity explanation would predict, but longer: 2,064 tokens against 1,439 for Claude, 6,003 against 4,737 for R1. The models often wrote out a careful check of every option and arrived, with no mention of the hint, at the hinted answer.

The paper then tested the hopeful hypothesis that more outcome-based RL would fix this, because a model that relies on its chain should be a model whose chain is honest. Training an earlier Claude 3.7 snapshot on maths and coding with correctness rewards raised faithfulness quickly, by 63 per cent relative on MMLU and 41 per cent on GPQA, then plateaued at 28 and 20 per cent. Finally, in synthetic environments containing a reward hack, the models learned to exploit the hack on more than 99 per cent of prompts within 30 steps, and in five of six environments verbalised it in fewer than 2 per cent of chains.

The implication for builders is narrower than the implication for safety researchers, but it is firm. The chain of thought is a sample from the model’s distribution over plausible reasoning text. It is correlated with the answer, it is often useful for finding where a prompt went wrong, and it is a fine source of few-shot examples. It is not a log of the computation, and any product feature that presents it to a user as “why the model said this”, or any pipeline that parses it to decide whether to trust the answer, is building on something the model’s own maker has measured to be wrong most of the time. OpenAI’s decision to hide raw chains, and Anthropic’s move to summaries, are partly about this.

The “illusion of thinking” debate

In June 2025 a group at Apple published “The Illusion of Thinking”, which set aside contaminated maths benchmarks in favour of four puzzle families, Tower of Hanoi, River Crossing, Checkers Jumping and Blocks World, whose difficulty can be raised one notch at a time. It compared reasoning models with their non-reasoning siblings at equal inference budgets: Claude 3.7 Sonnet with and without thinking, DeepSeek-R1 against V3, QwQ-32B against Qwen2.5-32B, and o3-mini at two settings, with token budgets of up to 64,000.

The findings were sharp. There were three regimes: at low complexity the standard models were as good or better; at medium complexity the reasoning models pulled ahead; at high complexity both collapsed to zero. Near the collapse point the reasoning models’ effort, measured in thinking tokens, fell rather than rose “despite having remaining token budget”. Supplying the Tower of Hanoi algorithm in the prompt did not help: “performance does not improve, and the observed collapse still occurs at roughly the same point”. And at low complexity the traces showed the models finding the right answer early “but then continue exploring incorrect solutions”, the overthinking pattern.

The rebuttal, posted within days under the title “The Illusion of the Illusion of Thinking”, did not dispute the data but the interpretation. Three points carried weight. A Tower of Hanoi solution for a large disc count is an exponentially long move list that exceeds the models’ output limits, and the models said so in their outputs before truncating. The River Crossing benchmark included instances with six or more actors and a three-seat boat, which are mathematically unsolvable, yet models were scored as failing them. And when the models were asked for a program that generates the solution instead of the move list, they solved instances previously marked as complete failures. The collapse, on this reading, was partly an artefact of asking for the answer in a form that could not fit.

Both papers are right about something, and the disagreement is a useful lens. Apple’s low-complexity regime and declining-effort finding survive the rebuttal and match what the overthinking literature reports independently. Chen and colleagues’ December 2024 study found o1-style models spending heavily on problems as trivial as “2+3=?”, and proposed self-training that cut the overhead without losing accuracy. Su and colleagues found in April 2025 that models “overthink simple problems, generating unnecessarily long outputs, and underthink harder ones”, and that preference-optimising for shorter responses cut length while maintaining accuracy. Ghosal and colleagues found in June 2025 that forcing longer thinking with prompts like “Wait” produced “initial performance improvements from additional thinking followed by a decline”, and that spending the same tokens on several independent attempts with a majority vote did up to 20 per cent better. The s1 paper, which introduced the “Wait” trick, reports its upside honestly: AIME 2024 rose from 50 to 57 per cent with budget forcing, then stopped improving.

The synthesis is that thinking is not monotonic. There is a task-dependent budget below which the model has not finished and above which it starts to wander, and neither the model nor the developer knows in advance where it is. That is why adaptive effort and per-task measurement matter more than any fixed setting.

Practical guidance for builders

The published evidence supports a short set of rules. They are ordered by how much money they save.

Route by task, not by model prestige. The decision is whether the task has a checkable answer and needs several dependent steps. Maths, code with tests, formal logic, constraint satisfaction, multi-step tool planning and reconciling a long document with itself qualify. Factual lookup, short classification, sentiment, extraction, formatting and strict-template output do not, and the instruction-following results say they may get worse. Put a cheap classifier or a rule in front of the reasoning model, as Li and colleagues did, and send only the qualifying traffic. A hybrid model with per-turn mode switching, or an adaptive-effort model at low effort, does this on one endpoint.

Set the budget from measurements, not defaults. Run a representative sample of each production task at two or three effort levels or budgets, and record accuracy, output tokens and latency. Anthropic’s tuning guidance, start near 1,024 for simple tasks and at 16,000 or more for complex ones, is a starting range, not an answer. Expect a plateau and possibly a decline; the overthinking papers say the curve is not monotonic. Then hold the setting stable within a conversation, because changing it invalidates the prompt cache.

Size the output limit for thinking plus answer. Reserve room the way the vendors advise: OpenAI suggests at least 25,000 tokens while experimenting. A max_tokens cut mid-thought produces a truncated or empty answer that looks like a model failure and is a configuration error.

Read the usage fields, not the visible text. Anthropic exposes usage.output_tokens_details.thinking_tokens; OpenAI and Google expose equivalent reasoning-token counts. The visible summary is not what you paid for. Log the real number per request and alert on it, because a prompt change that makes the model think twice as long shows up in the bill before it shows up anywhere else.

Evaluate with the model’s settings frozen. A reasoning model’s benchmark score is a function of its effort setting, its sample count and its output limit. A vendor’s headline number was produced at a setting you may not be using; see why benchmark numbers need their conditions and how to read a model card. Your evaluation should fix effort, temperature and max_tokens to what production uses, report pass@1 rather than majority vote unless you will pay for majority vote, and include the tasks where reasoning is expected to hurt, so a regression there is visible.

Use the chain for debugging, never for trust. Read it when a prompt underperforms; it will often show a misread instruction or a missing constraint. Do not surface it to end users as an explanation, do not parse it to gate actions, and do not assume a chain that mentions a check performed one. The 25 and 39 per cent figures are the vendor’s own.

Consider distillation when latency or volume rules out thinking. If a task benefits from reasoning but cannot afford it at request time, the R1, Qwen3 and s1 results say a small model fine-tuned on a reasoning model’s outputs recovers much of the gain at a fraction of the cost, and that this beats running RL on the small model yourself. Generate the traces offline, filter them by correctness as STaR did, and fine-tune.

A worked example. A team running a document-processing pipeline with three stages, extract fields from an invoice, reconcile the line items against a purchase order, and draft a dispute note if they disagree, would route the first stage to a non-thinking model at low effort, since it is extraction with a fixed schema and the instruction-following evidence argues against reasoning. The second stage is reconciliation across two documents with a checkable result, the kind of task where R1 gained nine points on FRAMES, so it goes to a reasoning model at a measured budget. The third stage is open-ended writing, where a preference-tuned model at low effort is as good and cheaper. Measured this way, the reasoning bill lands on the one stage that earns it.

Closing judgement

Reasoning models are the most important capability change since instruction tuning, and the least mysterious. The whole mechanism is on the public record: a base model, a pool of problems with checkable answers, a rule that rewards correct answers, and an optimiser that makes correct-looking behaviour more likely, followed at inference by a budget for how long the model may run that behaviour. Everything the marketing calls thinking, from self-verification to backtracking to spending longer on hard problems, is what that loop selects for, and DeepSeek showed it emerging from nothing more than the loop.

That origin explains the limits as precisely as the strengths. The gains live where the reward lived, on maths, code and science with a single right answer. Recall does not improve because nothing taught facts. Instruction following can degrade because attention goes to the problem instead of the constraint. The chain of thought is unfaithful because nothing in the reward ever asked it to be faithful. And thinking longer helps only up to a task-dependent point because the reward never penalised wandering.

For a team building products, the conclusion is the same one the evidence has pointed to since the first budget dial shipped. Reasoning is a per-request purchase. Buy it for the tasks that can be checked and need many steps, measure what it returns at two or three settings, set the budget from the measurement, and route the rest of the traffic to something fast. The mechanism tells you which bill you are paying, and it is the only thing that does.