One of the most significant recent shifts in AI is a class of models that, instead of answering immediately, visibly work through a problem first — generating intermediate reasoning before committing to a final answer. They're often called reasoning models, and they represent a genuine change in how performance is bought. Understanding what that extra "thinking" actually does — and where it doesn't help — is key to using them well.

The core idea

A standard language model produces its answer in a single forward pass: question in, answer out, no visible deliberation. That works well for many tasks but struggles on problems that genuinely require multiple steps of reasoning — a hard maths problem, a logic puzzle, a multi-stage analysis. The model has to leap straight to the answer, and on complex problems it often leaps wrong.

Reasoning models change the deal. They're trained to generate a chain of intermediate steps — working through the problem, considering approaches, checking themselves — before producing the final answer. This is sometimes described as letting the model "think out loud," and the analogy is apt: just as a person solves a hard problem better with scratch paper than in their head, a model that can lay out intermediate steps can solve harder problems than one forced to answer instantly.

The mechanism for why this helps is intuitive. Each generated step becomes part of the context the model conditions on for the next step, so the model can break a hard problem into a sequence of easier ones and build toward the answer incrementally, rather than having to produce the whole solution in one shot. More steps mean more intermediate computation devoted to the problem.

What it costs

This power isn't free, and the cost lands somewhere specific. Generating a long chain of reasoning means generating a lot of tokens before you ever get the answer — which means more compute and more time at inference, per question. The model is, quite literally, spending more thinking to answer harder questions.

This is a notable shift in where AI's costs sit. Historically the dominant cost was training — enormous upfront expense, then cheap inference. Reasoning models move a meaningful share of cost to inference: you pay extra each time you ask a hard question, in proportion to how much thinking it needs. That has real consequences. It changes the economics (hard queries are now genuinely more expensive to serve than easy ones), and it changes product design (you want to spend the expensive deep-reasoning effort only where it's warranted, and answer easy questions cheaply).

Where the gains are real — and where they aren't

The crucial nuance, often lost in the excitement, is that extra reasoning helps unevenly. It's not a universal upgrade.

The gains are largest on problems that are multi-step and verifiable — where the answer can be reached by decomposing into sub-steps, and where being able to check work along the way pays off. Mathematics, logical reasoning, coding, structured analysis: these are exactly the domains where "thinking before answering" delivers dramatic improvements, because they have the structure that step-by-step reasoning exploits.

The gains are much smaller — sometimes negligible — on tasks that don't decompose this way. A question of taste, a piece of creative writing, a simple factual lookup, a judgement that doesn't break into verifiable sub-steps: throwing more reasoning at these often adds cost without adding much quality. The extra thinking has nothing useful to chew on. Worse, on some tasks excessive deliberation can even hurt, as the model talks itself out of a correct initial instinct.

Using them well

The practical takeaway is to match the tool to the task. Reasoning models are a powerful, genuinely new capability for the class of hard, structured, multi-step problems where decomposition and self-checking pay dividends — and on those problems the improvement can be striking. But they're not a free upgrade to slap on everything; on tasks that don't decompose, you're paying inference premium for little return. The sophisticated move, increasingly, is to route: send the genuinely hard, structured problems to the expensive reasoning path, and let a cheaper, faster model handle the rest. Thinking before answering is a real advance — but knowing when it's worth thinking is the part that separates using these models well from just paying more for them.