What Is a Reasoning Model? Reasoning Models Explained

Published Updated 42 viewsReasoning ModelChain of ThoughtReasoning Effort

A reasoning model is a large language model that produces a longer thinking process before it answers. By 2026, whether to think and for how long has become an adjustable reasoning effort setting on mainstream models, and the setting you pick directly affects quality, latency, and cost.

A reasoning model is a class of large language model that goes through a longer "thinking process" before it formally gives an answer. OpenAI's o1 launched the category in 2024, and DeepSeek R1 brought it to open-weight models in early 2025. Compared with ordinary models, they often give more accurate and better-organized answers on complex logic, math, programming, and multi-step inference.

By 2026, the line between "reasoning models" and "ordinary models" has blurred: nearly every mainstream flagship model has thinking built in, and the difference has become whether thinking is on and how deep it goes, which developers tune through a reasoning effort setting.

Grab It in One Sentence First

A reasoning model "thinks a bit" before answering, whereas an ordinary model is more like an instinctive reaction that outputs the answer directly.

To borrow concepts from psychology, an ordinary large language model is closer to "System 1" thinking—fast, fluent, and reliant on pattern matching; a reasoning model is closer to "System 2"—slow, deliberate, checking each step of the logic in turn. Of course, this is only a metaphor: the model is still fundamentally a statistical model, except its training taught it to generate intermediate reasoning steps.

How It Works

The core mechanism of a reasoning model is Chain of Thought (CoT). Before generating the final answer, the model first produces a "thinking trace" that isn't necessarily visible to the user. In that trace it analyzes the problem step by step, tests assumptions, and corrects errors, and only then outputs the answer.

This intermediate process is sometimes called Extended Thinking. It can consume far more tokens than the final answer, which brings higher cost and longer latency. Spending more compute at answer time in exchange for quality is also known as test-time compute.

Reasoning Effort: The Most Common Dial in 2026

When you call a model today, you usually aren't choosing between a "reasoning model" and an "ordinary model"—you're choosing an effort level on the same model. A few 2026 examples:

  • Claude Fable 5.1, released by Anthropic on September 1, expanded its effort levels from three to five (low, medium, high, xhigh, max), and thinking can't be switched off entirely.
  • IBM's open-weight Granite 4.2 (3B, 8B, 30B), released August 25, has a "thinking / non-thinking" switch at every size, plus a low-effort mode that spends fewer reasoning tokens on simple questions.
  • OpenAI reports GPT-6 family results by effort level in its own comparisons, for example GPT-6 Sol's test results at the xhigh setting.

The effort setting can affect cost more than switching models does. When the independent evaluator Artificial Analysis tested Claude Sonnet 5.5, the average cost per task on its index was $7.60 at the highest effort level and $1.08 at high—roughly a sevenfold gap—while the vendor says the model costs up to 30% less than its predecessor for most work. The two claims don't conflict: whether it's "cheaper" or "pricier" depends on which level you run it at.

How It Differs from Ordinary Models

An ordinary large language model usually generates its answer token by token without explicitly "going back to check." That's fast and cheap, and it suits everyday conversation, copywriting, and summarization.

A reasoning model's advantage lies in tasks that need multi-step inference: math problems, debugging code, logic puzzles, and strategic analysis. In these tasks, a mistake at any intermediate step can throw off every conclusion after it. By extending the thinking process, a reasoning model is more likely to catch and fix mistakes along the way.

But more thinking isn't always better. For simple questions the thinking is wasted; for creative writing, excessive caution can smother the spark; and for applications that need fast responses, the latency is a problem.

When to Turn the Effort Up

Scenarios that benefit from higher effort:

  • Math and scientific computation: multi-step solving, formula derivation, data analysis
  • Complex coding tasks: debugging logic errors, architecture design, reviewing code for defects
  • Logical inference: tasks that require checking whether premises and conclusions are consistent
  • Strategic planning: decisions that require weighing multiple options

Scenarios where low effort or no thinking is fine:

  • Ordinary Q&A and casual chat
  • Summarizing and rewriting content
  • Creative writing and brainstorming
  • Applications with strict response-time requirements

Trading Off Cost and Speed

Reasoning is expensive mainly because the thinking itself consumes a lot of tokens, which are usually billed as output tokens. So when comparing prices, the per-million-token rate isn't enough—look at how many tokens it took in total to finish the same task.

In practice, two strategies are common. One is model routing: a routing layer judges task complexity, sends simple tasks to a cheaper model or lower effort, and escalates only the genuinely complex ones. The other is to run your own evals at low effort first and raise the setting only for task types where quality clearly falls short, rather than turning everything up to the maximum.

Common Misconceptions

Is slower always better? No. Reasoning suits logic-dense tasks; on simple tasks its advantage is close to zero, and it adds waiting time and cost.

Does longer thinking mean more accurate answers? Not entirely. Very long chains of thought can drift partway through. A September 2026 arXiv preprint, "When Agents Slow Down," tested agents in single sessions of up to 100 million tokens and found that gains per token come quickly at first and then show diminishing returns; splitting the same budget across several parallel sessions did better. The study hasn't been peer-reviewed yet, but it makes a point worth remembering: how you spend the budget matters as much as how much you spend.

If you can see the thinking, do you know what the model is thinking? Not necessarily. In the GPT-6 Astra system card released September 3, OpenAI wrote that the model's chain-of-thought monitorability had "substantially" declined compared with earlier models, and that it can solve complex problems without writing its reasoning out. A displayed thinking trace can help you understand an answer, but it shouldn't be treated as a complete record of the model's actual computation.

Can reasoning models replace ordinary models? A wholesale replacement isn't recommended. Choosing the model and effort level per task usually works better than a single choice.

Sources