What Is a Reasoning Model?
Reasoning models add a deliberate thinking step before they answer. This explainer covers how they work, when to use them, and what they cost you in tokens and time.

A reasoning model is an AI model that thinks before it answers. A standard model starts writing its reply straight away. A reasoning model first works through the problem: it breaks it into steps, tries different approaches and checks its own logic. Only then does it write the answer you see.
The difference shows on hard problems. Ask a standard model to solve a tricky maths problem, write a complex piece of code or untangle a legal contract, and it may give a confident answer that looks right but isn't. A reasoning model is more likely to catch its own mistake while thinking, and get it right.
That doesn't make reasoning models better for everything. They're slower, they cost more, and most everyday tasks don't need them. The useful skill is knowing when to use one and when not to.
How reasoning models work
The core idea is chain-of-thought: working through a problem step by step. People used to get this by adding "think step by step" to their prompts. Reasoning models do it automatically, every time.
While it thinks, the model writes notes to itself, a kind of scratch pad. This is where it splits the problem into parts, considers other approaches, spots contradictions and goes back when something doesn't add up. When it's done thinking, it writes the final answer.
This is more than the old "think step by step" trick. With that trick, an ordinary model writes its reasoning into the visible answer, and the reasoning can be thin or written after the fact to justify a guess. Reasoning models are trained specifically to think before answering, and they're rewarded for reaching the right answer, not for reasoning that merely sounds convincing.
Anthropic describes Claude's version, extended thinking, as letting the same model give itself more time and effort on a hard problem before it answers (source: Anthropic (opens in a new tab)).
Some tools show you the thinking, so you can watch the model work before the answer appears. Others show a summary or hide it. Seeing it helps you check the answer, but takes longer to read.
A worked example
Take this question: "A train leaves London at 09:00 travelling at 180 km/h. Another leaves Birmingham (180 km away) at 09:30, travelling towards London at 120 km/h. When do they meet?"
A standard model might answer straight away, sometimes correctly and sometimes not. A reasoning model works through it:
- In the 30 minutes before the second train leaves, the first train covers 90 km.
- That leaves 90 km between them.
- Together they close the gap at 300 km/h (180 + 120).
- 90 km at 300 km/h takes 18 minutes, so they meet at 09:48.
- It checks that the answer makes sense.
The model isn't "smarter" in general. It just gives itself more chances to catch a mistake before committing to an answer.
Reasoning models vs standard models
| Standard model | Reasoning model | |
|---|---|---|
| Speed | Faster | Slower (thinking takes time) |
| Tokens used | Fewer | More (the thinking counts) |
| Best for | Writing, summarising, quick questions | Maths, coding, logic, planning |
| Accuracy on hard problems | Hit and miss | More reliable |
| Cost per question | Lower | Higher |
AI providers charge by the token, roughly a short word or part of a word. The thinking produces tokens too, and providers generally charge for them at the higher rate they use for answers, even when you can't see them. On very hard problems that cost is usually worth it. On simple ones, you're paying for thinking you didn't need.
Which products use reasoning models
Most major AI companies now offer reasoning:
OpenAI started the category with its o-series models. Its current models in ChatGPT and the API include reasoning ("thinking") modes. OpenAI shows a summary of the reasoning rather than all of it.
Claude's extended thinking lets current Claude models think before answering. Developers can set a "thinking budget", a limit on how many tokens Claude may spend thinking. You can see the thinking, in full or summarised depending on the model. (source: Anthropic (opens in a new tab))
Gemini's Deep Think is Google's most intensive reasoning mode, which Google says "excels at complex problem solving". Availability depends on your Google plan, so check which plans include it. (source: Google DeepMind (opens in a new tab))
DeepSeek R1 is a reasoning model you can download and run yourself, and it showed its full thinking from the start, which was unusual when it launched. As an open-weight model, it's free to download and run on your own hardware.
What reasoning models are often confused with
Bigger models: A bigger model isn't the same as a reasoning model. Size helps with general knowledge and ability. Thinking time helps specifically with problems that take several steps.
Mixture of experts: This is a way of building a model so that only part of it switches on for each question, which saves computing power. It has nothing to do with thinking time, though some models built this way also have reasoning modes.
Retrieval-augmented generation (RAG): RAG gives a model extra information by looking up relevant documents before it answers. Reasoning helps a model use the information it has more carefully. They solve different problems and can be used together.
Web search: Some models search the web before answering. That keeps answers up to date, but it isn't the same as thinking harder.
When to use a reasoning model
Use one when the task really needs it:
- Maths or logic problems with several steps, where one wrong step ruins the answer.
- Complex coding or debugging, where parts of a program interact in ways that aren't obvious.
- Planning that has to juggle constraints, dependencies and trade-offs.
- Careful document review, such as checking a contract for contradictions or loopholes.
- Scientific questions about experiment design, statistics or what causes what.
Skip it when:
- You're writing an email, summarising a document or asking a simple factual question. A standard model does these faster and cheaper, and extra thinking adds nothing.
- You need a quick reply. Thinking can add anywhere from a few seconds to over a minute on hard problems.
- You're sending large numbers of similar requests, where the extra cost per question quickly adds up.
- The task is creative. Reasoning models don't write noticeably better stories, poems or brainstorms. Those depend more on a good prompt than on thinking time.
What to check when choosing a tool with reasoning
- Is reasoning always on, or do you switch it on? Some tools always use it; others let you turn it on per conversation. Knowing which is active helps you predict cost and speed.
- How is the thinking billed? Check the pricing page. Thinking usually counts as output, the more expensive kind of token, so a hard question can cost several times what the visible answer suggests.
- Can you see the thinking? If you need to check how an answer was reached, see whether the tool shows the reasoning.
- Can you control how hard it thinks? Claude lets developers cap the thinking, and some tools have a low, medium or high effort setting. Lower effort is faster and cheaper; higher effort is more thorough.
If tokens are new to you, the explainer on AI tokens covers how token billing works. The short version: thinking adds up fast on hard problems, so match the tool to the task before you pay for reasoning.

Stephen Gbolagade
Software Engineer and Technical Writer at Ploba
Writes Ploba's guides to AI tools, agents and protocols, explaining how they work in plain language.
Keep learning
Plain-language explanations, technical guides and practical comparisons.


