Reasoning models are language models specifically trained to generate extended, explicit intermediate reasoning steps before producing a final answer — substantially improving performance on tasks requiring multi-step logical, mathematical, or planning reasoning.
The Core Idea: Thinking Before Answering
A standard language model generates its response token by token, immediately, without any dedicated space to "think through" a complex problem first. Reasoning models are trained to first produce a — often much longer — chain of intermediate reasoning (sometimes explicitly hidden from the final user-facing output) before committing to a final answer, closely related to but going considerably further than the prompting-based chain-of-thought technique.
Why Extended Reasoning Improves Accuracy on Hard Problems
Complex problems (multi-step math, intricate logic puzzles, non-trivial planning) often can't be solved correctly in a single, immediate forward pass through a network — they genuinely benefit from working through intermediate steps, checking intermediate results, and sometimes backtracking from an unproductive line of reasoning, much as a human solving a hard problem on paper benefits from writing out their work rather than trying to state the final answer immediately.
How Reasoning Models Are Trained
| Approach | Core Idea |
|---|---|
| Reinforcement learning on reasoning traces | Training the model to generate reasoning chains that lead to more often-correct final answers, using the correctness of the final answer as a reward signal |
| Fine-tuning on high-quality reasoning examples | Training on demonstrations of detailed, step-by-step problem-solving, teaching the model to produce similar reasoning patterns |
| Inference-time scaling | Allowing the model to generate substantially more tokens of intermediate reasoning at inference time for harder problems, trading additional compute for higher accuracy |
Code — Illustrating the Reasoning-vs-Direct-Answer Distinction
# A direct-answer prompt
direct_prompt = "What is 47 * 89 - 123?"
# A reasoning-encouraging prompt (or a reasoning model's natural default behavior)
reasoning_prompt = """Solve step by step, showing your work:
What is 47 * 89 - 123?"""
# Reasoning models tend to produce something like:
# "First, 47 * 89 = 4183. Then, 4183 - 123 = 4060. The answer is 4060."
# -- explicit intermediate steps, each independently checkable, rather than
# a single immediate (and more error-prone) final numberThe Real Cost: More Compute and Latency
Generating extended reasoning before a final answer takes meaningfully more tokens, and therefore more inference compute and latency, than producing a direct answer immediately. This is a genuine, real tradeoff — reasoning models are most valuable specifically for problems that actually benefit from multi-step reasoning, and can be unnecessarily slow and costly overkill for simple queries that don't need it.
Common Mistakes
- Using a reasoning model (with its higher latency and cost) for simple queries that don't actually require multi-step reasoning — matching the model choice to the task's actual complexity avoids unnecessary cost and latency.
- Assuming extended reasoning guarantees a correct final answer — reasoning models substantially improve accuracy on hard problems, but can still make errors within their reasoning chain, including sometimes confidently reasoning toward an incorrect conclusion.
Interview Relevance
Q: "Why does allowing a language model to generate extended intermediate reasoning before its final answer often improve accuracy on complex, multi-step problems?" A standard model committing to an answer immediately, in a single forward pass, has no dedicated mechanism to work through intermediate steps, verify partial results, or reconsider an unproductive approach — complex problems (multi-step math, intricate logic) often genuinely require this kind of stepwise work to solve reliably, much as a person benefits from writing out their work rather than stating a final answer to a hard problem immediately. Generating explicit intermediate reasoning gives the model an analogous "space to work," at the real cost of more tokens generated and correspondingly more inference compute and latency.
Practice Question
Why would using a reasoning model for a simple factual lookup query (e.g. "What is the capital of France?") likely be an unnecessary and wasteful choice?
