Reasoning Models

What is it?

A reasoning model is a language model built to work through a problem before it answers, rather than replying immediately. It tends to do better on multi-step tasks like maths, programming, logic puzzles and planning.

The trade-off is that it is usually slower and uses more tokens. Many providers show only a summary of the reasoning — or none — rather than the model's raw working.

Also known as: thinking models, reasoning LLM, reasoning LLMs, o1 style models, chain of thought models, slow thinking models, large reasoning models, LRM.

Technical definition

Reasoning models are LLMs post-trained, often with reinforcement learning on tasks with checkable outcomes (Reinforcement Learning for Reasoning (RLVR and GRPO)), to generate long intermediate token sequences ("thinking") before a final response. They use Test-Time Compute (Inference-Time Scaling) sequentially. Providers differ on whether intermediate reasoning is returned, summarised or withheld, and on how it is billed. Behaviour, naming and controls vary by vendor and change often.

Entity type: concept · Freshness class: volatile.

When should I use it?

Choose a reasoning model for hard maths, code debugging, multi-constraint planning, complex analysis and agent tasks that need to recover from errors. Choose a standard model for chat, extraction, rewriting, classification and low-latency features.

Prerequisites and related concepts

Understand these first: What is a Large Language Model (LLM)?, What are Tokens in AI?, What is a Context Window?.

Related concepts: OpenAI Reasoning Models: o-series, Effort, Reasoning Tokens and Deprecations, Test-Time Compute (Inference-Time Scaling), Chain-of-Thought Prompting, Reasoning Transparency and Hidden Reasoning, Thinking Budgets and Reasoning Effort, Reinforcement Learning for Reasoning (RLVR and GRPO), Process Reward Model (PRM), Reasoning Models vs Standard LLMs.

Implementation patterns

• Route by difficulty: use a standard model first and escalate hard cases.
• Give the goal, constraints and checkable success criteria; avoid over-prescribing steps.
• Provide tools (code execution, search) so reasoning can verify instead of guess.
• Request a concise final justification written for the user, not the raw internal trace.
• Cap output and reasoning budgets per request.

Technologies and frameworks

Commonly associated: hosted reasoning models from major providers, open-weight reasoning models, vLLM, Hugging Face Transformers. Names are examples of what exists, not recommendations, and projects change quickly.

Practical guide

1. List which of your tasks genuinely need multi-step deliberation.
2. Run a head-to-head on 20–50 real cases: standard model vs reasoning model (How to Evaluate AI Systems and Outputs).
3. Check cost and latency per correct answer, not just accuracy.
4. Configure effort/budget, output limits and timeouts.
5. Decide what to show users — a short rationale, not raw traces (Reasoning Transparency and Hidden Reasoning).

Common failure modes

• Using a reasoning model for trivial tasks and paying for unnecessary tokens and latency.
• Over-long prompts that micro-manage steps, which can reduce quality for models that plan on their own.
• Assuming the displayed reasoning, if any, is a faithful explanation of the answer.
• Treating a confident final answer as verified; reasoning models can still hallucinate.
• Logging or exposing reasoning content in ways the provider's terms or your privacy policy do not allow.

Troubleshooting

• Timeouts or very slow responses — Lower reasoning effort, stream the response, or move simple requests to a faster model.
• Empty or truncated final answer — Increase the output-token limit; part of the budget may be consumed by hidden reasoning.
• Answer differs run to run — Add a verifier or tests; for decisions, sample several times and compare.

Contrasted with

• Reasoning Models vs Standard LLMs — Standard models answer in one fast pass; reasoning models trade latency and cost for deliberation.
• Chain-of-Thought Prompting — Chain-of-thought is a prompting technique you apply; reasoning models do deliberation as a trained default.

Questions this page answers

• What is a reasoning model?
• How are reasoning models different from regular LLMs?
• When should I use a reasoning model?
• Why do reasoning models cost more?
• Do I need chain-of-thought prompts with reasoning models?

Typical goals: understand how reasoning models differ from standard chat models; choose between a reasoning and a non-reasoning model; control cost of reasoning models.

Sources and verification

Status: not independently verified. This entry was authored on 2026-10-06 from general technical knowledge, without live checking of the sources below. Treat every source as a lead to confirm (identifier, title, authorship, current version) before publication or citation.

Freshness class: volatile — Products, versions, protocols, benchmarks, leaderboards, regulations and dates. Verify against the primary source before relying on specifics; re-review every 3 months.

Time-sensitive claims to verify before relying on them:

• Names, capabilities and pricing of specific reasoning models.
• What each provider returns about reasoning (full, summary, none) and how it is billed.
• Claims that reasoning models outperform standard models on a given benchmark.

Canonical sources (unverified leads):

• Wei et al., Chain-of-Thought Prompting Elicits Reasoning in Large Language Models (2022) — arXiv:2201.11903
• DeepSeek-AI, DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning (2025) — arXiv:2501.12948
• Provider model documentation for current reasoning models — locator to be identified

Related concepts