How reasoning models work: AI that thinks before answering

For a few years, all large language models worked the same way: you asked a question, and the model answered immediately, generating its response one token at a time with no pause to plan or reconsider. It spoke as it thought, committed to each word as it went. Then, in late 2024 and through 2025, a different kind of model arrived, and it changed what the frontier looks like. Models like OpenAI's o1 and o3, DeepSeek-R1, and the "thinking" variants from other labs do something the earlier ones could not: they stop and think first, working through a problem privately before writing a single word of the answer.

These are called reasoning models, and 2025 to 2026 marks their emergence as a distinct category, not just bigger versions of what came before but a different kind of system doing something new. This piece covers what they actually do, the idea (chain of thought) at their heart, how they were trained to reason, the new form of scaling that powers them, and the honest trade-off of when their extra deliberation is worth the wait and cost. The short answer to what they are: a reasoning model is a student who reaches for scratch paper, works through the problem, checks the work, and only then writes the final answer, except the scratch paper is invisible, happening inside the model before you see anything.

What a regular model can't do

To see what is new, start with the limitation reasoning models overcome. A standard language model generates its answer directly, predicting each next token in a single forward flow. This is fast and works impressively well for a huge range of tasks, but it carries a built-in constraint: the model has no opportunity to pause, plan, reconsider, or check itself before committing. It produces the answer in one pass, and whatever reasoning happens has to happen implicitly, inside that single stream of output. For easy questions this is fine. For hard ones, problems in mathematics, multi-step logic, or intricate code, it is a real handicap, because hard problems usually require working through intermediate steps, trying an approach, noticing it fails, and backtracking. A model that must answer in a single pass cannot do that.

Reasoning models remove this constraint by giving the model room to deliberate before answering. That room is filled with a chain of thought.

Chain of thought: the core idea

The mechanism at the center is chain-of-thought reasoning: instead of jumping to an answer, the model generates a sequence of intermediate reasoning steps, working the problem out in stages, and only then produces the final result. Breaking a hard problem into a series of smaller steps makes each step easier and lets errors surface and get corrected along the way, much as showing your work on paper helps you catch a mistake you would miss doing it all in your head.

This idea has a specific and instructive history. It began in 2022 as a prompting trick: researchers found that simply adding "let's think step by step" to a prompt caused a standard model to lay out intermediate reasoning and, in doing so, solve problems it otherwise got wrong. The words did not add knowledge; they gave the model permission and structure to use the reasoning latent in its training. That discovery was powerful but limited, because it depended on the user knowing to ask, and the model was never actually trained to reason well, only nudged into it. The leap that created reasoning models was turning this from an external trick into a trained-in capability. Rather than hoping a prompt elicits step-by-step thinking, these models are trained so that generating a long, careful chain of thought before answering is simply what they do, every time, automatically.

How they learned to reason: reinforcement learning

The training that produced this is worth understanding, because it connects to a larger story. Reasoning capability is installed mainly through reinforcement learning, and specifically through a version that rewards correct answers on problems whose answers can be checked.

The approach, covered more fully in the pieces on reinforcement learning and how models are trained, is RLVR, reinforcement learning with verifiable rewards. You take problems where correctness can be verified automatically, a math answer that either checks out, code that either passes its tests, and you reward the model for reaching the right final answer, letting it generate long chains of thought along the way. Because the reward depends only on the final answer being correct, the model is free to discover whatever reasoning process gets it there. And what it discovers, on its own, is striking: it learns to break problems down, to try an approach and abandon it when it stalls, to double back, and to check its own work, behaviours that emerge from the training rather than being explicitly programmed. DeepSeek-R1 made this point vividly by showing that strong reasoning could emerge from reinforcement learning applied to a base model, largely without hand-written examples of good reasoning, the model essentially taught itself to reason by being rewarded for correct answers. (Some models add a warm-up on curated reasoning examples first for stability, and reasoning ability can also be transferred to smaller models by distillation, training them on a reasoning model's traces.)

Test-time compute: a new axis of scaling

Reasoning models introduced a new lever, and it is one of the most important ideas in recent AI: test-time compute. For years, the way to make models better was to make them bigger and train them on more data, a scaling of training. Reasoning models scale something different: the compute spent at the moment of answering.

The insight is that letting a model think longer, generate a more extensive chain of thought, explore more approaches, verify more carefully, improves its answers on hard problems, sometimes dramatically. This is a different resource from model size. A reasoning model can solve problems that defeat a much larger standard model, not because it knows more, but because it spends more effort thinking at inference time. It is the difference between a brilliant person forced to answer instantly and a merely capable one given an hour and a notepad. This reframed part of the field's ambition: the best systems of the next few years may not simply be the ones that know the most, but the ones that think most effectively with the compute they are given, and a striking demonstration was reasoning models reaching scores on hard abstract-reasoning benchmarks that had resisted the larger models before them.

You pay for this thinking, literally. The chain of thought consumes tokens and time, which is the source of the central trade-off below.

What the thinking looks like, and whether you see it

Inside the deliberation, the model is doing something like a search: proposing steps, reflecting on them, backtracking from dead ends, and validating its progress before settling on a final answer. Two design choices differ across models. Some, like OpenAI's o-series, keep the chain of thought hidden, doing the deliberation internally and showing you only the polished final answer. Others, like DeepSeek-R1, make the reasoning visible, exposing the full chain of thought (in R1's case wrapped in explicit thinking tags), which lets you watch how the answer was reached and spot where it went wrong. Visible reasoning aids transparency and debugging; hidden reasoning keeps the interface clean and protects the raw chain from being copied. Either way, the pattern is the same: extended internal thinking, then a final answer.

When reasoning models are worth it, and when they are not

An honest account has to be clear that reasoning models are not simply better, they are a trade, and using them well means knowing which side of the trade you are on. The cost is real: reasoning models are slower and more expensive than standard ones, because you are paying for all those thinking tokens, and for a simple question the deliberation is wasted effort, a slow, costly way to answer something the standard model would have gotten instantly.

The rule of thumb: reasoning models earn their cost on problems that actually require thinking, competition-level math, complex coding, multi-step logic, scientific analysis, and they are overkill for the routine tasks that make up most everyday use, summarising, drafting, simple questions, formatting. Reaching for a reasoning model by default wastes time and money; reaching for a standard model on a hard problem leaves accuracy on the table. Match the tool to the difficulty.

There is also a subtler limitation worth flagging, one connected to the piece on why AI hallucinates: more thinking is not uniformly better. On open-ended factual questions, extended reasoning can sometimes give a model more room to construct elaborate but wrong justifications, and reasoning does not repeal a model's tendency to be confidently mistaken. Reasoning models are a large step forward on problems with a checkable structure; they are not a cure for every weakness of language models.

Where this is heading: adaptive reasoning

The frontier direction resolves the trade-off elegantly by making it automatic: adaptive reasoning, where the model itself decides whether a question needs deliberation and how much. Rather than a fixed "always think hard" setting, newer systems aim to think briefly on easy questions and extensively on hard ones, spending test-time compute in proportion to difficulty. This is the natural maturation of the idea, from a prompting trick anyone could invoke, to a trained-in reflex that always fires, to a controllable resource the model allocates as needed, which is where the most capable systems are converging.

The short version

Reasoning models are language models trained to generate an extended internal chain of thought, working a problem out step by step and checking themselves, before producing a final answer, rather than answering in a single immediate pass. They learned this mainly through reinforcement learning that rewards correct answers on verifiable problems, discovering useful reasoning behaviours like backtracking and self-checking on their own. Their power comes from test-time compute, a new scaling axis where thinking longer at inference improves hard-problem accuracy independently of model size. The trade-off is that they are slower and costlier, worth it for hard problems in math, code, and logic, and wasteful for simple tasks.

The idea to hold onto is that a reasoning model does not know more than a standard model so much as it thinks more before it answers, spending compute at the moment of the question to deliberate, and that turns problems that need working-out from failures into successes. The previous era scaled what models know by making them bigger. This era also scales how hard they think, and for the problems that actually require thought, that turns out to matter just as much.

Common questions

What is a reasoning model? A reasoning model is a language model trained to think before it answers, generating an extended internal chain of thought, working through a problem step by step, trying approaches, and checking itself, before producing a final response. Examples include OpenAI's o1 and o3, DeepSeek-R1, and the "thinking" variants from other labs. Unlike standard models that answer immediately in one pass, reasoning models spend extra compute at the moment of answering to deliberate, which makes them much better at hard problems in math, coding, and logic.

What is chain-of-thought reasoning? Chain-of-thought is the technique of having a model generate intermediate reasoning steps rather than jumping straight to an answer. Breaking a hard problem into smaller steps makes each easier and lets mistakes surface and be corrected, much like showing your work on paper. It began in 2022 as a prompting trick (adding "let's think step by step" improved answers), and reasoning models turned it from an optional prompt into a trained-in behaviour the model performs automatically before every answer.

How are reasoning models different from regular LLMs? A regular language model answers immediately, generating its response in a single pass with no chance to pause, plan, or check itself. A reasoning model first produces an extended internal chain of thought, deliberating and self-correcting, before writing the final answer. The practical result is that reasoning models solve hard multi-step problems that standard models reliably fail, at the cost of being slower and more expensive. They are a different kind of model, not just a bigger one, spending inference-time compute on structured thinking.

What is test-time compute? Test-time compute is the computation a model spends at the moment of answering, as opposed to the compute used to train it. Reasoning models introduced it as a new scaling axis: letting a model think longer, generating a more extensive chain of thought and exploring more approaches, improves accuracy on hard problems, sometimes dramatically, independently of how big the model is. It means a reasoning model can outperform a much larger standard model on hard tasks by thinking harder rather than knowing more.

How were reasoning models trained to reason? Mainly through reinforcement learning with verifiable rewards (RLVR): the model is given problems whose answers can be checked automatically, like math or code, and rewarded for reaching the correct final answer while generating long chains of thought along the way. Because the reward depends only on final correctness, the model discovers effective reasoning strategies on its own, learning to break problems down, backtrack, and self-verify. DeepSeek-R1 showed that strong reasoning could emerge from reinforcement learning largely without hand-written reasoning examples.

When should I use a reasoning model? Use one when the problem requires multi-step thinking: competition-level math, complex or subtle coding, intricate logic, or careful scientific and analytical work. Avoid them for routine tasks like summarising, drafting, simple questions, or formatting, where their deliberation is wasted and a standard model answers instantly at lower cost. The trade-off is accuracy on hard problems versus speed and cost, so match the model to the difficulty rather than defaulting to reasoning for everything.

Do reasoning models still hallucinate? Yes. Reasoning helps most on problems with a checkable structure, like math and code, but it does not cure a model's tendency to be confidently wrong. On open-ended factual questions, extended reasoning can even give a model more room to build elaborate but incorrect justifications. Reasoning models are a significant step forward on hard, verifiable problems, but they are not a general fix for hallucination, and their answers still need checking on factual matters where there is no built-in way to verify correctness.