TL;DR: A reasoning model works through a problem before answering it - generating internal "thinking" tokens where it explores, checks itself, and backtracks, then delivers the conclusion. That extra computation buys real accuracy on math, code, and multi-step planning, and costs real time and tokens. Use one where being right matters more than being fast.
How it works
A standard chat model commits to its answer as it streams - each token is final, so an early arithmetic slip propagates to the end. Prompt engineers long worked around this by asking models to "think step by step". Reasoning models bake the workaround into training: using reinforcement learning on problems with checkable answers (does the proof hold, does the code pass the tests), the model is rewarded for whatever internal process reaches correct results. What emerges looks like deliberation - trying an approach, noticing it fails, backing up, verifying a candidate answer - written out in tokens before the final response. Ask "what is the cheapest way to ship these five packages given these carrier rules" and a reasoning model will enumerate cases and catch its own errors mid-stream; a standard model produces one confident pass.
The deeper shift is economic: this is test-time compute - spending more computation at inference to get a better answer from the same weights, a second scaling dial alongside making models bigger. Accuracy on hard problems climbs as the model is allowed to think longer, which is why providers expose an effort or thinking-budget control: low for quick tasks, high for hard ones. Most APIs bill those thinking tokens as output even when the raw trace is hidden or summarized, so a "short" answer can carry a long invisible cost - worth watching in cost tracking.
When to reach for one: math, hard debugging, multi-step planning, dense document analysis, and agentic work where one wrong step derails a chain - reasoning models are a natural fit for AI coding agents. When not to: summarization, casual chat, extraction, and latency-sensitive paths, where thinking adds cost and delay for little gain. The lines are blurring - many current models are hybrids that decide, or let you decide, how much to think per request - but the cost-accuracy trade remains yours to make when choosing a model.
One caveat: the visible trace reads like a transcript of thought, but research shows it is not always faithful to what actually drove the answer. Treat it as a useful debugging artifact, not testimony.
Where it sits in the AI stack
Reasoning models insert a thinking phase between the prompt and the answer, spending extra inference compute to raise accuracy:
Key tools and implementations
-
Extended thinking modes
Hybrid frontier models where you dial reasoning effort up or down per request.
-
Dedicated reasoning series
Model lines trained primarily for deliberation on math, science, and code.
-
Open reasoning models
Open-weights releases with visible thinking traces you can run and study yourself.
-
Thinking-budget controls
API parameters that cap or target how many tokens the model may spend deliberating.
Related entries
- Inference Running a trained model to produce output - the phase where every user request is actually served.
- Token The chunk of text - roughly three-quarters of a word - that a language model reads and writes one at a time.
- Choosing a model A framework for weighing capability, latency, cost, privacy, and openness when picking a model for a task.
- AI coding agent Software that plans and executes multi-step coding tasks - reading files, editing code, and running tests with minimal supervision.