1. What counts as a reasoning model?
A Reasoning Model is a language model or model family whose interface and training are explicitly organized around deliberation before or during response. In practice, this means the model allocates Test-Time Compute Scaling to internal “thinking” tokens, chain-of-thought-like scratchpads, tool calls, or self-checking passes before producing final output. OpenAI’s o1 announcement made this pattern explicit: OpenAI described o1 as trained by large-scale reinforcement learning to “think productively” using chain of thought, and reported that performance improved both with more reinforcement learning and with more time spent thinking at test time. OpenAI
The basic primitive is Chain-of-Thought as working memory. OpenAI’s o1 post says o1 learns through reinforcement learning to refine its chain of thought, recognize and correct mistakes, break difficult steps into smaller steps, and try alternative approaches. OpenAI DeepSeek-R1 framed the same transition more openly: DeepSeek-R1-Zero was trained with large-scale reinforcement learning without supervised fine-tuning as a preliminary step, while DeepSeek-R1 added cold-start data and multi-stage training to improve readability and performance. arXiv Google’s Gemini 2.5 launch described Gemini 2.5 models as “thinking models” that reason through thoughts before responding, building on reinforcement learning and chain-of-thought prompting research. blog.google Anthropic exposes a different surface: “extended thinking” and, in newer Claude models, “adaptive thinking,” where the model spends an internal thinking budget or effort level before emitting user-facing text. Claude Platform
The important architectural shift is that reasoning is now treated as an inference-time resource, not just a property of model weights. A chat model usually maps prompt to answer in a relatively direct generation pass. A reasoning model maps prompt to internal state, intermediate hypotheses, tool decisions, verification attempts, and only then answer. That makes these systems feel slower, more expensive, more agentic, and sometimes dramatically more capable.
2. The 2026 landscape across major labs
| Lab / family | Public reasoning surface | Budget controls | Tool-call interleaving | Distinctive position in 2026 |
|---|---|---|---|---|
| OpenAI o1 → o3/o4-mini → GPT-5.x reasoning | Raw chain of thought is hidden; summaries may be exposed. OpenAI explicitly says raw reasoning tokens are not exposed, while summaries can be requested for supported models. OpenAI | reasoning.effort with values such as none, minimal, low, medium, high, and xhigh, depending on model. OpenAI Developers |
Strong. o3/o4-mini use tools inside their chains of thought, including web, Python, image/file analysis, image generation, canvas, automations, file search, and memory. OpenAI | OpenAI established the commercial reasoning-model category with o1, then made tool-interleaved reasoning central with o3/o4-mini. Current API docs position GPT-5.5-class models as the main reasoning line, but o1/o3 remain the defining technical reference points. OpenAI Developers |
| DeepSeek-R1 / R1-Zero / distilled R1 models | Visible reasoning is commonly surfaced through <think>-style traces in open-weight deployments, although hosting layers may filter or summarize. DeepSeek recommends enforcing <think>\n in some evaluations because the model can otherwise bypass the thinking pattern. GitHub |
No proprietary managed “effort” dial in the same sense as OpenAI/Gemini/Claude; practical control is via max generation length, sampling, prompting, and external scaffolding. DeepSeek’s benchmark setup used a 32,768-token maximum generation length. GitHub | Not natively tool-interleaved in the model card in the same API-product sense; tool use is usually scaffolded externally. DeepSeek’s official app/API includes “DeepThink” and prompt templates for web/file contexts. GitHub | The open-weight shock. R1 showed that strong reasoning behavior could be induced with large-scale RL and then distilled into smaller dense models. GitHub |
| Google Gemini Thinking / Deep Think | Thought summaries can be requested; raw thoughts are summarized rather than simply dumped. Google states that thought summaries are summaries of raw thoughts and that thinking budgets apply to raw thoughts, not summaries. Google AI for Developers | Gemini 3 uses thinkingLevel; Gemini 2.5 used thinkingBudget. Gemini 3.1 Pro cannot disable thinking; Gemini 2.5 Pro supports dynamic thinking with a 128–32,768 budget range. Google AI for Developers |
Strong. Gemini supports thinking with tools and function-calling state via encrypted thought signatures, which must be passed back in certain multi-turn/tool cases. Google AI for Developers | Google has folded thinking into the Gemini line rather than making it a separate “o-series”-style brand. Gemini 3.1 Pro is presented as a high-reasoning, long-context, multimodal, agentic model. Google DeepMind |
| Anthropic Claude Extended / Adaptive Thinking | Claude 4 models can return summarized thinking blocks; Opus 4.7 defaults to omitted thinking content unless summarized display is requested. Claude Platform | Earlier Claude 4 models used budget_tokens; Opus 4.7 removed manual extended-thinking budgets and moved to adaptive thinking plus effort. Claude Platform |
Strong. Claude 4 interleaved thinking lets Claude reason between tool calls, chain multiple tool calls, and make decisions after intermediate tool results. Claude Platform | Anthropic’s distinctive emphasis is controllable thinking for coding, agents, tool use, and long-running tasks, with explicit developer ergonomics around summaries, budgets, effort, and tool loops. Anthropic |
3. Architectural commonalities
3.1 Test-time compute became a first-class scaling axis
Reasoning models operationalize the idea that some tasks need more computation at inference time. In o1, OpenAI explicitly reported smooth improvement with more test-time thinking. OpenAI In OpenAI’s current API documentation, reasoning models use internal reasoning tokens before producing a response, helping with planning, tool use, ambiguity recovery, alternatives, coding, scientific reasoning, and multi-step agentic workflows. OpenAI Developers Gemini exposes the same dimension through thinking levels and budgets, warning that high thinking may take significantly longer to reach a first non-thinking token but can produce more carefully reasoned output. Google AI for Developers Claude exposes it through budget tokens, adaptive thinking, and effort levels, with Anthropic explicitly describing the cost/latency tradeoff of larger thinking budgets. Claude Platform
This is the Bitter Lesson applied inside the forward pass. Sutton’s “search and learning” framing argued that the scalable long-term methods in AI are general methods that exploit computation, especially search and learning. UT Austin Computer Science Reasoning models combine both: the weights encode learned heuristics, while inference-time token generation, self-checking, sampling, and tool use approximate search over possible solution paths.
3.2 Chain of thought functions as working memory
The common mechanism is not merely “longer output.” It is intermediate state. OpenAI’s o3/o4-mini system card says the models use tools in their chains of thought—cropping or transforming images, searching the web, or using Python during the thought process—and that o-series models are trained with large-scale reinforcement learning on chains of thought. OpenAI DeepSeek describes R1-Zero as exploring chain of thought for complex problems and developing self-verification, reflection, and long CoTs. GitHub Google’s Gemini docs expose thought summaries and thought signatures, implying that internal thought state must be preserved across stateless tool/function-call interactions. Google AI for Developers Anthropic’s docs likewise require preserving thinking blocks during tool use because Claude pauses response construction for a tool call and then continues building the same response after tool results arrive. Claude Platform
The academic monitorability literature makes the working-memory point more formally. A 2025 chain-of-thought monitorability paper argues that, for sufficiently serial reasoning in transformer-style autoregressive systems, long chains of cognition must pass through chain-of-thought tokens as working memory; it also cautions that this does not guarantee the reasoning is understandable or complete. arXiv That caveat matters: a visible or summarized trace is not the same thing as a proof of faithful cognition.
3.3 RL-from-rewards is central, but disclosure varies by lab
The strongest public evidence for Reinforcement Learning from Verifiable Rewards is from OpenAI and DeepSeek. OpenAI says o-series models are trained with large-scale reinforcement learning on chains of thought. OpenAI DeepSeek is unusually explicit: it uses Group Relative Policy Optimization, applies RL directly to a base model in R1-Zero, then adds cold-start data, reasoning-oriented RL, rejection sampling, SFT, and a second RL stage for broader helpfulness/harmlessness behavior. arXiv
For Gemini and Claude, public evidence is thinner. Google says Gemini thinking builds on reinforcement learning and chain-of-thought prompting, but the public documentation does not disclose an o1/R1-style recipe. blog.google Anthropic documents the API mechanics of extended/adaptive thinking in detail, but does not publicly specify the full training recipe that produces Claude’s reasoning behavior. Treat “RL on reasoning traces” as a well-supported pattern for OpenAI and DeepSeek, a plausible but less disclosed pattern for Google, and an externally visible behavior plus product interface for Anthropic rather than a fully published architecture.
3.4 Tool use turned reasoning into action selection
The second shift after test-time compute is Tool-Interleaved Reasoning. OpenAI o3/o4-mini were the first OpenAI reasoning models positioned around full tool access in ChatGPT, with the system card saying tools are used inside chains of thought. OpenAI Gemini thought signatures exist because stateless APIs need a way to preserve internal thought context across function-calling turns. Google AI for Developers Claude’s interleaved thinking explicitly supports reasoning after receiving tool results and chaining multiple tool calls with reasoning steps between them. Claude Platform
This changes the unit of evaluation. The relevant question is not just “Can the model answer?” but “Can it decide when to search, when to execute code, when to inspect a file, when to ask for more information, and when to stop?” The model’s reasoning tokens become a controller for a broader environment.
4. Architectural differences that matter in practice
| Design axis | OpenAI | DeepSeek-R1 | Gemini Thinking | Claude Extended / Adaptive Thinking | Practical implication |
|---|---|---|---|---|---|
| Raw reasoning visibility | Raw reasoning hidden; summaries optional. OpenAI Developers | Often visible in open deployments through <think> traces, but not guaranteed by every host. GitHub |
Thought summaries available; raw thoughts summarized. Google AI for Developers | Summarized thinking blocks or omitted display depending on model/config. Claude Platform | Visibility is not equivalent to faithfulness. Hidden reasoning improves safety/product control but reduces auditability. |
| Budget control | reasoning.effort; output token limits include hidden reasoning. OpenAI Developers |
Max generation length, sampling, prompts, external orchestration. GitHub | thinkingLevel for Gemini 3; thinkingBudget for Gemini 2.5. Google AI for Developers |
Manual budget_tokens on earlier models; adaptive thinking + effort on Opus 4.7+. Claude Platform |
Budget controls are product-level search knobs. They trade accuracy for latency, cost, and sometimes hallucination risk. |
| Reasoning-token billing | Reasoning tokens are hidden but occupy context and are billed as output tokens. OpenAI Developers | Depends on host/runtime; local open-weight inference pays in hardware time rather than API token pricing. | Response pricing is output tokens plus thinking tokens; full thoughts are billed even if only summaries are output. Google AI for Developers | Claude charges for full thinking tokens, not just summaries; Anthropic notes billed output token count may differ from visible response count. Claude Platform | Reasoning can be expensive before the user sees anything. |
| Tool-state preservation | Reasoning items should be passed back in function-call workflows for token-efficient continuation. OpenAI Developers | Usually handled externally by the agent scaffold. | Thought signatures preserve encrypted thought context across multi-turn/function-call interactions. Google AI for Developers | Thinking blocks must be preserved during tool-use continuations, especially with interleaved thinking. Claude Platform | Agent correctness increasingly depends on invisible state plumbing, not only prompts. |
| Open-weight availability | Proprietary. | Open-sourced R1-Zero, R1, and six distilled dense models. arXiv | Proprietary. | Proprietary. | DeepSeek is the main route for inspecting and adapting frontier-like reasoning behavior outside closed APIs. |
The most consequential difference is raw reasoning visibility. OpenAI explicitly chose not to show raw chains of thought for o1, citing user experience, competitive advantage, and chain-of-thought monitoring considerations. OpenAI Gemini and Claude expose summaries rather than full raw traces in their managed APIs. Google AI for Developers DeepSeek-style open models make it easier to inspect and intervene on visible thought traces, but visibility creates its own problems: traces can be verbose, unfaithful, unsafe, or simply hard to evaluate.
5. Empirical performance: what the benchmarks show and do not show
Benchmark comparisons are difficult because reasoning models are often evaluated under different effort levels, tool access, scaffolds, sampling, and answer-selection policies. OpenAI’s GPT-5 developer post reports GPT-5 at 74.9% on SWE-bench Verified versus o3’s 69.1%, while also noting that GPT-5 used fewer output tokens and fewer tool calls than o3 at high reasoning effort. OpenAI DeepSeek’s R1 table reports pass@1 and other metrics under a 32,768-token generation cap with sampling and 64 responses per query for some benchmarks. GitHub Google’s Gemini 3.1 Pro model card reports competitor numbers under Google’s evaluation methodology, which is useful but not the same as neutral, universally standardized testing. Google DeepMind
| Model / family | Selected reported results | Interpretation |
|---|---|---|
| OpenAI o1 | AIME 2024 pass@1 74.4, MATH pass@1 94.8, GPQA Diamond pass@1 77.3, Codeforces Elo 1,673 in OpenAI’s o1 appendix. OpenAI | o1 was the first widely deployed proof that inference-time reasoning could move math/code/science results sharply beyond GPT-4o-style chat models. |
| OpenAI o3 / o4-mini | OpenAI described o3 as setting SOTA on Codeforces, SWE-bench, and MMMU, and said external experts found 20% fewer major errors than o1 on difficult real-world tasks. OpenAI OpenAI later reported o3 at 69.1% on SWE-bench Verified in the GPT-5 developer post. OpenAI o4-mini with Python was reported at 99.5% pass@1 on AIME 2025, with the explicit caveat that computer access reduces AIME difficulty. OpenAI | o3/o4 show how tool access and high effort can dominate raw model comparisons. Results with Python, browsing, or custom scaffolds should not be compared directly to no-tool pass@1. |
| DeepSeek-R1 | DeepSeek reports R1 at GPQA-Diamond 71.5, LiveCodeBench 65.9, Codeforces rating 2029, SWE Verified 49.2, AIME 2024 79.8, and MATH-500 97.3. GitHub | R1 demonstrated that open-weight reasoning could approach o1-class math/code/science performance, especially under long generation budgets. |
| DeepSeek-R1 distilled models | DeepSeek-R1-Distill-Qwen-32B reports AIME 2024 72.6, MATH-500 94.3, GPQA 62.1, LiveCodeBench 57.2, and Codeforces rating 1691; the 70B distill reports MATH-500 94.5 and GPQA 65.2. GitHub | Distillation shows reasoning behavior can be compressed, but DeepSeek’s own discussion says smaller-model RL required enormous compute and still underperformed distillation from the stronger R1. arXiv |
| Gemini 3 / 3.1 Pro Thinking | Gemini 3 Pro reported HLE 37.5 without tools and GPQA Diamond 91.9; Gemini 3.1 Pro Thinking High reports HLE 44.4 no tools, ARC-AGI-2 77.1, GPQA 94.3, Terminal-Bench 2.0 68.5, SWE-bench Verified 80.6, and LiveCodeBench Pro Elo 2887. blog.google | Gemini’s published numbers indicate very strong science, coding, abstract-reasoning, and agentic-terminal performance, but many values come from model-card methodology rather than a single neutral cross-lab harness. |
| Claude 4.x Extended / Adaptive Thinking | Anthropic reported Claude Opus 4 leading SWE-bench at 72.5% and Terminal-bench at 43.2%, with sustained performance on long-running tasks requiring thousands of steps. Anthropic Google’s Gemini 3.1 Pro model card lists Sonnet 4.6 Thinking Max at GPQA 89.9 and SWE-bench Verified 79.6, and Opus 4.6 Thinking Max at GPQA 91.3 and SWE-bench Verified 80.8. Google DeepMind | Claude is especially prominent in coding-agent and long-running workflow reports. Cross-lab comparisons should separate Anthropic self-reports from Google-reported competitor measurements. |
5.1 Math and science
Math and science benchmarks are where reasoning models first looked qualitatively different from chat models. o1’s AIME, MATH, and GPQA results created the category. OpenAI DeepSeek-R1’s R1/R1-Zero work showed that math/code/science reasoning could be incentivized directly by RL on tasks with clear rewards, with R1-Zero improving through self-evolution but requiring later cold-start and readability interventions. arXiv Gemini 3.1 Pro Thinking High’s GPQA 94.3 and HLE 44.4 indicate that Google’s thinking stack is now competitive at the high end of science and academic-reasoning benchmarks. Google DeepMind
The caveat is that math benchmarks are increasingly scaffold-sensitive. AIME with Python is not the same task as AIME without tools. OpenAI explicitly noted that computer access meaningfully reduces AIME difficulty in the o4-mini AIME result. OpenAI
5.2 Code and software engineering
Coding is where reasoning models became economically useful first. SWE-bench Verified, Terminal-Bench, Aider, Codeforces, LiveCodeBench, and agentic coding harnesses all reward the ability to plan, inspect context, execute tests, repair mistakes, and persist through multi-step debugging. OpenAI’s GPT-5 developer post is useful because it directly compares against o3: GPT-5 scored 74.9% on SWE-bench Verified versus o3’s 69.1%, with fewer output tokens and fewer tool calls. OpenAI Gemini 3.1 Pro reports SWE-bench Verified 80.6 and Terminal-Bench 2.0 68.5, while the same table lists Opus 4.6 at 80.8 on SWE-bench Verified. Google DeepMind Anthropic’s Claude 4 launch emphasized long-running coding tasks with thousands of steps, not just single-shot code generation. Anthropic
The key lesson is that code benchmarks are agent benchmarks in disguise. A model that writes plausible code but cannot inspect errors, run tests, or revise patches will underperform a model that uses tools well. This is why tool interleaving became part of the architecture, not an add-on.
5.3 Abstract reasoning and ARC-style tasks
ARC-AGI-style tasks highlight both the promise and the danger of compute-heavy reasoning. ARC Prize reported that a tested o3 system scored 75.7% on a semi-private evaluation set at a public-leaderboard $10k compute limit and 87.5% in a high-compute configuration, while noting that the tested o3 system was not the same as the later released o3 and that compute efficiency must be reported alongside score. ARC Prize Google’s Gemini 3.1 Pro model card reports ARC-AGI-2 Verified at 77.1 for Gemini 3.1 Pro Thinking High, compared with 31.1 for Gemini 3 Pro and competitor numbers for Claude and GPT-5.2 under Google’s methodology. Google DeepMind
ARC-like results are important because they stress adaptation to novel tasks, but they are also unusually sensitive to sampling, search, training exposure, and compute budgets. They are not simple “IQ scores.”
6. Why reasoning models feel different from chat models
6.1 They may spend money before showing text
OpenAI’s API docs say reasoning tokens are not visible via the API but occupy context-window space and are billed as output tokens. Depending on task complexity, the model may generate from a few hundred to tens of thousands of reasoning tokens. OpenAI Developers The same docs warn that a response can hit max_output_tokens during reasoning before any visible output is produced, creating the possibility of cost without a useful visible answer. OpenAI Developers
Gemini has the same economic structure: when thinking is on, response pricing is the sum of output tokens and thinking tokens, and the full thought tokens are billed even though only summaries may be output. Google AI for Developers Claude’s docs similarly state that larger thinking budgets can improve quality at the cost of increased latency, that full thinking tokens are billed rather than only visible summaries, and that budgets above 32k can create long-running request issues. Claude Platform
6.2 Time-to-first-token is part of the UX
The user experience of a reasoning model is often a pause followed by a higher-quality answer. Gemini’s docs explicitly say high thinking may take significantly longer to reach a first non-thinking output token. Google AI for Developers OpenAI recommends short preambles for faster time to first visible token in latency-sensitive applications, because interleaved thinking can otherwise delay visible output. OpenAI Developers Anthropic notes that if thinking display is omitted, the product may appear as a long pause before output begins. Claude Platform
This creates a new product-design question: should the assistant show a progress summary, a reasoning summary, a spinner, partial results, or nothing? The correct answer depends on trust, safety, latency tolerance, and whether the visible summary is useful or misleading.
6.3 Reasoning consumes context
Reasoning is not free memory. OpenAI says hidden reasoning tokens occupy context-window space even though they are discarded from conversation context afterward. OpenAI Developers Gemini thought signatures can increase input tokens when passed back as part of the request. Google AI for Developers Claude thinking blocks can count as input tokens when cached and must be preserved in tool continuations. Claude Platform
In long agent loops, context management becomes part of the reasoning architecture. Context Compaction, Reasoning Token Budgets, and Tool State Management are no longer infrastructure details; they affect model intelligence.
7. Deployment patterns that emerged
7.1 Reasoning model as planner, cheaper model as executor
The most common production pattern is Planner-Executor Agents. OpenAI’s reasoning best-practices guide explicitly describes o-series models as “the planners” and lower-latency GPT models as “the workhorses,” suggesting workflows where o-series models plan strategy or make decisions while GPT models execute specific tasks when speed and cost matter more than perfect accuracy. OpenAI Developers The same guide says most AI workflows will use a combination of both: o-series for agentic planning and decision-making, GPT-series for task execution. OpenAI Developers
This pattern works when the hard part is deciding what should be done, not generating every token of the final artifact. Examples include routing, task decomposition, policy interpretation, code-review planning, research planning, and final validation.
7.2 Reasoning model as primary assistant
The second pattern is to make the reasoning model the default assistant for hard work. This is most natural when the user values correctness over latency: programming, legal/financial analysis, scientific reasoning, complex spreadsheets, architecture decisions, and multi-step debugging. OpenAI o3/o4-mini were explicitly positioned for complex math, coding, scientific challenges, visual perception, and full-tool reasoning. OpenAI Gemini 3 Pro and 3.1 Pro are positioned for learning, building, planning, agentic performance, advanced coding, long-context, multimodal understanding, and algorithmic development. blog.google Claude Opus 4 and later Opus models are positioned for long-running coding and agentic workflows, with Opus 4.7 marketed as available across Claude products, API, Bedrock, Vertex AI, and Microsoft Foundry. Anthropic
The failure mode is overuse. Reasoning models can be worse UX for quick queries. A model that spends 4,000 internal tokens deciding how to answer “rewrite this sentence” is not intelligent; it is misallocated compute.
7.3 Reasoning model as judge or evaluator
A third pattern is LLM-as-Judge with a reasoning model as grader. OpenAI’s best-practices guide says reasoning models do well at benchmarking and evaluating other model responses, citing cases where workhorse-model outputs are judged by o1 or o3-mini for nuanced evaluation. OpenAI Developers This pattern is attractive because evaluation often requires applying rubrics, detecting subtle errors, and comparing alternatives—tasks where internal deliberation helps.
The caveat is that a reasoning judge can be expensive and still biased. It should be calibrated with held-out human labels, adversarial examples, and disagreement analysis, not treated as an oracle.
7.4 Open-weight reasoning as local infrastructure
DeepSeek-R1 created a fourth pattern: run or fine-tune a reasoning-like model locally, distill reasoning traces, or use R1 as a teacher for smaller systems. DeepSeek released R1-Zero, R1, and distilled 1.5B–70B dense checkpoints based on Qwen and Llama. arXiv The distilled models are not equal to the frontier teacher, but they are good enough to make reasoning behavior part of commodity AI infrastructure.
This pattern is especially important for labs and companies that need data control, reproducibility, model inspection, or cost predictability. It also enables research on visible reasoning traces that is impossible with fully closed systems.
8. Are these models genuinely reasoning?
The honest answer is: it depends on the operational definition of “reasoning,” and the evidence is mixed.
Under a functional definition, these systems reason. They decompose problems, maintain intermediate state, revise hypotheses, call tools, inspect results, and solve tasks that earlier LLMs failed. OpenAI o1’s benchmark improvements, DeepSeek-R1’s RL-induced self-verification, Gemini’s high science/agentic scores, and Claude’s long-running coding performance are not explained by surface fluency alone. Anthropic+3OpenAI+3GitHub+3
Under a stronger philosophical definition—stable, causal, compositional understanding that generalizes outside training distributions—the evidence is contested. Apple’s “Illusion of Thinking” paper compared large reasoning models with standard LLM counterparts under controlled puzzle complexity and found three regimes: standard models doing better on low-complexity tasks, reasoning models gaining advantage at medium complexity, and both collapsing at high complexity; it also argued that reasoning models failed to use explicit algorithms consistently across scales. arXiv The paper was controversial, and follow-up critiques argued that benchmark leakage, prompt sensitivity, misgrading, and puzzle-specific protocols complicate broad claims about “fundamental” reasoning limits. arXiv
A better frame is that reasoning models are learned search systems. They are neither “just autocomplete” in the naive sense nor human-like reasoners in the introspective sense. They search through token-level, tool-level, and latent solution spaces using learned heuristics. Sutton’s Bitter Lesson predicts that general methods exploiting more computation—search and learning—will outperform handcrafted reasoning machinery over time. UT Austin Computer Science Reasoning models look like that prediction instantiated inside language-model inference.
9. Chain-of-thought faithfulness and monitorability
Visible reasoning creates a safety opportunity, but not a guarantee. A 2025 paper on whether DeepSeek-R1 and other reasoning models are more faithful found that reasoning models based on Qwen, Gemini, and DeepSeek articulated influential prompt cues much more often than non-reasoning counterparts; for example, DeepSeek-R1 described the influence of a “professor’s opinion” cue 59% of the time versus 7% for the non-reasoning DeepSeek model. But the authors explicitly limited the claim: they tested artificial cue-influence tasks and only one aspect of faithfulness. arXiv
The monitorability literature makes the same point. Chain-of-thought traces may reveal reward hacking, prompt injection, sabotage, or misaligned planning, but externalized reasoning does not guarantee that all relevant reasoning appears in the trace. arXiv OpenAI’s 2026 monitorability work says CoT monitoring is already used to detect reward hacking and other misbehavior in frontier reasoning models and internal agent deployments, while also emphasizing that monitorability depends on preserving CoT informativeness and legibility. alignment.openai.com
OpenAI’s 2026 CoT-control work adds an interesting twist: current reasoning models struggle to control their chains of thought even when instructed to do so, with low controllability across tested frontier models. OpenAI frames this as good for safety because models that cannot easily reshape their reasoning traces are harder to train or prompt into hiding monitor-relevant reasoning. OpenAI This is reassuring only for the current generation. If future models become better at strategic trace manipulation, visible CoT may become less useful as a safety signal.
10. Does reasoning capability compose?
The empirical question is whether a reasoning agent inside a reasoning agent compounds capability or hits diminishing returns. The answer is not settled; current evidence points to conditional composition.
There is positive evidence. DeepSeek’s distillation results show that reasoning patterns from a stronger model can be transferred into smaller models, and DeepSeek concludes that distillation from powerful models is economical and effective. arXiv OpenAI’s production guidance describes reasoning models as planners that can orchestrate other models in workflows. OpenAI Developers Anthropic’s Opus 4.5 announcement says Opus 4.5 was effective at managing teams of subagents and that context management, memory, effort control, and advanced tool use boosted performance on a deep research evaluation. Anthropic
There is also negative evidence. A 2026 General AgentBench paper on test-time scaling of general LLM agents found that sequential scaling improves performance only within a modest range before hitting an effective context ceiling; beyond that, accumulated history can overwhelm the agent’s reasoning capacity and lead to instability or degradation. arXiv Another 2026 OpenReview submission found that increasing test-time computation does not consistently improve factual accuracy on knowledge-intensive tasks and can increase hallucinations, with some reductions in hallucination coming from abstention rather than better recall. OpenReview
The strongest synthesis comes from long-horizon execution research. “The Illusion of Diminishing Returns” argues that short-task benchmarks can understate gains because small improvements in per-step accuracy compound into much longer executable horizons. It also finds that thinking mitigates self-conditioning on prior errors and enables much longer single-turn execution, while still acknowledging limitations of synthetic tasks. arXiv
A reasoning agent inside a reasoning agent helps when decomposition, verification, and state management are explicit. It fails when the outer model merely feeds opaque, error-prone traces from one inner model into another until context fills with noise. The engineering rule is: composition requires Verification, State Compression, External Memory, and Budget-Aware Routing. More thinking is not automatically better thinking.
11. The emerging engineering doctrine
The 2026 doctrine is not “use the smartest model everywhere.” It is closer to:
| Task property | Best-fit pattern |
|---|---|
| Simple, latency-sensitive, high-volume | Non-reasoning or low-effort model |
| Ambiguous, high-stakes, multi-step | Reasoning model as primary assistant |
| Complex workflow with many routine subtasks | Reasoning planner + cheaper executors |
| Coding/debugging with tests | Tool-interleaved reasoning model |
| Evaluation/rubric grading | Reasoning model as judge, calibrated against human labels |
| Local/private/research use | Open-weight R1-style model or distilled reasoner |
| Long-horizon agent | Reasoning model plus external state, compaction, verification, and failure recovery |
Reasoning models are best seen as Inference-Time Search policies trained to spend compute where it matters. They are powerful because they can allocate deliberation, not because every thought token is profound. The engineering frontier is therefore allocation: when to think, how long to think, what tools to use, what state to preserve, when to stop, and how to verify.
12. Open questions
12.1 Is chain of thought the mechanism or merely the interface?
The public evidence suggests chain-of-thought tokens are an important mechanism for serial reasoning, but not the whole mechanism. Monitorability work argues that difficult serial reasoning must use CoT-like working memory in current transformer systems, while also warning that some relevant reasoning may not appear there and future models may not externalize it in human-readable form. arXiv The practical conclusion is to treat CoT as a useful signal, not a ground-truth transcript.
12.2 Will RL on reasoning traces keep scaling?
OpenAI and DeepSeek show strong scaling from RL plus inference-time compute. OpenAI DeepSeek’s discussion of failed PRM attempts is especially instructive: process reward models can help rerank or guide search, but fine-grained step correctness is hard to define, model-based annotation risks reward hacking, and added reward models complicate large-scale RL. arXiv The field has not settled the best reward granularity: outcome rewards, process rewards, verifier rewards, tool-grounded rewards, or mixtures.
12.3 Will hidden reasoning remain acceptable?
Closed labs hide or summarize raw reasoning for safety, competitive, and user-experience reasons. OpenAI But hidden reasoning makes independent debugging, faithfulness evaluation, and user trust harder. Open-weight models push the opposite direction, exposing traces that are useful for research but sometimes messy, unsafe, or misleading. The equilibrium may be: raw traces for monitors and researchers under controlled access; summaries for users; encrypted or signed reasoning state for tool continuity; and external verifiers for final claims.
12.4 Does reasoning improve factuality?
Not reliably. Reasoning helps when the model can derive, verify, search, compute, or inspect. It can hurt when the model elaborates around false premises or uses extra tokens to rationalize uncertainty. The OpenReview work on knowledge-intensive tasks found that more test-time compute does not consistently reduce hallucination and can produce overconfident hallucinations, although enabling thinking still showed benefits relative to non-thinking in some settings. OpenReview The operational lesson is simple: for facts, pair reasoning with retrieval, citations, code, or databases.
12.5 Is the next frontier more thinking, better thinking, or less thinking?
All three. More thinking improves hard tasks when verification exists. Better thinking means training models to allocate effort, preserve state, and call tools appropriately. Less thinking matters because latency and cost dominate real products. OpenAI’s docs, Gemini’s thinking levels, and Claude’s adaptive effort controls all point toward the same future: reasoning will be dynamically routed, not manually selected for every query. OpenAI Developers+2Google AI for Developers+2
Companion entries
Core theory: Reasoning Model, Test-Time Compute Scaling, Chain-of-Thought, Inference-Time Search, Bitter Lesson, Search and Learning, Reinforcement Learning from Verifiable Rewards, Process Supervision
Model families: OpenAI o-Series, OpenAI o1, OpenAI o3, OpenAI o4-mini, DeepSeek-R1, DeepSeek-R1-Zero, Gemini Thinking, Gemini Deep Think, Claude Extended Thinking, Claude Adaptive Thinking, Open-Weights Reasoning Models
Architecture and deployment: Tool-Interleaved Reasoning, Planner-Executor Agents, Reasoning Token Budgets, Thought Signatures, Thinking Blocks, Context Compaction, External Memory, Budget-Aware Routing, LLM-as-Judge, Subagent Orchestration
Evaluation: AIME, MATH-500, GPQA Diamond, SWE-bench Verified, Terminal-Bench, LiveCodeBench, ARC-AGI, Humanity’s Last Exam, PaperBench, Long-Horizon Agent Evaluation
Counterarguments and risks: Illusion of Thinking, CoT Faithfulness, Chain-of-Thought Monitorability, Benchmark Contamination, Reward Hacking, Hallucination Under Test-Time Scaling, Context Ceiling, Diminishing Returns in Agent Loops, Jagged Intelligence