For most of the modern AI era, the way to make a model better was to make it bigger and train it on more data. Reasoning models added a second axis: spend more computation at the moment the question is asked.
The insight is mundane when stated plainly. Hard problems benefit from working through them rather than answering immediately. The consequences for cost, latency and capability are not mundane at all.
From prompting trick to trained behaviour
The precursor was a prompting discovery: appending something like “think step by step” improved accuracy on multi-step problems. This worked because a model generating text conditions on what it has already written, so intermediate steps become available as scaffolding for later ones. The reasoning happens in the output, not before it.
Reasoning models internalise this. Rather than relying on the user to request deliberation, the model is trained to generate an extended internal chain of thought before committing to an answer. Those intermediate tokens are generated, consumed as context, and then generally discarded.
How they are trained
What is publicly established: reasoning is trained with reinforcement learning. OpenAI states directly that its reasoning models are trained to reason through RL. The most fully documented public recipe remains DeepSeek’s R1, which used reinforcement learning with verifiable rewards — a checker confirms whether the final answer is right, and the model is rewarded accordingly. Notably, coherent step-by-step reasoning emerged from this process rather than being demonstrated in training examples.
This explains the capability profile. Training requires automatic verification, which exists for mathematics, code and formal logic — and precisely there is where reasoning models post their largest gains. Domains where correctness is subjective lack the training signal, and the labs are conspicuously quiet about how they handle them. Whether process supervision (rewarding good intermediate steps) or purely outcome supervision is used at scale is undisclosed across every frontier lab.
The reasoning budget is now a dial
The practically important development is that how hard a model thinks has become a parameter you set per request. As of September 2026 every major provider exposes some version of this — effort or reasoning-effort levels, thinking levels, or adaptive modes where the model decides for itself.
Two things are worth knowing. The vocabularies are not portable between providers or even between models from the same provider — the levels differ, the defaults differ, and some models reject settings others accept. Treat reasoning configuration as a model-specific contract, not a standard feature.
And raw chains of thought are generally not returned. Providers expose summaries at most. You pay for those tokens, they occupy your context window, and you usually cannot read them. The stated rationale is a mix of competitive protection and a safety argument: a chain of thought the model has not been trained to sanitise is more useful for monitoring if the model is not optimising its appearance.
What it costs
- Tokens. Reasoning tokens bill as output tokens, the expensive kind. A model thinking extensively before a short answer can cost many times what the visible response suggests.
- Latency. Thinking is generation, and generation is sequential. High-effort responses can take substantially longer, which rules the approach out for genuinely interactive uses.
- Context. Reasoning tokens consume the same window as everything else.
Two findings that complicate the picture
Reasoning does not uniformly help, and on some tasks it hurts. Extended reasoning shows little benefit on straightforward retrieval, summarisation or formatting, where it mainly adds cost. More troublingly, there is consistent evidence that reasoning modes increase hallucination rates on grounded summarisation tasks, sometimes by a factor of two or three relative to the same model’s non-reasoning mode. The plausible explanation is that a model reasoning at length about a document generates more opportunity to drift from it. See why AI models hallucinate.
Effort level makes benchmark comparisons treacherous. The same model at different effort settings produces materially different scores. Any published comparison that does not state the effort level, harness and tool availability is not reporting a number you can use. This problem is now pervasive — see AI benchmarks explained.
Choosing a setting
The practical rule: match effort to whether the task actually has a hard step. Mathematics, debugging, multi-constraint planning, anything with a verifiable answer reached through several dependent steps — reason hard. Extraction, reformatting, classification, drafting, and anything grounded in a document you have supplied — reason minimally and save the money.
Last reviewed: September 2026. Reasoning-control APIs are changing rapidly and differ by provider; verify current parameters against vendor documentation.
