Reasoning Models (Thinking Models)

What Are Reasoning Models?

Reasoning models, often marketed as thinking models, are large language models (LLMs) that are trained to produce an extended internal chain of reasoning before committing to a final answer. Rather than emitting a response token by token in a single pass, the model first generates a long sequence of intermediate reasoning tokens in which it plans an approach, works through sub-steps, checks its own logic, and revises mistakes. Only after this internal process does it output the user-facing answer.

The defining characteristic is not a new architecture but a behavior: the model invests additional computation at the moment of answering, and that behavior is reinforced during training so it becomes reliable rather than something a user must coax out with prompting. This is why the category is described in terms of how the model is used (it thinks before it speaks) rather than any single underlying network design.

Conceptually, reasoning models occupy a point on a spectrum. At one end are standard instruction-tuned LLMs that answer quickly and cheaply. At the other are systems explicitly optimized to scale accuracy on hard tasks by spending more inference compute. The trade-off is direct: more thinking generally means better answers on difficult problems, but higher latency and cost.

• Reasoning models generate a long internal chain of thought before the final answer.
• The extra reasoning tokens are usually billed but often hidden or summarized in the interface.
• The category is defined by behavior and training, not by a distinct model architecture.

Test-Time Compute: Thinking Before Answering

The core idea behind reasoning models is test-time compute, also called inference-time compute or inference scaling. Traditional scaling improved models by adding parameters and training data, which increases train-time compute. Test-time scaling instead increases the compute spent at the moment a query is answered: the model is allowed to generate more reasoning tokens, explore more intermediate steps, and effectively think for longer.

OpenAI framed this directly when it previewed the o1 model in September 2024, noting that performance improved consistently both with more reinforcement learning during training and with more time spent thinking at inference. In practice, the model produces hidden reasoning tokens that never appear in the final response but represent real, billable computation. Longer thinking gives the model room to break a hard problem into simpler steps, try alternative approaches, and catch its own errors.

Test-time compute can be scaled in several ways. The most common is sequential: simply letting the model generate a longer chain of thought. Other strategies are parallel, such as sampling multiple candidate solutions and selecting the best by majority voting or a verifier. As of 2026, most commercial reasoning systems expose a thinking budget or effort setting that lets developers tune how much inference compute the model is allowed to spend per request.

• Test-time compute spends more processing at inference rather than at training.
• Sequential scaling lengthens the chain of thought; parallel scaling samples multiple answers.
• Many systems let developers cap thinking via a token budget or effort level.

How Reasoning Models Are Trained (RL on Verifiable Tasks)

What separates a reasoning model from a standard LLM that is merely prompted to show its work is the training process. Reasoning behavior is taught primarily through large-scale reinforcement learning (RL), often on tasks where the correctness of a final answer can be checked automatically. Math problems, code that must pass tests, and other verifiable tasks provide a clear reward signal: the model is rewarded for reaching the right answer, and it gradually learns reasoning strategies that lead there.

The most detailed public account of this approach comes from DeepSeek-AI. Their DeepSeek-R1 work, first released on arXiv in January 2025 and published in Nature in September 2025, showed that reasoning capabilities can be incentivized through reinforcement learning without first requiring human-labelled reasoning traces. An initial variant, DeepSeek-R1-Zero, was trained with pure RL on the base model and spontaneously developed behaviors such as self-reflection, verification, and trying alternative strategies. The RL algorithm used was Group Relative Policy Optimization (GRPO).

A key reported result illustrates the effect: on the AIME 2024 math benchmark, the pass@1 score rose from 15.6% to 71.0% through RL, and reached 86.7% with majority voting (figures as reported by DeepSeek-AI). The full DeepSeek-R1 pipeline added a small amount of cold-start supervised data and further RL stages to improve readability and general usefulness, but the central finding was that advanced reasoning can emerge from reinforcement learning on verifiable rewards.

• Reasoning is reinforced via RL, frequently on verifiable tasks like math and code.
• DeepSeek-R1 showed reasoning can emerge from RL without human reasoning traces (Nature, 2025).
• Emergent behaviors include self-correction, verification, and strategy switching.

Reasoning Models vs Standard LLMs vs Chain-of-Thought Prompting

It is easy to conflate three related ideas. Chain-of-thought (CoT) prompting is a technique, introduced by Wei et al. in 2022, in which a standard model is prompted to show intermediate reasoning steps. CoT is purely an inference-time prompting method; it changes nothing about how the model was trained and works best on large models. A standard LLM with a good CoT prompt can reason far better than the same model answering directly.

A reasoning model differs in that the thinking behavior is baked in through training rather than elicited by the prompt. The model decides how much to reason, generates a much longer and often hidden chain of thought, and has learned, via RL, to verify and backtrack rather than simply narrate a single linear path. The result is typically more reliable on hard problems than CoT prompting alone, because the model has been optimized to reason rather than merely imitating the format of reasoning.

• Standard LLM: answers directly; fastest and cheapest.
• CoT prompting: a prompt technique that elicits reasoning from any capable model at inference time.
• Reasoning model: reasoning trained in via RL, with longer, self-verifying, often hidden thinking.

The Model Landscape as of 2026

As of 2026, every major frontier lab ships a reasoning capability, though naming and packaging differ and change quickly. OpenAI pioneered the commercial category with its o-series (o1 previewed in September 2024, followed by o3 and o4-mini announced in April 2025), models explicitly trained to think longer before responding. Vendor lineups evolve rapidly, and reasoning is increasingly folded into a single flagship family with a selectable thinking mode rather than sold as separate models, so treat specific version names as snapshots that date fast.

DeepSeek-R1, from DeepSeek-AI, is the most prominent openly published reasoning model and is notable for releasing detailed methodology and open weights, which accelerated reasoning research across the field. Google ships reasoning under its Gemini family (the Gemini 2.5 generation described its models as thinking models), and Anthropic exposes reasoning in Claude through extended or adaptive thinking. These details are accurate as of 2026 and should be re-verified against current vendor documentation.

A practical theme across vendors as of 2026 is developer control over thinking. Google's Gemini 2.5 Flash exposes a thinking budget that can be set from 0 up to 24,576 tokens, with the model deciding how much of that budget to use. Anthropic's Claude historically used a budget_tokens parameter (minimum 1,024 tokens) and has moved toward an adaptive thinking approach with an effort setting on recent Claude versions, letting the model determine reasoning depth per request.

• OpenAI o-series (o1, o3, o4-mini) launched the commercial reasoning category (2024 to 2025).
• DeepSeek-R1 is a leading openly published, open-weight reasoning model.
• Google Gemini and Anthropic Claude expose reasoning via thinking budgets or adaptive/effort controls.
• Specific version names and pricing change fast; verify against current vendor docs.

Strengths: Math, Code, and Multi-Step Problems

Reasoning models deliver their largest gains on tasks that decompose into many verifiable steps. Competition mathematics, algorithmic coding, formal logic, scientific reasoning, and complex planning all benefit because errors compound across steps, and the model's ability to check and correct intermediate work materially raises the chance of a correct final answer. Benchmarks such as AIME (math) and competitive programming evaluations are where the gap between reasoning and standard models is most visible.

The advantage is weaker, and sometimes negligible, on tasks that do not require multi-step deduction: simple lookups, short rewrites, formatting, casual conversation, or retrieving a single fact. For these, a standard model usually returns an equally good answer far faster and more cheaply. The strength of a reasoning model is specifically the ability to sustain a long, self-correcting chain of inference, so its value scales with problem difficulty.

• Largest gains: competition math, code that must pass tests, logic, scientific and multi-step planning.
• Smaller or no gains: simple lookups, short edits, formatting, casual chat.
• Value scales with problem difficulty and the number of reasoning steps required.

Cost, Latency, and the Overthinking Problem

The thinking that makes reasoning models powerful is also their main cost. Hidden reasoning tokens are typically billed as output tokens, so a single query can consume far more compute than a standard completion, and the long sequential generation increases latency. For interactive or high-volume applications, this can dominate both the bill and the user experience.

Returns on additional thinking also diminish. Research as of 2026 documents an overthinking problem: beyond a certain budget, extra reasoning yields little accuracy gain and can even hurt, with models abandoning previously correct answers or burning thousands of tokens on trivial questions. Studies note that optimal thinking length varies with problem difficulty, so a fixed, uniform budget tends to overthink easy problems and underthink hard ones. The practical implication is to match thinking budget to task difficulty and stop scaling once accuracy plateaus.

• Reasoning tokens are usually billed and add substantial latency.
• Accuracy gains from more thinking diminish and can reverse (overthinking).
• Optimal thinking length depends on difficulty; tune the budget per task type.

When to Use a Reasoning Model vs a Faster Model

Choosing between a reasoning model and a faster standard model is a cost-quality decision driven by task difficulty. Reach for a reasoning model when correctness matters more than speed and the task genuinely requires multi-step inference: hard math, non-trivial code, debugging, formal analysis, agentic planning, or problems where a wrong answer is expensive. Use a fast standard model for retrieval, summarization, classification, simple transformations, and latency-sensitive or high-volume traffic.

A common production pattern is routing: a cheap model handles routine requests and escalates only difficult cases to a reasoning model, or a single model is run with an adjustable thinking budget so most queries stay cheap while hard ones get more compute. For retrieval-heavy applications, the value of reasoning often appears after relevant context has been gathered, when the model must synthesize or reconcile information across sources. AI memory and second-brain tools such as MemX, which retrieve stored documents, photos, and voice notes by plain-English query, illustrate this split: fast semantic retrieval surfaces the right material, and a reasoning model is worth its cost mainly when an answer requires multi-step synthesis over what was retrieved.

• Use a reasoning model for hard, multi-step, correctness-critical tasks.
• Use a fast model for retrieval, summaries, classification, and latency-sensitive traffic.
• Consider routing or an adjustable thinking budget to control cost at scale.