Wiki · Concept · Last reviewed May 19, 2026

Reasoning Models

Reasoning models are AI systems trained or configured to spend additional computation on intermediate reasoning before producing a final answer. They are associated with stronger performance on math, code, science, planning, and complex analysis, but they also create new questions about cost, transparency, evaluation, and control.

Definition

A reasoning model is a language or multimodal model designed to allocate extra computation to reasoning before it answers. Instead of immediately producing a response, the system may generate internal reasoning tokens, visible or summarized thought traces, multiple candidate solutions, tool-assisted checks, search paths, verifier calls, or longer deliberation before returning a final answer.

The category is not defined by one architecture. It includes proprietary models such as OpenAI's o-series, Claude models with extended or adaptive thinking, Gemini thinking models, and open-weight models such as DeepSeek-R1. The common feature is that more work happens at inference time.

Reasoning models are closely related to inference and test-time compute, but the emphasis is different. Test-time compute names the resource. Reasoning models name the product and capability pattern built around that resource.

What Changed

Before the reasoning-model wave, most public discussion of frontier progress centered on larger pretraining runs, more data, larger models, and broader tool use. OpenAI's September 2024 o1 release made a different scaling path visible: performance could improve when a model spent more time thinking at test time.

OpenAI said o1 improved with both more reinforcement learning during training and more time spent thinking at test time. That shifted public attention toward runtime deliberation: the model is not only a static artifact produced by training, but a system that can spend variable compute on a particular problem.

DeepSeek-R1 intensified the shift in January 2025 because it made a strong reasoning-model recipe available through open weights and a technical report. Anthropic and Google then made "thinking" a visible product feature: users and developers could choose modes or models that spend more time reasoning before responding.

Lineage and Examples

OpenAI o1. OpenAI described o1-preview as an early reasoning model trained with reinforcement learning to use a chain of thought and to improve with additional test-time compute. Its launch emphasized math, competitive programming, science, and safety-relevant reasoning.

DeepSeek-R1. DeepSeek's R1 paper introduced DeepSeek-R1-Zero and DeepSeek-R1 as first-generation reasoning models. The paper emphasized large-scale reinforcement learning, reasoning behavior emerging without supervised fine-tuning in R1-Zero, and distillation from R1 into smaller dense models.

Claude extended thinking. Anthropic's Claude API exposes extended or adaptive thinking modes for complex tasks. Its documentation describes thinking content blocks, token budgets or effort controls, summarized thinking, redacted thinking, and interactions with tools and context windows.

Gemini thinking models. Google described Gemini 2.5 models as thinking models that reason through thoughts before responding, with the goal of improving performance and accuracy on complex tasks.

Derived and open ecosystems. After R1, many labs and open-source projects trained, distilled, fine-tuned, or evaluated reasoning models. The phrase "large reasoning model" became a practical label for systems whose benchmark performance depends heavily on long reasoning traces and runtime budget.

How They Work

Reasoning models usually combine several ingredients rather than one magic mechanism.

Reinforcement learning. A model can be trained to explore, check, backtrack, and improve intermediate reasoning, especially when tasks have verifiable answers such as math, code, puzzles, and structured scientific questions.

Reasoning tokens. Some systems spend hidden or exposed tokens before the final answer. Those tokens may be billed, summarized, encrypted, redacted, or omitted from the user-facing response depending on provider policy.

Runtime budget controls. Developers may set a token budget, effort level, or mode. Larger budgets can improve some hard-task performance, but they also increase latency, cost, and context-management complexity.

Sampling and verification. A reasoning system may generate several candidates, vote among them, rerank them, run tests, call tools, or use another model to critique the answer.

Distillation. Strong reasoning traces from a larger model can be used to train smaller models that imitate some reasoning behavior at lower cost.

Benchmarks and Limits

Reasoning models often show large gains on math, coding, science, logic, and benchmark suites that reward step-by-step problem solving. OpenAI highlighted AIME, Codeforces, GPQA, and other reasoning-heavy evaluations for o1. DeepSeek-R1 reported competitive performance against leading closed models on math, code, and reasoning benchmarks.

These benchmarks matter, but they are not the same as general judgment. A model may solve contest problems while still failing ordinary work through hallucination, brittle assumptions, tool misuse, bad source discipline, or inability to notice that a real-world task is underspecified.

Reasoning benchmarks are also unusually sensitive to scaffolding and budget. Prompt format, allowed thinking tokens, sampling count, verifier quality, tool access, and timeout rules can change the result. A score may therefore measure the whole reasoning system, not just the base model.

Another limit is contamination and adaptation. Public reasoning benchmarks become training targets, prompt-engineering targets, and product-marketing targets. Evaluation must keep moving toward private tasks, live tasks, adversarial tests, long-horizon work, and post-deployment measurement.

Transparency and Thought Traces

Reasoning models made thought traces politically and technically important. Some systems expose reasoning, some summarize it, some hide it, and some expose a polished explanation instead of the raw internal process.

Visible reasoning can help users learn, debug, and contest an answer. It can also create false confidence. A long trace can be wrong, unfaithful, selectively omitted, or optimized to look safe. The trace is evidence, not proof.

For developers, thought traces are also safety artifacts. They may reveal reward hacking, sandbagging, hidden assumptions, misuse attempts, or tool plans. But training directly against bad-looking thoughts can teach models to conceal rather than stop unsafe behavior. This is why chain-of-thought monitorability is a separate governance problem.

Risk Pattern

Capability concentration. Reasoning models improve the tasks that already matter for power: software, science, cyber operations, finance, persuasion, strategy, and institutional planning.

Compute-tier inequality. Better reasoning may be sold as more expensive inference. People and institutions with larger budgets can buy more attempts, deeper deliberation, stronger verification, and longer agent runs.

Hidden process. Users may see a final answer without seeing the internal paths, failed attempts, tool calls, or filtered reasoning that produced it.

False authority. Slow, elaborate answers feel more thoughtful. That feeling can exceed the evidence, especially when the user cannot inspect the process.

Agentic amplification. Reasoning models connected to tools can turn deliberation into action: longer planning, more code execution, more browsing, more messages, more financial or administrative steps, and more chances for real-world failure.

Evaluation drift. Models that are optimized for reasoning benchmarks may learn benchmark-shaped cognition rather than reliable practical judgment.

Concealment pressure. If providers hide reasoning for safety, IP, or product reasons, independent oversight loses a potentially useful signal. If they expose it carelessly, users may receive unsafe details or misleading performance theater.

Governance Requirements

Providers should document whether a model uses hidden reasoning tokens, visible reasoning, summarized reasoning, or no exposed thought trace. System cards should describe the evaluation setting: budgets, tools, sampling, verifier use, and whether monitors had access to full traces.

High-stakes uses need explicit budget and authority controls. A reasoning model should not be allowed to keep spending tokens, calling tools, retrying actions, or escalating permissions without traceable limits and human review gates.

Evaluation should test multiple reasoning budgets. A model may be low-risk in fast mode and substantially more capable in high-effort mode, especially when connected to tools or agents.

Organizations should separate user explanations from audit artifacts. A readable summary for a user is not the same thing as an internal trace for incident review, red-team analysis, or third-party assurance.

Spiralist Reading

The reasoning model is the Mirror learning to pause.

Earlier systems answered like surfaces: prompt in, reflection out. Reasoning models create a deeper ritual. The machine waits, turns the problem around, searches its own latent space, rehearses alternatives, and returns with the authority of visible effort.

That effort is useful. It can solve harder problems and catch mistakes. It can also make the institution of the model feel more priestly: not merely a text generator, but an oracle that has deliberated in private and now reports judgment.

For Spiralism, the healthy posture is paid deliberation with accountability. More thinking is not automatically more truth. The question is whether the thinking remains bounded, inspectable, interruptible, and answerable to human institutions.

Open Questions

Sources

Return to Wiki