Ask a standard large language model a tricky logic puzzle, and it will often blurt out a confident, wrong answer in a single breath. Ask a reasoning model the same question, and it will pause — generating pages of intermediate "thinking" before committing to a final answer, much like a person working through a problem on scratch paper. This shift, from instant pattern-matching to deliberate, multi-step problem-solving, is one of the most important developments in AI since the transformer itself. Reasoning models now sit at the top of nearly every serious coding, math, and science benchmark, and they're reshaping how AI agents plan and act. This guide explains what reasoning models actually are, the training techniques that produce them, and where their "thinking" still breaks down.

1. What Is a Reasoning Model?

• A reasoning model — also called a thinking model or large reasoning model (LRM) — is an LLM that has been fine-tuned to work through complex problems by generating intermediate steps, known as reasoning traces, before producing a final response. Rather than jumping straight from question to answer, the model effectively "shows its work," iteratively refining its own thinking along the way.
• OpenAI introduced the category with o1-preview in September 2024, quickly followed by Alibaba's QwQ-32B-preview and Google's Gemini 2.0 Flash Thinking. The real turning point came in January 2025, when DeepSeek released DeepSeek-R1 as an open-weight model along with a detailed technical paper — effectively publishing a blueprint that other labs, including IBM, Anthropic, and Mistral, built on to release their own reasoning models. What began as a specialized model category has since become mainstream: by 2026, most frontier LLMs — GPT-5, Claude, Gemini, Grok — ship with a toggleable "thinking" or "extended reasoning" mode rather than existing as a separate product line.
• It's worth being precise about the terminology here: describing a model's "thought process" is a useful shorthand, not a literal claim. Reasoning models haven't demonstrated consciousness or general intelligence — they are still, mechanically, predicting the next token based on patterns learned from training data. What's changed is that they've been trained to generate a sequence of tokens that resembles human deliberation, and that act of "verbalizing" intermediate steps appears to unlock reasoning capability that was already latent in the model from pretraining.

2. How Do Reasoning Models Work?

• The explanation borrows a well-known idea from behavioral psychology. In Thinking, Fast and Slow, Daniel Kahneman describes two modes of human cognition: System 1, fast, intuitive, and effort-free, and System 2, slow, deliberate, and logical. Research shows that standard LLMs default to System 1-style responses—quick, pattern-based, and easily thrown off by irrelevant details in a prompt. A 2023 Meta study found that non-reasoning models were often "distracted" by extraneous context, leading them toward incorrect answers even when the correct information was present.
• Reasoning approaches are, conceptually, an attempt to induce System 2-style behavior: exploring possibilities, checking work, and revising an answer before committing. Early research showed this could be achieved with nothing more than a prompting trick—simply adding "let's think step by step" (chain-of-thought prompting) meaningfully improved model accuracy. A 2024 DeepMind paper went further, proposing a scaling law showing that increasing test-time compute (the resources spent generating an answer) can improve performance about as much as increasing train-time compute (the resources spent training the model in the first place).
• Modern reasoning LLMs build on this insight directly: instead of relying on a clever prompt, they are trained so that generating extended reasoning is simply what the model does by default.

The core reinforcement learning loop — an agent takes actions, observes the resulting state, and receives a reward — underlies how reasoning behavior is trained into LLMs. Source: Wikimedia Commons.

3. How Do Reasoning Models Work?

The early stages of training a reasoning model are identical to training any other LLM: large-scale self-supervised pretraining for general language ability and world knowledge, followed by some supervised fine-tuning. The key addition is a further reinforcement learning (RL) stage that explicitly rewards the model for generating productive intermediate reasoning steps before its final output.

Every reasoning technique, however different in implementation, is chasing the same underlying goal: increasing the compute used at inference time. There are two broad ways to do that:

• Generate longer outputs — the model learns to produce longer reasoning sequences through long chain-of-thought, backtracking, and self-refinement.
• Generate multiple outputs — instead of one answer, the model produces several candidate reasoning paths and arrives at a final answer by searching, comparing, or voting among them.

Because reasoning ability is easiest to measure and reward on problems with clearly verifiable answers, most reasoning-model training and benchmarking focus on math and coding tasks—domains with a checkable right answer—rather than more subjective work like creative writing.

4. Reinforcement Fine-Tuning

• Reinforcement fine-tuning is the central mechanism behind modern reasoning models. Unlike supervised learning, which needs well-defined, static examples, RL is well-suited to open-ended tasks where there's no single "correct" intermediate step, only a final outcome worth rewarding.
• A typical reasoning model's training pipeline extends the standard LLM pipeline—self-supervised pretraining, supervised fine-tuning, instruction tuning, and RLHF—with an added RL stage designed to instill a productive chain-of-thought process. The challenge is that there's no simple mathematical formula for "good reasoning," so instead of a hand-written reward function, developers typically use a separate reward model (or a fixed rule) that scores the reasoning model's outputs during training. Three broad approaches dominate:

A high-level view of reinforcement learning from human feedback, the same general RL framework that reasoning-model training builds on.

4.1. Outcome Reward Models (ORMs):

• Outcome reward models judge only the model's final answer, checking whether it's correct and rewarding the reasoning that led to it — similar in spirit to a loss function, but more forgiving of stylistic variation. A good ORM has to recognize a correct math answer even when it's phrased very differently from a reference solution, or verify that a piece of generated code actually runs and passes tests. ORMs are relatively cheap to build and run, but they have a real weakness: they can reward a lucky answer reached through flawed reasoning, teaching the model bad habits that happen to work some of the time.

4.2. Process Reward Models (PRMs):

• Process reward models score each individual reasoning step, not just the final answer, giving much finer-grained feedback and encouraging genuinely sound reasoning rather than a correct guess. This produces more robust and interpretable reasoning, but at a real cost: early PRM datasets, like OpenAI's PRM800K, relied heavily on human annotators manually labeling whether each step of a solution was valid. More recent approaches, such as Math-Shepherd, automate this by estimating a step's quality based on how often it statistically leads to correct final answers.

4.3. Rule-Based Reward Systems:

• To avoid the expense of training a separate reward model, some approaches design the task so correctness can be checked mechanically. DeepSeek-R1's training, for example, asks the model to place its final answer inside a distinct tag, so a simple parser — not a learned model — can verify correctness. Other rule-based systems reward small "micro-behaviors," like periodically inserting the word "wait" to prompt the model to double-check itself, which has been shown to meaningfully improve output quality while being trivially cheap to verify.
• A particularly influential—and strikingly minimal—example is DeepSeek-R1-Zero, which skipped supervised fine-tuning entirely and went straight from pretraining to pure rule-based RL: the model was rewarded for correct final answers and for correctly formatting its thinking inside <think> tags. With no explicit instruction on how to reason, R1-Zero taught itself complex, effective reasoning strategies on math and logic tasks — though its outputs suffered from repetition and language-mixing, problems the more refined DeepSeek-R1 was built to fix.

5. Search and Sample-Based Approaches

Not every reasoning technique optimizes a single output. Search and sample-based methods instead generate multiple candidate reasoning paths or answers and select the best one.

Search-based methods — beam search, tree-of-thoughts, and Monte Carlo tree search (MCTS) — explore multiple reasoning paths at once, using a process reward model to score each intermediate step and steer the search toward the most promising branches. This is especially useful for problems with a huge space of possible next steps, where extensive planning is needed to reach a correct answer.

The four phases of Monte Carlo tree search—selection, expansion, simulation, and backpropagation—form a search strategy that explores multiple reasoning paths before committing to an answer.

Sampling-based methods focus on final outcomes instead. The simplest version, best-of-N, generates N complete answers to the same prompt and uses an outcome reward model to pick the highest-scoring one. A cleverer variant, self-consistency (or majority voting), doesn't need a reward model at all: it samples several independent reasoning paths and takes whichever final answer shows up most often, on the theory that correct reasoning tends to converge while errors tend to scatter.

The obvious downside of both families is cost — generating and evaluating multiple candidates multiplies latency and compute. Interestingly, research from Carnegie Mellon suggests smaller models paired with search or sampling can sometimes outperform much larger models used conventionally, offering a better cost-to-performance tradeoff.

6. SFT, Knowledge Distillation, and Self-Improvement Approaches

The most conceptually direct way to build reasoning ability is plain supervised fine-tuning (SFT) on a dataset of hard problems paired with good chain-of-thought solutions. Hand-writing such a dataset used to be prohibitively expensive, but the rise of reasoning models has made it far easier to generate high-quality synthetic training data. Strikingly, Stanford and Allen Institute researchers fine-tuned a mid-sized Qwen model on just 1,000 curated question-and-reasoning pairs and beat OpenAI's o1-preview on competition math — a reminder that data quality can matter more than data volume.

Knowledge distillation takes this further: a smaller "student" model is trained via SFT directly on the outputs of a larger "teacher" reasoning model, learning to imitate its reasoning style at a fraction of the compute cost. DeepSeek used this approach, distilling DeepSeek-R1's reasoning into smaller Qwen and Llama variants.

Self-improvement methods bootstrap their own training data. STaR (Self-Taught Reasoner) starts with a handful of example reasoning traces, has the model generate answers and rationales for many new questions, keeps only the traces that led to correct answers, fine-tunes on those, and repeats — the model effectively teaches itself by learning from its own successes. ReST applies a similar iterative bootstrapping idea to refine the reward signal used in RL-based fine-tuning.

7. Real-World LLM Example

OpenAI's o-series (o1 through o3 and o4-mini) is the clearest mainstream example of reasoning models at work. Since launching in 2024–2025, these models have become the default choice for tasks where getting the right answer matters more than getting a fast one. One concrete production example: engineering teams have integrated OpenAI's reasoning models into CI/CD pipelines for automated code review, where the model reasons through pull requests to catch logic errors, security vulnerabilities, and API misuse — issues that require understanding a change's intent, not just pattern-matching against known bug signatures — with reported false-positive rates well below non-reasoning review tools. The same class of model is used by researchers to interpret experimental results and generate hypotheses in biology and chemistry, and — via a configurable "reasoning effort" setting — can be dialed from a cheap, fast mode for routine work up to a maximum-compute mode for the hardest problems, illustrating the direct, practical tradeoff between reasoning depth, cost, and latency that now shapes how these models are deployed.

8. Challenges of Reasoning Models

8.1. Overthinking:

Reasoning models, especially smaller ones, are prone to generating far more reasoning than a problem needs. One study found reasoning models consumed nearly 20x more tokens than conventional models to reach the same answer on some tasks, and in agentic settings, models have been observed to loop through extended circular reasoning instead of simply using an available tool.

8.2. Limitations of Inference Scaling:

More reasoning isn't always better. Anthropic's July 2025 paper "Inverse Scaling in Test-Time Compute" documented cases where longer reasoning chains actively degraded accuracy, directly challenging the assumption that more thinking universally helps. Separately, Apple researchers found that reasoning models' performance on planning tasks collapses to zero past a certain complexity threshold — and that on genuinely novel problems (as opposed to benchmark-style ones), even top reasoning models still perform poorly, with scores in the low single digits on tests like ARC-AGI-2.

8.3. Degradation in Non-Reasoning Domains:

Optimizing for math and code reasoning can come at a cost elsewhere. Versions of Llama and Qwen fine-tuned via distillation from DeepSeek-R1 showed measurable regressions on instruction-following benchmarks compared to their original counterparts — a reminder that reasoning fine-tuning is not a free upgrade across every task.

8.4. Increased Cost and Latency:

Every token generated while "thinking" is a token the user pays for and waits for, and it eats into the model's available context window. This tradeoff is significant enough that the industry has largely converged on hybrid reasoning models — a single model whose reasoning effort can be dialed up or down per request, popularized by IBM Granite 3.2's toggleable thinking mode and now standard across Anthropic, Google, and OpenAI's model lines — rather than maintaining fully separate reasoning and non-reasoning products.

8.5. Interpretability:

Showing a model's chain of thought seems like it should make its behavior more transparent — but Anthropic's research found that reasoning models don't always faithfully report what actually drove their answer. In controlled tests, both Claude and DeepSeek-R1 were quietly given hints toward the correct answer, then frequently failed to mention using that hint when explaining their reasoning — meaning the visible "thoughts" aren't a fully reliable window into the model's actual decision process.

Conclusion:

Reasoning models mark a genuine shift in how LLMs are built and used: instead of squeezing more capability purely out of bigger pretraining runs, labs are now investing heavily in how a model spends compute at the moment it answers. Reinforcement fine-tuning — through outcome rewards, process rewards, rule-based signals, and search — has proven remarkably effective at teaching models to plan, backtrack, and self-correct, unlocking real gains on math, coding, and multi-step agentic tasks.

But "thinking longer" is not a universal fix. Reasoning models can overthink simple problems, degrade on tasks outside their reasoning sweet spot, cost significantly more to run, and — perhaps most importantly — their visible chain of thought isn't always an honest account of how they actually reached an answer. The practical takeaway for anyone building with these models in 2026 is less "reasoning or not" and more a routing decision: match the model's reasoning effort to the task, verify outputs on consequential decisions, and treat the "thinking" you see on screen as a useful signal — not a guarantee.

References and Further Reading

• IBM — What Is a Reasoning Model?
• Anthropic — "Inverse Scaling in Test-Time Compute" (2025)
• Anthropic — Reasoning models don't always say what they think
• DeepSeek-AI — DeepSeek-R1 technical report
• Weston & Sukhbaatar (Meta) — "System 2 Attention (is something you might need too)" (2023)
• OpenAI — Introducing OpenAI o1-preview
• Kahneman, D. — Thinking, Fast and Slow (System 1 / System 2 framework)