Ask a reasoning model a hard question and it stops, "thinks" for a few seconds, then replies. This guide opens up that pause: what the model is doing in it, how it learned to do it, why it is different from a chatbot with a clever prompt or an agent in a loop, and how Claude's approach and the GPT reasoning family differ.
If your gut said 10 cents, you are in excellent company and you are wrong; the ball is 5 cents. The fast, fluent, confident answer is the trap. Now watch two AI models meet the same kind of question.
The pause is the whole story. In those seconds the reasoning model was not waiting or searching the web. It was writing, to itself, the working you would write on scrap paper. This guide is about what that writing is, how the model learned to produce it, and why it is a different thing from the tricks that came before it.
The tempting explanation is that the reasoning model is simply a bigger, cleverer brain. Usually it is not much bigger at all. What it does differently is spend more computation at the moment you ask, generating a long private train of thought before committing to an answer. Researchers call this test-time compute: paying with time and tokens, at the moment of the question, to buy accuracy.
You may remember the "let's think step by step" prompt, which nudged a normal model to show its working. A reasoning model is that idea taken all the way: instead of being asked to think, it was trained to think, deeply and by default. The difference between asking and training is the difference between the whole rest of this guide.
Here is the definition, now that the need for it is felt. A reasoning model generates a long internal chain of thought, in ordinary language, before it produces its final answer. That thinking is just more of the same token-by-token generation the model always does, except it is aimed inward, at working the problem out, rather than at you.
Two things make it more than a prompt trick. The reasoning is trained into the model, not requested at runtime, so it happens reliably and skillfully. And the amount of it can be turned up or down: more thinking for a hard proof, less for a simple question. The next chapter lets you watch a real-shaped thinking trace unfold, so the abstract "chain of thought" becomes concrete tokens on a page.
This is what fills the pause: the model's own words, working the problem. Scroll, and read a real-shaped reasoning trace appear the way the model generates it, one thought at a time, before the short answer drops out at the end.
A small word problem. A standard model might blurt "20" by dividing 60 by 3. The reasoning model starts writing to itself instead.
It names the unknown and writes the relationships as it understands them. Nothing clever yet, just careful bookkeeping that a fast answer skips.
It does the arithmetic, then pauses to check it against the total. This self-check, catching its own mistake, is the behavior training rewarded most.
With the check passing, it commits. Notice how much thinking preceded a one-line answer. The thinking is most of the tokens; the answer is a sliver.
Only now does it address you. Everything above was private working. In many products you see a tidy summary of it, not the raw thing.
This is the question that trips up everyone, so here it is head-on. Three different things all involve a model "reasoning," and they are not the same. Click each to see exactly where the reasoning lives, how many model calls happen, and where the loop is, if there is one.
Keep the reasoning model and the external loop clearly apart in your head, because chapter 10 shows the twist: you can put a reasoning model inside a harness and get both at once. First, the schooling.
So where did the skill come from? Not from being told how to reason. From practice with a scorekeeper. The model attempts a problem, an automatic checker sees whether the final answer was right, and reasoning that led to right answers gets reinforced. Do that on millions of problems and good reasoning emerges. Scroll the loop.
Training uses problems that can be graded automatically: math with a checkable result, code that either passes tests or does not. The right answer is known in advance.
The model generates a full reasoning trace and an answer. Early in training this is often rambling and wrong. It tries many different lines of thought across many attempts.
An automatic grader compares the final answer to the known one. Right or wrong, no human needed. This is why math and code lead: the reward is cheap and objective.
Traces that reached the right answer are made more likely; traces that failed, less likely. The model is not told the correct method. It is only told which of its own attempts paid off.
Millions of rounds later, the habits that keep producing right answers, setting up, checking, backtracking, are baked in. Nobody wrote those habits. The scorekeeper grew them.
The defining dial of reasoning models is how long you let them think. Below is the accuracy of a reasoning model plotted against its thinking budget. Drag the budget and watch the curve. Then flip the problem from hard to easy and notice the whole story change.
Two lessons sit in that curve. Thinking has sharply diminishing returns, so there is a sweet spot past which you burn time and money for almost nothing. And thinking only helps in proportion to how hard the problem is; on easy questions a reasoning model is a slow, pricey way to get an answer a fast model already had. Matching the budget to the problem is the real skill.
Both Anthropic and OpenAI ship reasoning models, and the underlying idea is the same one you just saw. What differs is the product philosophy: how much of the thinking you see, and how much control you get over it. Click each dimension to compare. A note on names first: reasoning models are recent (the GPT o-series, and Claude's extended thinking). GPT-3, from 2020, was not one, so if you are comparing "Opus 4.8 vs GPT-3," you are really comparing a reasoning model against a plain one.
Strip the branding and the picture is simple. Both learned to reason from checkable rewards; both spend test-time compute; both let you dial effort up or down. One leans toward showing you a summary of its thoughts and handing you the budget dial directly; the other leans toward hiding the raw thoughts and managing the effort for you. Neither choice is wrong. They serve different tastes for transparency and control.
The test-time curve already told you when a reasoning model earns its keep, but here it is as a rule of thumb you can act on. Reach for a reasoning model when the task has many steps and a checkable outcome: math, algorithms, debugging, logic puzzles, careful planning, anything where a wrong intermediate step sinks the whole answer.
Skip it, and use a fast standard model, when the task is quick, open-ended, or latency-sensitive: casual chat, simple lookups, drafting, brainstorming, autocomplete. There, the pause is pure cost. Paying a reasoning model to think hard about "reword this sentence" is like hiring a structural engineer to hang a picture.
Now the payoff from chapter 05. A reasoning model and an agent harness are not rivals; they stack. Inside a ReAct loop, each turn can be handled by a reasoning model. So on every step, the model thinks deeply in its own head and then takes an external action, reads the real result, and thinks again on the next turn.
That is the shape of the strongest AI systems today: an external loop that gives the model tools and memory, wrapped around an internal reasoning that makes each individual decision sharp. The outer loop supplies the hands and the world; the reasoning model supplies the careful thought behind each move. One loop you can see, one you cannot, working together.
Watching a model reason feels like watching it be honest. It is not quite that, and the gaps matter.
The trace is not a faithful log. Research keeps finding that the written reasoning is not always how the model truly reached its answer. It can produce clean steps and a wrong answer, or reach a right answer by a route its trace does not mention. Read the thinking as a useful artifact, not a confession.
More thinking can hurt. Past the sweet spot on that curve, models sometimes talk themselves out of a correct answer, or loop without progress. Longer is not reliably better, which is exactly why the budget is a dial and not a maximum.
It costs real time and money. Those thinking tokens are generated, and in most products you pay for them and wait for them. A reasoning model on every request is a way to make a cheap product slow and expensive.
Hidden reasoning cannot be audited. When a product hides the raw thoughts and shows only a summary, you are trusting that the summary is faithful. For high-stakes or regulated use, that opacity is a real limitation, not a detail.
The pause is the model thinking in its own words.
It learned to, from a scorekeeper, not a teacher.
It is not a prompt and not a loop in your code; the loop was the training.
Spend its thinking on hard problems, and let fast models handle the rest.
Put it together. Pick how hard the task is and how much thinking you allow, and read what you get for it: accuracy, and the cost and latency you paid. The presets are three real situations. Watch how the right amount of thinking depends entirely on the task.
Seven rabbit holes the main path stepped around. Each stands alone.