An ordinary language model has a curious habit: it answers instantly. Give it a question and it produces the next word, then the next, marching straight from the prompt to a reply with no visible pause for thought. For a great many tasks this is fine — recalling a fact, rephrasing a sentence, drafting an email. But ask an ordinary model to multiply two large numbers, or to work through a tricky logic puzzle, or to debug a subtle piece of code, and it often stumbles, blurting out a confident answer that happens to be wrong. It behaves like a student who has been forbidden from using scratch paper and must announce the answer the instant the question is read aloud. Reasoning models are what appears when that ban is lifted. They are trained to think first — to spend time working a problem through, step by step, before committing to an answer. This piece is about what “thinking” means for a machine that only knows how to predict words, how such models are made, and what the extra room does not buy.
The problem with answering instantly
To see why instant answers are fragile, remember what a model actually does: at each step it predicts the single next word, given everything so far. All of its reasoning, such as it is, has to happen inside that one forward sweep through the tower of layers — a fixed, finite amount of computation, the same whether the question is “what is the capital of France” or “what is the fifteenth prime number times the seventh.” Easy questions and crushingly hard ones are granted exactly the same budget of thought. For a hard problem, that budget simply runs out. The model has no room to try an approach, notice it is going wrong, and back up; it must compress the entire solution into a single reflexive leap. Small wonder it so often leaps wrong.
But here is the opening reasoning models exploit. A model can use its own output as a place to think. If, instead of the final answer immediately, the model first writes out a chain of intermediate steps — “there are twelve of these, each worth five, so that is sixty, then subtract the four returned…” — then each of those steps becomes part of the input for the steps that follow. The words the model writes become scratch paper it can read back. Suddenly a hard problem is no longer squeezed into one forward pass; it is spread across dozens of them, each building on the last. This simple observation — that a model can think out loud, on the page, and lean on what it has written — is the seed of everything that follows.
Figure 1. One forward pass, or many.
Thinking out loud: the chain of thought
The practice of prompting a model to write out its intermediate steps before answering is called chain-of-thought . Early on it turned out to be summonable by nothing more than a polite instruction — appending “let’s work through this step by step” to a prompt — and accuracy on hard problems would jump, sometimes dramatically. The model already had the capability latent within it; it just needed permission to use its output as workspace.
Why does this help so much? Partly because it converts one impossible leap into a sequence of easy hops. Predicting the next small step given the work so far is a task the model is very good at, far better than predicting a distant final answer out of thin air. And partly because the written steps act as a kind of external memory. The model does not have to hold the entire half-finished calculation inside a single pass; it can offload it onto the page and read it back, the way an intermediate total gets jotted on the corner of an envelope. The chain of thought is both the reasoning and the notepad the reasoning is written on.
A reasoning model takes this from a trick you prompt for and bakes it into the model’s very nature. Rather than hoping a clever instruction will elicit step-by-step work, the model is trained so that thinking first is simply what it does — often producing a long private stretch of deliberation, sometimes called its thinking tokens, before it ever begins the answer you see.
Making a reasoning model: rewarding the right destination
So how do you train a model to think well, rather than merely at length? This is where reasoning models depart most sharply from everything before them, and the departure is worth setting out precisely.
Recall the ordinary way a model learns: it is shown mountains of text and, at each point, nudged to predict the word that actually came next. This teaches it to imitate — to sound like its training data. But genuine problem-solving cannot be taught purely by imitation, because for a truly hard problem there may be no worked solution in the data to copy, and in any case we do not really care whether the model’s reasoning looks like a human’s. We care whether it arrives at the right answer. That shift — from rewarding imitation to rewarding correct outcomes — calls for a different kind of training, one drawn from reinforcement learning: instead of being shown the answer, the model attempts the problem in its own way and is rewarded when it succeeds and discourage it when it fails.
The load-bearing part is where the reward comes from. For a large and important class of problems, correctness can be checked automatically, with no human in the loop. A math answer can be compared against the known result. A piece of code can be run against a battery of tests. A logic puzzle has a definite solution. This is the idea behind what is often called reinforcement learning from verifiable rewards : let the model generate a full chain of thought and a final answer, mechanically check whether the answer is right, and use that verdict as the training signal. Get it right, and the whole path of reasoning that led there is reinforced — made a little more likely next time. Get it wrong, and that path is discouraged. Repeat across millions of problems.
What makes this so powerful is that the model is never told how to think. It is told only whether it succeeded. Left to search for whatever reasoning earns the reward, models trained this way spontaneously develop striking habits — breaking problems into parts, checking their own work, noticing a mistake mid-stream and saying, in effect, “wait, that is wrong, let me reconsider,” and backtracking to try another route. Nobody scripted those behaviours. They emerged because they help get the answer right, and getting the answer right is what earns the reward. The model discovers, on its own, that careful deliberation pays.
The cost of the right answer, paid at inference
Once such a model exists, the second half of the story unfolds not during training but every single time the model is used. And it upends a comfortable old assumption.
For most of the field’s history, the way to make a model better was to make it bigger or train it longer — to pour more effort into building it, after which running it was a fixed, one-shot expense. Reasoning models add a second lever, pulled at the moment of use: let the model think longer. This is what people mean by test-time compute — spending more computation at the moment the question is posed, not only when the system was trained. Because the model’s thinking is written out as tokens, thinking longer literally means generating more of them: a longer chain of deliberation before the answer. And the remarkable, repeatable finding is that on hard problems, accuracy climbs with the room the model is given to think. Grant it a few hundred words of scratch work and it does better; give it room for several thousand and, up to a point, it does better still.
This is precisely the scratch-paper effect described above, now turned into a dial that can be set at will. An easy question needs only a moment’s thought and it would be wasteful to spend more. A hard one deserves a long, winding deliberation with false starts and self-corrections. The same model can do either; the only choice being made is how much room to think it is granted. There are even more elaborate ways to spend this budget — having the model explore several different lines of reasoning and then favour the answer they most agree on, for instance — but the essential insight is the humble one: a model given more time to think, on the page, tends to think better.
Two budgets, and how they trade
It is worth holding the two halves of the story side by side, because reasoning models make a genuinely new trade-off available. The first budget is the old one, spent up front: the cost of training the model. The second is spent at the moment of use: the cost of letting it think. What is striking is that these budgets can substitute for each other. A problem a smaller model can crack given room to deliberate might otherwise have demanded a far larger, costlier model answering in one shot. Accuracy can be bought either by training a larger model or by giving a smaller one longer to work, and often the second is cheaper. The accounting is set out under test-time compute , which also separates this purchase from a different one: letting one attempt think longer buys depth, sampling many attempts buys coverage, and the two fail in different places. This is why reasoning models reshaped the field’s sense of where progress comes from: not only from ever-larger training runs, but from teaching models to spend effort wisely at the moment it matters.
The trade has its limits. Thinking longer costs real time and money at every use, so a model that muses for thousands of words on a trivial question is a poor bargain — hence ongoing work on teaching models to match their effort to the difficulty of the problem, thinking hard only when hard thinking is called for. And more thinking is not infinitely helpful; beyond some length the gains flatten, and a model can even talk itself out of a correct answer. Deliberation is a powerful tool, not a magic one.
Figure 2. Two budgets that substitute for each other.
Passing the skill along
There is a coda, and it connects to a technique worth knowing on its own. A large, expensive reasoning model that has learned — through all that costly reinforcement — to produce excellent chains of thought can serve as a teacher. It works through a great many problems, the good reasoning traces are collected, and a much smaller model is trained to imitate them. The small model never has to rediscover how to reason through the expensive search; it simply learns to copy the worked-out thinking of a model that already knows how. This is distillation applied to reasoning traces: the hard-won skill of deliberation, transferred from a giant into something lean enough to run cheaply. It is much of the reason capable reasoning is now available in models small enough to run almost anywhere.
Figure 3. From prompt trick to trained habit to distilled skill.
What to carry forward
Ordinary models answer in a single reflexive leap, granting every question the same fixed sliver of thought — which is why they stumble on genuinely hard problems. Reasoning models lift that constraint by letting the model think out loud, writing a chain of intermediate steps that becomes scratch paper it can read back, spreading a hard problem across many passes instead of cramming it into one. They are trained not to imitate human reasoning but to reach correct answers, using reinforcement learning with rewards that can be checked automatically — right answer, reinforce the path; wrong answer, discourage it — from which habits like self-checking and backtracking emerge on their own. And crucially, their quality can be dialled up at the moment of use by letting them think longer, a lever called test-time compute that can substitute for sheer model size. The result is a genuinely new way to spend effort: not only in building the model, but in giving it room to think before it speaks, and through distillation in handing that skill down to models small enough for everyday use. The room is not free and it is not unbounded. Thinking is billed at every use rather than once at training, beyond some length the gains flatten and a model can talk itself out of a correct answer, and the trace that makes the deliberation visible is not therefore a description of it — deliberation is a powerful tool and not a magic one.
The figures in this article follow the shared figure key , which explains what every shape, line style and colour means.
