Reasoning models: what thinking before answering means

A reasoning model answers your question by first writing a long piece of text that you mostly do not see: trying an approach, noticing it does not work, backing up, checking arithmetic, considering an edge case. Only then does it produce the reply. Mechanically it is the same next token prediction as any other model, but it has been trained to spend hundreds or thousands of tokens working before committing, and that extra computation at answer time is what buys the accuracy. The trade is simple and worth stating up front: you get materially better results on problems with many dependent steps, and you pay several times more for answers that arrive in seconds or minutes rather than instantly.

Why more thinking actually helps

A standard model commits to each token as it goes. If it takes a wrong turn in step two of a seven step problem, everything after that inherits the error, and there is no mechanism to go back. The answer is produced in one forward pass through the problem.

A reasoning model is trained to use its own output as a scratchpad. It can write out an intermediate result, notice that it contradicts something earlier, and try again. Because that work happens in tokens, and tokens are the model's only workspace, giving it more of them genuinely gives it more room to think. This is often called test time compute: instead of making the model bigger, you let the existing model work longer on each question.

The training for this usually involves problems where the answer can be checked automatically, such as competition math and programming tasks. The model generates many attempts, the ones that reach the right answer are reinforced, and over time it learns the habits that lead there: decomposing the problem, checking units, testing an example, questioning its own first instinct.

What the visible thinking is, and is not

Most products show you something while the model works. Read it with care, because it is not a log.

In most cases what you see is a summary, generated separately, of a much longer hidden reasoning trace. Even where the raw trace is shown, it is still generated text produced by the same prediction process as everything else. It is not an instrumented record of the computation inside the network, and research on this has repeatedly found that models can reach an answer for reasons their stated reasoning does not mention.

The practical consequence: a tidy, confident chain of steps is not evidence that the answer is right, and you cannot debug a wrong answer by auditing the displayed thinking. Treat it as useful context about the approach taken, and verify the answer itself on its own terms. This is the same trap described in how a language model actually works, where fluency and correctness come from one process and neither signals the other.

When it is worth the wait

How to use one well

1. Give it the whole problem at once, including every constraint. Reasoning models handle a dense, complete brief better than a drip feed, and each follow up restarts the expensive thinking.
2. State what "correct" means. "The totals must reconcile to the invoice figure" or "the schedule must not put anyone on two consecutive nights" gives the model something to check itself against.
3. Do not micro manage the method. Telling a reasoning model to think step by step is redundant, and prescribing your approach can block a better one.
4. Ask for a short verification section at the end: the key numbers recomputed, or the constraints listed with a tick against each. That gives you something checkable.
5. Use a fast model for everything else in the workflow, and call the reasoning model only for the hard step.

That last point matters for cost. A realistic pattern is a cheap model extracting and formatting data, a reasoning model doing the one calculation that must be right, and a cheap model writing it up.

Cost, latency and limits in practice

Because hidden thinking tokens are billed as output, a reasoning request commonly costs several times an ordinary one for the same visible answer length, and occasionally far more on a hard problem. Latency moves from roughly a second to anywhere from a few seconds to a couple of minutes. Many products let you choose an effort level, and the honest advice is to start at the lowest setting that solves your problem and raise it only when you see failures.

On consumer plans, reasoning modes are typically the feature that separates free from paid tiers, usually with a quota per day or per week. Free versus paid AI covers where those lines usually fall.

One limit does not move: reasoning improves derivation, not knowledge. It will not tell you what changed in a law last month, and it will not stop the model inventing a citation. For arithmetic in particular, the reliable route is still to have the model write out a calculation you can check or code you can run, which is covered in why AI struggles with math.

What to try first

Take the task you most recently gave up on because the answer was subtly wrong, and run it once on a fast model and once on a reasoning model with the constraints stated explicitly. Compare not just the answers but the time and the cost. Most people find one or two tasks where the difference is dramatic and a long list where it is not worth a cent extra, and knowing which is which is the whole skill.