Reasoning Models Explained: How Thinking Models Work, Cost and Differ

A reasoning model is a large language model that generates intermediate "thinking" tokens before it gives its final answer, spending extra computation at the moment of use to work through multi-step problems. The approach grew out of chain-of-thought prompting research in 2022, became a product category with OpenAI o1 in September 2024 and DeepSeek-R1 in January 2025, and by late 2026 most major providers offer reasoning controls on their main models. This page explains what reasoning models are, how they work, how each provider exposes and bills reasoning, when reasoning helps and what it costs. It is for developers, buyers and anyone trying to make sense of "thinking", "effort" and "reasoning tokens". Providers are listed alphabetically; the order is not a ranking.

This is an independent reference page from NHI Mgmt Group based on public provider documentation; it is not sponsored or endorsed by any provider.

Last checked: 2026-11-15

Key takeaways

• Reasoning means thinking before answering: the model writes internal reasoning tokens first, then the visible answer or tool call.
• You pay for thinking you may not see: every provider documentation page that covers billing says reasoning tokens are charged, as output tokens or alongside them, even when only a summary or nothing is returned.
• The control is usually called effort or thinking level: parameter names and allowed values differ by provider and by model, and some models cannot switch reasoning off.
• Raw reasoning is often not shown: several providers return summaries or encrypted reasoning rather than the full chain of thought, while others return a reasoning text field.
• Reasoning state must often be passed back: in multi-turn and tool-using conversations, several APIs require earlier reasoning blocks to be returned unchanged.

What is a reasoning model?

An ordinary chat model produces its answer token by token straight away. A reasoning model first produces a stream of reasoning: breaking the problem down, trying approaches and checking its work, and only then writes the answer. Those reasoning tokens sit in the context window and are counted in usage, but they are usually hidden or summarised in what the user sees.

OpenAI's developer documentation describes reasoning models as using internal reasoning tokens before they respond, which helps with planning, tool use and multi-step tasks. OpenAI's o1 announcement described two levers: performance improved with more training compute and with more time spent reasoning before answering (often called test-time compute).

When did reasoning models appear?

As of 15 November 2026.

The DeepSeek-R1 paper argues that reasoning can be developed through pure reinforcement learning, without human-labelled reasoning examples, and reports that behaviours such as self-reflection and verification emerge from that training. It also states that reasoning patterns from large models can be used to improve smaller ones.

How do reasoning models work?

• Training: reasoning behaviour is trained, mainly with reinforcement learning on tasks whose answers can be checked, such as mathematics and code, as described in the o1 and DeepSeek-R1 sources above.
• Thinking at inference time: the model generates reasoning tokens before the answer. Higher effort settings let it reason for longer.
• Context use: reasoning tokens occupy the context window. OpenAI documents that reasoning tokens occupy context and are billed as output tokens.
• Output limits: the output limit covers reasoning too. OpenAI's max_output_tokens, Anthropic's max_tokens and Google's max_output_tokens all count thinking, so a low limit can end a response before any visible answer appears.
• Adaptive reasoning: some APIs let the model decide whether to think at all. Anthropic's adaptive thinking may skip thinking on easy inputs at lower effort; several GLM models automatically decide whether to think.

How does each provider expose reasoning?

The table uses identical fields for every provider. Where a provider's reasoning documentation does not state a value, the cell says so.

As of 15 November 2026, from each provider's reasoning or thinking documentation listed in the references. Values differ by model; check the model page for the model you use.

Two further details are documented. OpenAI's reasoning.mode accepts standard (the default) or pro, independent of effort. On xAI's grok-4.20-multi-agent, reasoning_effort sets how many agents collaborate (4 or 16) rather than reasoning depth.

How much do reasoning models cost?

Reasoning is priced through tokens, not as a separate fee. The documentation states:

• Anthropic: you are billed for the full thinking tokens generated, not the summary; thinking tokens count toward max_tokens and are billed as output whether display is summarised or omitted.
• DeepSeek: billing is not stated on the thinking mode page.
• Google: response pricing is the sum of output tokens and thinking tokens, and you are billed for the full thoughts even though only the summary is returned.
• Mistral AI: the reasoning page has no billing section and notes that the high setting increases token usage.
• OpenAI: reasoning tokens are not visible through the API, occupy the context window and are billed as output tokens.
• xAI: reasoning tokens count toward total consumption and are billed.
• Z.ai: billing is not stated on the thinking page.

Two providers give sizing guidance. OpenAI recommends reserving at least 25,000 tokens for reasoning and output when starting out, then adjusting from observed usage. Google recommends lowering thinking_level rather than setting a small max_output_tokens, because hitting the limit during reasoning can return an incomplete or empty response with the thinking tokens still billed. For per-token prices see LLM Pricing Explained; for runaway spend controls see the Denial-of-Wallet and AI Agent Cost Runaway Guide.

When should you use a reasoning model or a higher effort level?

Providers describe effort levels in terms of task type. Anthropic's effort documentation, for example, gives these typical uses:

Factual criteria for choosing a setting, whichever provider you use:

• Task structure: multi-step problems (planning, mathematics, code changes across files, tool sequences) are what reasoning is designed for; short lookups and reformatting are not.
• Latency budget: more reasoning means a later first visible token. Anthropic notes that omitting thinking display reduces latency, not cost.
• Cost budget: reasoning tokens are billed, so measure the reasoning token count in the usage field on a sample of real requests.
• Prompt caching: changing Anthropic's budget_tokens or switching thinking modes invalidates cache breakpoints; OpenAI documents a configuration_update item to change effort between turns while preserving prompt caching.
• Model constraints: check whether the model can turn reasoning off and which levels it accepts, as unsupported values return errors on several APIs.

Benchmark results for reasoning models depend heavily on the effort setting used, so compare like for like. See How to Read LLM Benchmarks.

Can you see what a reasoning model is thinking?

Partly, depending on the provider. OpenAI chose not to show raw chains of thought for o1, citing safety and alignment monitoring, user experience and competitive factors. Anthropic states that thinking text is a summary and that no display setting returns the raw chain of thought. Google and OpenAI return summaries only when requested, and xAI returns summaries on grok-4.7. DeepSeek and Z.ai return reasoning in a reasoning_content field, and Mistral AI returns thinking chunks; their pages do not state whether this is the complete reasoning.

Whether visible reasoning reflects what the model actually relied on, and how to monitor it, is covered in Reasoning Model Security, which this page does not repeat.

Do you need to send reasoning back in a conversation?

As of 15 November 2026.

Is a reasoning model the same as an AI agent?

No. A reasoning model is a model behaviour; an agent is a system that uses a model to call tools and act over several steps. Reasoning models are widely used inside agents because they plan between tool calls, but an agent can run on a non-reasoning model and a reasoning model can answer a single question with no tools. For how agents are measured, see AI Agent Benchmarks Explained.

Practitioner checklist

• Check which effort or thinking levels your model accepts and whether reasoning can be turned off.
• Set the output limit high enough to cover reasoning plus the answer, then tune from usage data.
• Log the reasoning token usage field for every request and track it per feature.
• Decide whether you need summaries, and request them explicitly where they are opt-in.
• Pass reasoning blocks or encrypted reasoning back unchanged where the API requires it.
• Re-test prompt caching after changing thinking mode or effort.
• Record the effort setting alongside any benchmark or evaluation result.
• Review the security considerations in Reasoning Model Security before using reasoning models in agents.

Standards and references

All sources accessed 15 November 2026.

• arXiv: Chain-of-Thought Prompting Elicits Reasoning in Large Language Models (Wei et al.)
• arXiv: DeepSeek-R1, Incentivizing Reasoning Capability in LLMs via Reinforcement Learning
• OpenAI: Learning to reason with LLMs
• Anthropic: Thinking and Effort
• DeepSeek: Thinking mode
• Google: Gemini API thinking
• Mistral AI: Reasoning
• OpenAI: Reasoning models guide
• xAI: Reasoning
• Z.ai: Thinking mode

Related NHI Mgmt Group resources: Reasoning Model Security, LLM Context Windows Explained, Model Cards and System Cards Explained, LLM Security Guide.