Reasoning model
A model trained to work through a problem step by step before answering, spending extra tokens on internal deliberation. Reasoning models are slower and cost more per answer, and they earn it on planning, debugging, and multi-file changes, not on renaming a variable.
At a glance
- Also called
- Thinking model
- Trained with
- Reinforcement learning on checkable problems
- Cost driver
- Billed thinking tokens
- Best for
- Planning, debugging, multi-file changes
- Worst for
- Renames, boilerplate, format conversion
How it works
A reasoning model produces a long chain of intermediate thinking before its final reply: restating the problem, trying an approach, noticing a contradiction, backing up. That behavior comes from training, typically reinforcement learning on problems with checkable answers such as math and code, not from a prompt. OpenAI's o1 brought the approach into the mainstream in 2024, and most major model families now offer a reasoning mode.
The thinking tokens are billed and take time even when the interface hides them or shows a summary. Many APIs expose a setting for effort or a thinking budget. Higher effort usually means better answers on hard problems and noticeably longer waits, which matters inside an agent loop that may call the model dozens of times per task. Picking effort per task, rather than once per account, is where most of the savings are.
Why it matters
Extra deliberation pays off where a wrong first guess is expensive: planning a change across several modules, tracking a bug whose cause is far from its symptom, reasoning about concurrency, or reviewing a diff for logic errors. It also helps an agent decide what to inspect before it edits, which reduces thrashing in a long session.
It is wasted on mechanical work. Renaming symbols, writing boilerplate, or applying a pattern you already showed the model all run fine on a faster model at a fraction of the cost. A common split is to plan with a reasoning model and execute routine steps with a fast one.
Reasoning model versus chain-of-thought prompting
Chain-of-thought prompting asks an ordinary model to show its working, which can improve accuracy on multi-step problems. A reasoning model does this natively and was trained to make the deliberation useful: to check itself and change course. Adding "think step by step" to one is usually redundant, and the space is better spent on evidence: the error, the log, the file you suspect.
Common mistakes
- Handing a reasoning model a step-by-step script, which constrains the search it would have done on its own.
- Treating a long chain of reasoning as proof the answer is correct instead of testing it.
- Setting maximum effort as the default everywhere, which multiplies latency and spend across a team.
Related terms
Frequently asked questions
Are reasoning models always better for coding?
No. They are better at hard, ambiguous problems and slower and costlier on routine edits.
Can I see a reasoning model's thinking?
It depends on the provider. Some return the full reasoning, some a summary, and some hide it, but you pay for those tokens either way.