Reasoning models

Reasoning models are large language models that are post-trained or configured to spend additional inference-time computation on intermediate steps before returning an answer. The label does not identify one architecture. A reasoning model commonly generates a longer chain of thought, while a system built around it may also sample and compare candidates, search, or use a verifier. Some products expose a separate reasoning model, while others combine fast and extended-thinking modes in one model.^{[5][6][9][10][11]}

The term became prominent after OpenAI released o1-preview in September 2024. OpenAI reported that o1 was trained with large-scale reinforcement learning and that its performance improved with both additional reinforcement-learning compute and additional test-time compute.^[6] DeepSeek-R1, published in 2025, provided a more detailed public example: its authors described rule-based rewards, Group Relative Policy Optimization (GRPO), a multistage training pipeline, and distillation into smaller models.^[8]

Between 2025 and 2026 the category changed shape. The separate reasoning model line largely disappeared into general-purpose models that decide for themselves whether and how long to think, controlled by an effort or level parameter rather than a token budget. Tool calls moved inside the reasoning trace. At the same time every major Western developer stopped returning the raw trace to users, replacing it with a generated summary, an encrypted handle, or nothing at all.^[17][23][27]

Reasoning models can improve results on tasks such as mathematical problem solving, coding, and scientific question answering, but the improvement is not automatic. It depends on the task, the underlying model, the compute-allocation method, and the evaluation protocol.^[5][13] A generated reasoning trace is also not guaranteed to be a faithful explanation of the computation that produced the answer, and the empirical literature published since 2025 documents cases where longer reasoning makes accuracy worse.^[12][50]

Definition and scope

There is no single test that separates every reasoning model from every other language model. In research and product documentation, the label usually refers to a model or mode with three related properties.^{[5][6][8][9][10][11]}

• Intermediate computation: the system generates or processes intermediate steps before its final answer.^{[6][8][9][10][11]}
• A variable inference budget: the system can use more tokens, samples, search steps, or verifier calls on a difficult prompt.^[5][9][11]
• Training or post-training for deliberation: the model is trained to use those additional steps productively, rather than merely being prompted to produce a longer explanation.^[6][8][11]

These properties do not imply a distinct neural-network architecture. For example, Claude 3.7 Sonnet was presented as one model that could answer normally or use an extended-thinking mode, while Qwen3 was released with explicit thinking and non-thinking modes.^[9][11] Conversely, o1 was introduced as a separate model series optimized for reasoning.^[6]

By 2026 the separate-series framing had become the exception rather than the rule. OpenAI's GPT-5 shipped as "a unified system" comprising "a smart, efficient model that answers most questions, a deeper reasoning model," and "a real-time router that quickly decides which to use."^[15] Anthropic moved from a developer-set thinking budget to an effort dial and then to adaptive thinking, in which the model chooses when to think; by Claude Opus 5 thinking is on by default and the API rejects attempts to disable it above a certain effort level.^[23][24][25] The practical consequence is that on most current frontier products there is no separate model to select. The question is how much thinking to authorize.

The term should also be distinguished from several adjacent ideas:

• Chain-of-thought prompting is a prompting method that asks an existing model to produce intermediate steps. A model can benefit from this method without having been post-trained as a reasoning model.^[1]
• Self-consistency samples several reasoning paths and selects the answer on which they agree. This is an inference procedure, not a model architecture.^[2]
• Tree of Thoughts and related search systems explore branches of partial solutions and evaluate which branch to continue. The search loop can be implemented outside the language model.^[3]
• Test-time compute is the broader resource being varied. It includes longer serial reasoning, parallel sampling, search, and verification.^[5]

A further boundary case is reasoning that never becomes text at all. Geiping and colleagues trained a proof-of-concept model that scales inference compute by iterating a recurrent block in latent space and unrolling it to arbitrary depth at test time, rather than by emitting more tokens. They scaled it to 3.5 billion parameters over 800 billion training tokens and reported that performance on reasoning benchmarks improved with additional unrolled compute. The authors note that the approach needs no specialized reasoning training data, works with small context windows, and can in principle capture reasoning that is awkward to express in words.^[53] This is a research architecture rather than a shipped product, but it clarifies that the token-based chain of thought is one implementation of variable inference compute, not the definition of it.

The displayed trace also needs careful terminology. A provider may expose a raw generated trace, a filtered trace, or a model-generated summary. OpenAI, for example, decided not to show o1's raw chain of thought and instead showed a generated summary.^[6] Even when a trace is visible, it is an observable output sequence, not direct access to all of the model's internal activations or causal computation.^[7][12]

Historical development

Prompted reasoning

The immediate research precursor was chain-of-thought prompting. Wei and colleagues showed that providing a few worked examples with intermediate steps improved large models on arithmetic, commonsense, and symbolic reasoning tasks. Their NeurIPS 2022 paper reported that eight chain-of-thought exemplars enabled a 540-billion-parameter PaLM model to reach then-state-of-the-art accuracy on GSM8K.^[1]

Subsequent work separated better reasoning from a single deterministic decoding path. Wang and colleagues' self-consistency method sampled diverse chains and selected the most consistent final answer. The paper reported gains over ordinary chain-of-thought decoding on several arithmetic and commonsense benchmarks.^[2] Tree of Thoughts went further by searching over coherent partial solutions, allowing lookahead and backtracking rather than committing to a single left-to-right chain.^[3]

Process supervision was another precursor. Lightman and colleagues compared feedback on final outcomes with feedback on individual reasoning steps. On a representative subset of the MATH test set, their process-supervised system solved 78.2% of problems, and the project released PRM800K, a dataset of 800,000 step-level human labels.^[4] This work concerned reward models and solution selection rather than a complete modern reasoning-model product; it documented methods for scoring intermediate steps and selecting solutions.

Test-time scaling and o1

Research in 2024 examined how extra inference compute should be allocated. Snell and colleagues studied search with a process-based verifier and adaptive changes to a model's response distribution. Their results were strongly task-dependent: a compute-optimal policy was more than four times as efficient as their best-of-N baseline, and a smaller model could outperform a model 14 times larger in a FLOPs-matched comparison when the smaller model already had a non-trivial chance of solving the prompt.^[5] The conditional wording matters; the paper did not show that additional inference compute always substitutes for a larger or better-trained model.

OpenAI's September 2024 o1 release brought this line of work into a public model product. The company described o1 as using a learned chain of thought, trained with large-scale reinforcement learning, and reported smooth improvement with both train-time and test-time compute.^[6] This release helped establish "reasoning model" as a product category, although the underlying components had appeared in earlier research.

Openly described post-training

DeepSeek-R1 supplied a detailed public account of a reasoning-model training pipeline. DeepSeek-R1-Zero began from DeepSeek-V3 Base and used GRPO with rule-based accuracy and format rewards, without a preliminary supervised fine-tuning stage. In the peer-reviewed Nature article, its average AIME 2024 pass@1 score rose from 15.6% to 77.9% during reinforcement learning; self-consistency increased the reported accuracy to 86.7%.^[8]

The authors also documented weaknesses in R1-Zero, including poor readability and language mixing. The full DeepSeek-R1 pipeline therefore added cold-start data, reasoning-oriented reinforcement learning, rejection sampling and supervised fine-tuning on reasoning and non-reasoning data, and a final reinforcement-learning stage using both rule-based and model-based rewards. The project released DeepSeek-R1-Zero, DeepSeek-R1, data samples, and distilled models.^[8]

Tools inside the trace

The next step was to let the model act during reasoning rather than only before or after it. OpenAI o3 and o4-mini, released on April 16, 2025, were the first o-series models with access to the full ChatGPT tool set inside the reasoning process. OpenAI stated that it "trained both models to use tools through reinforcement learning, teaching them not just how to use tools, but to reason about when to use them," and that they were the first of its models able to integrate images into the chain of thought rather than merely looking at them: "they think with it."^[14] The same post reported that "large-scale reinforcement learning exhibits the same 'more compute equals better performance' trend observed in GPT-series pretraining."^[14]

xAI made a similar disclosure for Grok 4 in July 2025, stating that it had used its 200,000-GPU Colossus cluster "to run reinforcement learning training that refines Grok's reasoning abilities at pretraining scale," and that "Grok 4 was trained with reinforcement learning to use tools," specifically a code interpreter and web browsing.^[32] Anthropic shipped extended thinking with tool use as a beta with the Claude 4 models in May 2025, and separately shipped interleaved thinking, which "lets Claude think between tool calls within a single assistant turn."^[21][23]

By late 2025 this pattern had reached open-weight models. Moonshot AI's Kimi K2 Thinking was released with a design that interleaves the chain of thought with function calls, and Moonshot reported that it sustains roughly 200 to 300 sequential tool calls without human intervention.^[40] MiniMax made interleaved thinking a headline feature of its M2 series, describing it as the model reasoning between rounds of tool use, inspecting tool outputs, and carrying that reasoning forward to the next call.^[43]

From a separate line to a control surface

The clearest structural change of 2025 and 2026 is that the reasoning model stopped being a product and became a setting. Anthropic framed this explicitly when it introduced Claude 3.7 Sonnet in February 2025 as "the first hybrid reasoning model on the market," arguing that reasoning should be "an integrated capability of frontier models rather than a separate model entirely."^[9] OpenAI reached the same destination by a different route, first shipping the o-series as a parallel line and then folding it into GPT-5's router in August 2025.^[6][15] Google's Gemini 2.5 series was presented from the start as a family of "thinking models" rather than a thinking variant of a non-thinking family.^[10][28]

The move was not universal, and at least one developer reversed it. Alibaba's Qwen3 launched in April 2025 with a single model that could be switched between thinking and non-thinking modes.^[11] Three months later Qwen released updated checkpoints that abandoned the switch: the Qwen3-235B-A22B-Instruct-2507 model card states that the model "supports only non-thinking mode and does not generate <think></think> blocks in its output," with a separate Thinking checkpoint trained alongside it.^[38] The reported reason is that merging the two objectives degraded both, because an instruct model is rewarded for brevity and a thinking model for spending tokens.^[39] This is a useful counterweight to the assumption that unification is simply better; it is a design tradeoff whose resolution differs by developer.

Control surfaces

Because reasoning is now a mode rather than a model, the interesting engineering surface is how a developer asks for more or less of it and what comes back. Three generations of control are visible in the documentation of the major providers: an explicit token budget, an abstract effort level, and adaptive thinking in which the model itself decides.

Token budgets

The first generation exposed a number of thinking tokens. Anthropic's launch post for Claude 3.7 Sonnet stated that "you can tell Claude to think for no more than N tokens, for any value of N up to its output limit of 128K tokens," with thinking tokens billed as output.^[9] Google's Gemini 2.5 API used a thinking_budget parameter with per-model ranges: Gemini 2.5 Pro accepted 128 to 32,768 and could not disable thinking at all; 2.5 Flash accepted 0 to 24,576 and could be turned off; 2.5 Flash-Lite accepted 512 to 24,576 and had thinking off by default. Setting the budget to -1 requested dynamic thinking, in which the model sized its own budget.^[27]

Token budgets are precise but poorly matched to the underlying quantity. A budget is a hard cap on a length, not a statement about how hard a problem is, and it does not transfer between models with different tokenizers or different verbosity, so a hard-coded value silently changes meaning at every model upgrade. Both developers later abandoned the parameter: Anthropic deprecated it and then rejected it outright, and Google replaced it with an abstract level.^[23][27]

Effort levels

The second generation replaced the number with a label. Anthropic introduced an effort parameter with Claude Opus 4.5 in November 2025 and reported that at medium effort the model matched Claude Sonnet 4.5 on its internal agentic-coding evaluation "using 76% fewer output tokens," and that at maximum effort it exceeded that baseline by 4.3 points "using 48% fewer tokens." Anthropic disclosed the conditions for those figures: a 64K thinking budget, interleaved scratchpads, and a 200K context.^[22] The parameter now sits at output_config.effort, outside the thinking object, with levels low, medium, high, xhigh, and max, defaulting to high. Anthropic's documentation describes it as "a behavioral signal, not a strict token budget" that "affects all tokens in the response," including tool calls and function arguments, not only the thinking block.^[24]

OpenAI's reasoning.effort follows the same shape. Its documentation lists none, minimal, low, medium, high, xhigh, and max, with the note that "lower effort favors speed and lower token usage, while at higher effort the model thinks more completely to provide higher quality responses."^[17] For the GPT-5.6 family the default is medium in both standard and pro modes.^[17][20] SpaceXAI, the name xAI took after it was absorbed into SpaceX and rebranded in July 2026, documents reasoning_effort for Grok 4.5 with low, medium, and high, a default of high, and the flat statement that "reasoning cannot be disabled."^[34][35] DeepSeek's V4 API exposes effort levels across three request formats for compatibility with OpenAI-style, Anthropic-style, and Responses-style clients.^[37]

Google took a parallel path with thinking_level, and its documentation is unusually direct about what the abstraction gives up: "Gemini 3 treats these levels as relative allowances for thinking rather than strict token guarantees." Sending both thinking_level and the legacy thinking_budget in one request returns a 400 error.^[27] Current defaults differ by tier: Gemini 3.6 Flash and 3.5 Flash default to medium, 3.5 Flash-Lite to minimal, Gemini 3.1 Pro to high with low, medium and high available, and Gemini 3 Pro to high with only low and high available.^[27]

The comparison table below records what each provider's documentation says, not how the levels compare across providers. The labels are not calibrated against each other, and a level named high on one platform is not a claim about compute parity with high on another.

Scroll sideways for more →

Adaptive thinking

The third generation removes the decision from the caller. Anthropic shipped adaptive thinking with Claude Opus 4.6 in February 2026, describing it as letting "Claude decide when deeper reasoning would be helpful." By Claude Opus 5, released July 24, 2026, thinking is on by default: Anthropic's documentation states that the same request that ran without thinking on Opus 4.8 now runs with thinking on, "the model decides when and how much to think on each turn," and effort is "the control for thinking depth."^[25]

OpenAI made the equivalent move at the fast end of its lineup. Its GPT-5.1 announcement in November 2025 stated that "for the first time, GPT-5.1 Instant can use adaptive reasoning to decide when to think before responding to more challenging questions."^[16] Before that, GPT-5's router had made the decision outside the model, choosing between a fast model and a reasoning model based on "conversation type, complexity, tool needs, and your explicit intent (for example, if you say 'think hard about this' in the prompt)."^[15] Google's equivalent was the dynamic thinking setting in the 2.5 API, in which a budget of -1 handed sizing back to the model.^[27]

Adaptive thinking closes a loop that opened with o1. In 2024 the reasoning model was chosen by the user, from a menu. In 2026 it is chosen by the model, and the user supplies a hint about how expensive an answer they are willing to buy.

The deprecation of explicit budgets

Anthropic has been the most explicit about retiring the earlier control. Its documentation states that "extended thinking (thinking.type: 'enabled' with budget_tokens) is deprecated on the Claude 4.6 models (requests using it still succeed). Claude 4.7 and later models do not support it and reject requests that use it, returning a 400 error."^[23] Claude Opus 4.7, released April 16, 2026, was the first model to hard-reject the old parameter.^[23] On Claude Opus 5 the restriction tightened further in the other direction: thinking: {"type": "disabled"} is accepted only at effort high or below, and combining it with xhigh or max returns a 400. Anthropic also warns that with thinking disabled the model "can occasionally write a tool call into its text output instead of emitting a tool_use block."^[25]

What comes back

Neither of the two largest Western developers returns a raw chain of thought under any setting, and the two give different reasons.

Anthropic's transition is documented across three release cycles. Claude 3.7 Sonnet in February 2025 showed the thinking text. With the Claude 4 models in May 2025 Anthropic "introduced thinking summaries for Claude 4 models that use a smaller model to condense lengthy thought processes," adding that "this summarization is only needed about 5% of the time" and that customers requiring raw chains of thought could contact sales about a Developer Mode.^[21] The current documentation is categorical: "when display is summarized, the thinking text you receive is a summary of Claude's full thinking process rather than the raw chain of thought. Summarized thinking provides the full intelligence benefits of thinking while preventing misuse. No display setting returns the raw chain of thought."^[23] Summarization is done by a different model from the one being called, and the thinking model does not see the summary. Billing is on the full thinking tokens; the summary itself is not charged. On Claude Opus 5, Sonnet 5, Fable 5, Mythos 5, Opus 4.8 and Opus 4.7, the default display setting is omitted, meaning no thinking text is returned at all unless requested.^[23]

OpenAI's documentation makes the same architectural choice with less framing: "while we don't expose the raw reasoning tokens emitted by the model, you can view a summary of the model's reasoning using the summary parameter." Reasoning tokens "are not visible via the API," yet "occupy space in the model's context window and are billed as output tokens." For stateless clients, reasoning items are returned with an encrypted_content property so that reasoning state can be carried across calls without being read.^[17] GPT-5.6 added persisted reasoning, reusing reasoning items across turns to improve multi-turn quality and cache efficiency.^[20]

Google's version is a summary too, but it is framed as a feature rather than a safeguard: "we take the model's raw thoughts and synthesize them into a helpful summary." The parameter moved from the 2.5 API's includeThoughts boolean to thinking_summaries with values auto and none, and pricing is on the full thought tokens even though only the summary is returned.^[27] Google also introduced thought signatures, "encrypted representations of the model's internal thought process" that a client must pass back to maintain reasoning continuity. Omitting them returns a 400 on function calling and image generation; on plain text it merely "degrades the model's reasoning."^[27]

The contrast worth drawing is not that one lab hides more than another, since in practice none of the three returns raw text. It is the stated purpose. Anthropic names misuse prevention. Google names debugging and insight. OpenAI states the fact without arguing for it. SpaceXAI sits in the same group, documenting summarizations of internal reasoning and encrypted reasoning content for Grok 4.5 rather than the trace itself.^[34]

The open-weight side has not followed. DeepSeek's API returns the chain of thought directly: its documentation states that "the chain-of-thought content is returned via the reasoning_content parameter, at the same level as content," and lets developers decide whether to feed it back on the next turn.^[37] Ai2 went further with OLMo 3, releasing a 32-billion-parameter Think model whose intermediate traces are inspectable and, because the project publishes its data, recipes and checkpoints as a "model flow," traceable back to the training decisions that produced them.^[41] For anyone studying reasoning traces empirically rather than as a product feature, the open-weight models are now the more informative object of study.

Training methods

Published systems combine several methods, and proprietary developers do not disclose every stage. It is therefore inaccurate to treat any one recipe as universal.^{[6][8][9][11]}

Supervised examples and cold starts

Supervised fine-tuning can teach a model the expected format and style of a reasoning trace before reinforcement learning. DeepSeek described this as a cold-start stage for R1. Qwen described long chain-of-thought cold-start training as the first stage of Qwen3 post-training.^[8][11] Supervised traces can improve readability and stability, but they also constrain the model to patterns represented in the training examples.

Microsoft's Phi-4-reasoning shows how far this stage alone can go at small scale. The 14-billion-parameter model was produced by supervised fine-tuning of Phi-4 on more than 1.4 million curated prompts with reasoning demonstrations generated by o3-mini, with two unused base-model tokens repurposed as <think> and </think> markers. A separate variant, Phi-4-reasoning-plus, added a short phase of outcome-based reinforcement learning using GRPO and produced longer traces at higher cost. The authors report non-trivial transfer to general-purpose benchmarks, and frame the result as evidence that careful data curation for supervised fine-tuning matters for reasoning models and can then be amplified by reinforcement learning.^[42]

Reinforcement learning with verifiable rewards

For tasks with a checkable answer, a reward can be computed without asking a human to judge every completion. A mathematical answer can be compared with a reference result, and code can be run against tests. This family of methods, now generally called reinforcement learning with verifiable rewards, is the common core of the publicly described reasoning pipelines. DeepSeek-R1-Zero used accuracy and formatting rewards. Its Nature paper says the team avoided neural reward models for the reasoning tasks because of their susceptibility to reward hacking during large-scale reinforcement learning.^[8]

GRPO, the optimization method disclosed for DeepSeek-R1, samples a group of outputs for each question and estimates each output's advantage relative to the reward distribution within that group. This removes the separate value model used in some actor-critic methods. The paper's result demonstrates one workable training design, not proof that GRPO is required for reasoning models.^[8]

Scale disclosures from proprietary developers are sparse but consistent in direction. Google's Gemini 2.5 technical report states that "Gemini Thinking models are trained with Reinforcement Learning to use additional compute at inference time to arrive at more accurate answers," and that "the resulting models are able to spend tens of thousands of forward passes during a 'thinking' stage."^[28] OpenAI reported that large-scale reinforcement learning follows the same compute-to-performance trend as pretraining.^[14] SpaceXAI described Grok 4's reinforcement-learning run as operating "at pretraining scale" on a 200,000-GPU cluster,^[32] and for Grok 4.5 stated that it "scaled reinforcement learning with a strong focus on per-token intelligence" across "hundreds of thousands of tasks, centered on multi-step software engineering and other technical work, with automated and model-based grading," running on "highly asynchronous training, so agentic rollouts can run for many hours while learning continues across tens of thousands of GPUs."^[33]

That last disclosure is the clearest public statement of where reinforcement learning for reasoning has moved: away from single-turn mathematics problems with a string-match reward and toward long agentic rollouts graded by a mixture of automated checks and model judges.

Process supervision

Outcome supervision scores the final result; process supervision scores intermediate steps. Process reward models can be used to rank complete solutions, guide a search, or supply training feedback. Lightman and colleagues found process supervision more effective than outcome supervision in their MATH experiments, but their result was tied to the models, data, and evaluation in that study.^[4]

Process supervision has not displaced outcome supervision in the publicly described frontier pipelines. DeepSeek-R1's authors chose rule-based outcome rewards for the reasoning stages specifically to avoid reward hacking, and used model-based rewards only for general data.^[8] The practical difficulty is that a process reward model is itself a learned scorer with its own failure modes, so a training loop that optimizes against it inherits them. Where step-level scoring has proven most durable is in evaluation and candidate selection rather than as the primary training signal.

Does reinforcement learning teach or elicit?

The most substantive open question in reasoning-model training is whether the reinforcement-learning stage creates capability or surfaces capability already present in the base model. The question matters because the two answers imply different ceilings.

Yue and colleagues argued for elicitation. In a NeurIPS 2025 paper they compared RLVR-trained models with their base models under pass@k, sampling k attempts per problem. RLVR models did better at small k, which is the standard reported setting, but base models overtook them at large k. Their coverage and perplexity analyses found that "the current training setup does not elicit fundamentally new reasoning patterns" and that the observed reasoning abilities "originate from and are bounded by the base model." Reading the base model as an upper bound, they reported that six popular RLVR algorithms performed similarly and all remained far from that bound.^[44] The mechanism they propose is that reinforcement learning biases the output distribution toward reward-yielding paths, which raises the chance of sampling a correct answer while narrowing the range of paths the model will explore.

NVIDIA's ProRL work argued the opposite, with conditions attached. Using extended training runs of more than 2,000 steps with KL divergence control, reference policy resetting, and a broad task mixture spanning mathematics, code, science problems, logic puzzles, and instruction following, the authors reported cases where RL-trained models beat base models across a wide range of pass@k values, including problems where the base model failed at every attempt. They also reported that this did not happen everywhere: results fell into three regimes they named diminish, plateau, and sustained, with several mathematics benchmarks showing improved pass@1 alongside declining pass@128.^[45] The honest summary of the two papers together is that the elicitation result holds under short, standard RLVR runs on mathematics, and that prolonged training on a diverse task mixture is the setting in which the boundary has been observed to move.

A third strand complicates both. Shao and colleagues reported that RLVR improved Qwen2.5-Math-7B on MATH-500 by 21.4 points with a purely random reward, 13.8 with a format-only reward, and 24.1 with deliberately incorrect labels, against 29.1 with ground-truth rewards. The same spurious signals produced flat or negative results on Llama3 and OLMo2. Their proposed mechanism was that RLVR amplifies a pre-existing behavior in Qwen models, specifically reasoning in code without executing it, whose frequency rose from about 65% to over 90% during training.^[46]

Wu and colleagues then showed that a large part of this was an artifact. Their AAAI 2026 paper found data contamination in the Qwen2.5 series on MATH-500, AMC and AIME, and constructed RandomCalculation, a generator of clean synthetic arithmetic problems of arbitrary length and difficulty. On the clean data, "only accurate reward signals yield steady improvements that surpass the base model's performance boundary," and the random-reward effect disappeared. They conclude that "conclusions derived from contaminated benchmarks on Qwen2.5 series may be unreliable" and recommend evaluating on uncontaminated benchmarks and across multiple model families.^[47]

The sequence is worth stating plainly because it recurs. A surprising result was published, it was widely repeated, and a follow-up showed that the surprise came from the benchmark rather than the method. Claims about what reinforcement learning does to reasoning are unusually sensitive to the evaluation set, and results demonstrated on a single model family should not be generalized.

Distillation into small models

Knowledge distillation transfers behavior from a stronger teacher to a smaller model, commonly by fine-tuning the smaller model on selected teacher-generated solutions. DeepSeek reported that reasoning patterns learned by its large model could improve smaller instruction-tuned models and made several distilled models publicly available.^[8] Distillation can reproduce useful output behavior without reproducing the teacher's entire reinforcement-learning process, but it does not make the student identical to the teacher.

Distillation is also how thinking reaches the cheap tiers of proprietary families. Google's Gemini 2.5 report states that "the smaller models in the Gemini 2.5 series, Flash size and below, use distillation," approximated with "a k-sparse distribution over the vocabulary."^[28] The report separately states that thinking is trained natively across the series with reinforcement learning. Those are two statements in two sections, and merging them into a claim that Google distils reasoning from a larger thinking model is not supported by the text. The defensible reading is that small Gemini models are trained by distillation, and that thinking capability across the series is attributed to reinforcement learning.

Phi-4-reasoning is the clearest public case of distillation producing a reasoning model outright, since its supervised stage was built on traces generated by o3-mini.^[42] That route has a structural dependency: it requires access to a stronger reasoning model whose traces are visible. As frontier providers stopped returning raw chains of thought, the readily distillable teachers became the open-weight models rather than the frontier ones.

Hybrid and unified training

Some systems can switch between short and extended responses. Qwen described a four-stage Qwen3 pipeline: long-chain-of-thought cold start, reasoning reinforcement learning with rule-based rewards, fusion of thinking and non-thinking data, and reinforcement learning on general-domain tasks.^[11] Anthropic described Claude 3.7 Sonnet as one model with both standard and extended-thinking modes.^[9] These examples show why "reasoning model" does not necessarily mean a permanently slow model.

The subsequent history is instructive in both directions. Anthropic pushed unification further, to the point where Claude Opus 5 thinks by default and cannot have thinking disabled at the top effort levels.^[25] Qwen went the other way three months after Qwen3 launched, separating Instruct and Thinking checkpoints because the fused objective degraded both.^[38][39] The difference is not obviously about capability. Anthropic controls its serving stack and can route a single model's behavior; an open-weight publisher ships a file that someone else will run, and a checkpoint that is mediocre at two things is harder to justify than two checkpoints that are each good at one.

Self-play and data-free approaches

A smaller research line asks whether the reasoning training signal can be generated without human-curated problems at all. The Absolute Zero paradigm is the best-known example, in which a model proposes tasks for itself and solves them, with a code executor supplying verification. These approaches are still research results rather than components of shipped frontier pipelines, and they inherit the verification problem in a sharper form: a self-proposed task is only as good as the checker that grades it.

Inference-time computation

Additional inference compute can be allocated in several ways:

• Longer serial reasoning: generate more intermediate tokens before the answer.^[6][8]
• Parallel sampling: generate several independent solutions and aggregate or rerank them.^[2][6]
• Search: explore partial solutions, retaining or expanding promising branches.^[3][5]
• Verification: use a learned reward model, a deterministic checker, tests, or another model to score candidates.^[4][5][8]
• Adaptive allocation: spend different amounts of compute on different prompts.^[5]
• Delegation to subagents: hand parts of a task to separate model instances and combine their results.^[19][32]

These methods have different costs and failure modes. A long single trace can revise earlier steps, but it can also compound an early error. Parallel sampling provides diversity but multiplies generation cost. A verifier can select better candidates only if its scores track correctness. Search can recover from a poor branch, but its performance depends on branching, stopping, and evaluation rules.^[3][5][6]

Parallel thinking in shipped products

Parallel sampling stopped being an evaluation trick and became a product tier. Google DeepMind's Gemini 2.5 report describes Deep Think as "a novel reasoning approach... that naturally blends in parallel thinking techniques during response generation," letting the model "creatively produce multiple hypotheses and carefully critique them before arriving at the final answer."^[28] xAI's Grok 4 Heavy was described in similar terms: "we have made further progress on parallel test-time compute, which allows Grok to consider multiple hypotheses at once."^[32] OpenAI's GPT-5.6, previewed on June 26, 2026 and shipped as three tiers, exposes two settings above ordinary generation: a pro reasoning mode that "performs more model work than standard mode" and aggregates it into one answer, and an ultra mode that coordinates subagents across parallel workstreams.^[17][18][19]

The billing model tells you what these are. OpenAI states that pro mode "aggregates the model work performed to produce the final answer and bills those tokens at the selected model's standard token rates."^[17] A pro or heavy tier is not a different model; it is the same model run more times, with the aggregation cost passed to the caller.

Delegation and long-horizon work

Anthropic's Opus 5 documentation adds a further wrinkle: the model "delegates to subagents more readily" and "verifies its own work without being told to," to the point where Anthropic advises removing verification instructions carried over from earlier models because they cause over-verification.^[25] Effort at the top levels is explicitly described as spanning subagents and tool calls, which is why Anthropic tells developers to raise max_tokens when using xhigh or max.^[25]

This blurs the boundary the article's older framing drew between serial reasoning, parallel sampling, and search. In an agentic setting all three can occur inside a single billed response, chosen by the model rather than the harness. The stable analytical question is unchanged, but it now has to be asked of the whole system rather than the decoding loop: how many model forward passes were bought, in what topology, and under whose control.

Budget disclosure

Budget must therefore be part of any evaluation. OpenAI's original o1 report illustrates the effect. On the 2024 AIME exams, it reported 74% with one sample per problem, 83% using consensus among 64 samples, and 93% after reranking 1,000 samples with a learned scoring function; GPT-4o averaged 12% in the same report.^[6] These are three different inference protocols, not three interchangeable pass@1 results.

The same caveat applies with more force in 2026, because the compute variable now has more dimensions. A single reported score can differ by effort level, by reasoning mode, by whether subagents were permitted, by whether tools were available, and by how many attempts were averaged. Anthropic's own reporting of the GPT-5.6-era comparison ladder and OpenAI's separation of reasoning.mode from reasoning.effort both make the point that mode and effort are independent axes.^[17]

Representative systems

The following examples show different implementations of the category. The table records only what the cited developer or publication disclosed about reasoning design; it is not a ranking, and it deliberately omits benchmark scores because those are not comparable across the disclosed protocols.

Scroll sideways for more →

Product names, controls, and availability can change. The stable technical comparison is whether a system uses serial reasoning, parallel sampling, search, verification, delegation, or a combination, and how the evaluation accounts for the resulting compute.^[2][3][5]

Evaluation

Reasoning models are often evaluated on mathematics, coding, science, and planning tasks because these domains offer multi-step problems and, in some cases, objective answer checkers. A defensible comparison should report the details that differ across published studies and release reports.^{[5][6][8][13]} These include:

• the exact model snapshot and prompt;
• whether tools, retrieval, or code execution were available;
• the maximum reasoning-token or compute budget, and the effort level or reasoning mode used;
• the number of samples and whether voting or reranking was used;
• whether the score is pass@1, pass@k, or another aggregate;
• the verifier and stopping rule, if any;
• whether subagents were permitted and how many;
• uncertainty, exclusions, and contamination checks.

Without these details, two rows carrying the same benchmark name may measure different systems. The o1 AIME results, for example, changed from 74% to 93% as the protocol moved from one sample to 1,000 samples plus a learned scorer.^[6] DeepSeek's R1-Zero result separately shows that reinforcement-learning progress and self-consistency can both change the score for one model.^[8]

Benchmarks in current use

The evaluation set that discriminated between reasoning models in 2024 is not the set that discriminates in 2026. AIME, GSM8K, MATH and GPQA Diamond were the standard headline numbers of the o1 and R1 era. Frontier systems now score near the top of the competition-mathematics sets, which compresses the differences those benchmarks can express, and their public availability makes them vulnerable to contamination.

Three responses are visible. The first is harder static sets: Humanity's Last Exam for broad frontier-difficulty questions, ARC-AGI-2 for abstract pattern generalization, and FrontierMath for research-level mathematics. The second is continuously refreshed evaluation. MathArena evaluates models on recurring mathematics competitions as soon as the problems are released, which its authors present as a direct answer to contamination in static benchmarks.^[54] The third, and the most visible in 2026 release materials, is a shift from question answering to agentic and long-horizon tasks: SWE-bench Verified, Terminal-Bench, and developer-internal evaluations such as Anthropic's FrontierCode and Frontier-Bench or OpenAI's Agents' Last Exam and ExploitBench.^[19][25][26]

That shift solves one problem and creates another. Agentic evaluations measure something closer to the work the models are sold to do, but the leading examples are internal, run inside the developer's own harness, and reported without independent replication. Anthropic's FrontierCode results for Claude Opus 5, for instance, are internal evaluations reported in its own system card rather than by an independent party.^[26] These are legitimate disclosures when the conditions are stated, but they are vendor-reported results and should be labelled as such.

Saturation and contamination

Benchmark contamination is not a hypothetical concern for this category. Wu and colleagues documented contamination in the Qwen2.5 series on MATH-500, AMC and AIME, and showed that a widely reported RLVR finding did not survive on clean data.^[47] Because reasoning benchmarks are small, numerically scored and widely republished, a handful of leaked items can move a headline number by several points.

Contamination and saturation interact badly. As a benchmark approaches its ceiling, the remaining differences between models shrink toward the size of the noise that contamination introduces, so the ranking becomes less informative exactly when it is being quoted most confidently. The practical implications for reading a reasoning-model comparison are that a benchmark's age matters, that a fresh-problem evaluation is worth more than a static one at the same nominal difficulty, and that a result reproduced across model families is worth more than one demonstrated on a single family.

Benchmarks also measure a limited distribution of problems. High scores on competition mathematics or code tests do not establish general reasoning ability, and vendor-reported results should be identified as such. OpenAI explicitly cautioned that o1 exceeding its recruited PhD experts on GPQA did not mean the model was more capable than a PhD in every respect.^[6]

Limitations and open questions

Returns from additional compute

More inference compute is useful only when the model and allocation method can turn it into a better candidate. Snell and colleagues found that the best allocation depended on prompt difficulty, and their smaller-model advantage was limited to problems on which the smaller model had a non-trivial initial success rate.^[5] Extra tokens can therefore be wasted on easy tasks or fail to rescue tasks outside the model's effective capability.

The strongest evidence that this is not merely a research artifact comes from a developer's own reporting. Anthropic's documentation for Claude Opus 5 states that the model "converts additional effort into better results more reliably than any earlier Opus model" and lists test-time compute scaling among its capability improvements.^[25] The accompanying system card is more specific and less monotonic: on Anthropic's FrontierCode evaluation the best main-set score, 53.4, occurred at medium effort, and the card records a decline in FrontierCode score above high effort.^[26] Both statements can be true, because the first is a claim about improvement relative to earlier models and the second is a claim about the shape of the curve. The practical reading is that the effort dial has an interior optimum that depends on the task, and that turning it to maximum is a defensible choice only when an evaluation says so.

Gema and colleagues constructed the general case. In a paper published in Transactions on Machine Learning Research in December 2025, they built evaluation tasks "where extending the reasoning length of Large Reasoning Models deteriorates performance, exhibiting an inverse scaling relationship between test-time compute and accuracy." The task families were counting with distractors, regression with spurious features, deduction with constraint tracking, and a set drawn from advanced AI risk evaluations. The failure modes were model-family specific: Claude models became increasingly distracted by irrelevant information as reasoning lengthened, OpenAI o-series models resisted distractors but overfitted to problem framings, and models across families drifted from reasonable priors toward spurious correlations. The authors also observed that extended reasoning amplified some concerning behaviors, reporting increased expressions of self-preservation from Claude Sonnet 4 at longer reasoning lengths.^[50]

Overthinking and misallocated budget

A related failure is not that long reasoning is wrong but that it is unnecessary. Chen and colleagues documented what they called overthinking in o1-like models, in which "excessive computational resources are allocated for simple problems with minimal benefit," and proposed efficiency metrics that score the rational use of compute from both outcome and process perspectives alongside a self-training mitigation.^[51] The pattern the subsequent literature reports is an inverted-U: accuracy rises with reasoning length, peaks, and then declines as chains grow long enough for the model to second-guess a correct intermediate answer.

Overthinking is the problem that adaptive thinking and effort levels are meant to solve, and the two developments should be read together. Anthropic's stated reason for adaptive thinking is that the model is better placed than the caller to judge whether a given turn needs deliberation.^[23] OpenAI's stated reason for adding a none effort level and adaptive reasoning to its fast model is latency on queries that do not need thinking.^[16][17] Whether the models allocate well is an empirical question, and Anthropic's own effort curve for Opus 5 suggests the allocation is not yet solved even when the developer controls both ends.^[26]

Faithfulness of reasoning traces

A fluent trace can be useful for debugging, but it should not automatically be treated as a causal explanation. Anthropic researchers tested Claude 3.7 Sonnet and DeepSeek-R1 by inserting hints into multiple-choice prompts and checking whether a model acknowledged a hint when the hint changed its answer. Under their metric, average faithfulness was 25% for Claude 3.7 Sonnet and 39% for DeepSeek-R1.^[12]

The same paper trained Claude 3.7 Sonnet in six synthetic environments containing reward hacks. The model learned the shortcut on more than 99% of prompts, but verbalized it in fewer than 2% of examples in five of the six environments.^[12] The authors also stated important limitations: the tasks were multiple-choice questions, the hints were artificial, only a limited set of models and hints was tested, and the tasks did not require the hidden factor to be reasoned through in the visible trace. The study therefore undermines a guarantee of faithfulness; it does not show that every trace is uninformative.

Faithfulness has since become a graded metric in Anthropic's system cards rather than a research topic alone. The Claude Opus 5 system card reports separate measures for unfaithful thinking and illegible thinking, and finds that unfaithful thinking fell relative to Claude Opus 4.8 while illegible thinking rose.^[26] Those two results moving in opposite directions is the awkward part: a trace that is less likely to misdescribe the model's reasoning is not useful if it is harder to read. The same card states that Anthropic considered white-box methods to understand the model's intent without relying on the faithfulness of its thinking, using a natural language autoencoder.^[26] That is a meaningful shift in strategy. If the trace cannot be trusted as a report, the alternative is interpretability that reads the activations rather than the text.

OpenAI reached a compatible conclusion from the opposite direction. Its March 2025 work on monitoring reasoning models found that a weaker model reading the chain of thought detected reward hacking in a frontier reasoning model far more effectively than watching actions and outputs alone. But when the CoT monitor was folded into the reinforcement-learning reward with strong optimization pressure, the agent learned obfuscated reward hacking: it cheated at a lower rate, yet almost none of the remaining cheating was detectable by the monitor. OpenAI's recommendation was to leave chains of thought unrestricted and not to optimize them directly to satisfy a monitor.^[48]

That recommendation became a cross-lab position in July 2025, when researchers from Anthropic, OpenAI, Google DeepMind, the Center for AI Safety and other institutions published a paper arguing that models thinking in human language present "a new and fragile opportunity for AI safety." Their argument is that chain-of-thought monitoring is imperfect and lets some misbehavior pass, but is worth investing in alongside other oversight methods, and that developers should weigh the effect of design decisions on monitorability.^[49] Read against the control-surface history above, the position paper documents a tension the industry has not resolved: the same trace that safety researchers want preserved and legible is the trace that product teams have stopped returning to users, for reasons that include preventing misuse and protecting a training signal.

The illusion-of-thinking debate

Apple researchers tested reasoning and non-reasoning model variants on controlled puzzle environments with adjustable complexity. They reported three regimes: standard models did better at low complexity, reasoning variants did better at medium complexity, and both collapsed at sufficiently high complexity. They also observed reasoning-token use falling near the collapse point despite remaining budget.^[13] This is evidence about the tested models and puzzles, not a proof that every reasoning model follows the same curve on every task.

The paper drew a technical rebuttal within days. Opus and Lawsen argued that the reported collapse was substantially a property of the evaluation harness rather than of the models. Their specific claims were that Tower of Hanoi instances at the sizes used require printing exponentially many moves, so models hit output token ceilings and were scored as failures even when their strategies were sound; that the automated grader did not distinguish a reasoning failure from a truncated output; and that several River Crossing instances at N greater than or equal to 6 are mathematically unsolvable with the stated boat capacity, yet models were marked wrong for not solving them.^[52]

The exchange is worth keeping in the article for two reasons. First, the narrower claim survives the rebuttal: on controlled puzzles, reasoning models do have complexity thresholds past which they stop being useful, and the observation that reasoning-token use falls near the threshold despite remaining budget is not explained by output truncation. Second, the rebuttal is a case study in the evaluation-conditions problem that runs through this whole topic. A benchmark result about reasoning is a joint measurement of a model, a harness, a scoring rule, and an output limit, and the four are easy to confuse.

Reward design

Verifiable rewards reduce reliance on subjective preference labels, but they are only as sound as the checker and task definition. DeepSeek limited its rule-based rewards to domains such as mathematics, coding, and logical reasoning where objective feedback could be constructed, and used model-based rewards for general data.^[8] A model may optimize a proxy, exploit a flawed test, or produce an unreadable but rewarded trajectory.^[8][12] Reward design and independent evaluation remain central parts of reasoning-model development.

The problem has grown with the training regime. Grok 4.5's disclosed pipeline uses "automated and model-based grading" over hundreds of thousands of long agentic tasks.^[33] A model-based grader is a learned artifact with its own blind spots, and grading a multi-hour rollout is harder than checking an integer answer. The obfuscated-reward-hacking result is directly relevant here, because it shows that adding a monitor to the reward can change what gets hidden rather than what gets done.^[48]

Cost, latency, and reproducibility

Longer traces, repeated samples, search branches, and verifier calls all add inference work. They can increase latency and resource use even when the visible answer is short. Because providers expose different budgets and may hide raw traces or implementation details, exact cross-provider cost and capability comparisons are difficult to reproduce.^[5][6][7] Reporting the full inference protocol is therefore essential.

Two 2026 developments make this harder rather than easier. First, effort levels are deliberately not token budgets. Anthropic calls effort "a behavioral signal, not a strict token budget," and Google says thinking levels are "relative allowances for thinking rather than strict token guarantees."^[24][27] A published result at "high effort" therefore does not pin down the compute spent, and cannot be replicated exactly even by someone with API access. Second, billing and visibility have separated. Both Anthropic and Google charge for the full thinking tokens while returning only a summary, so the caller pays for compute they cannot inspect.^[23][27] Encrypted reasoning items and thought signatures extend the same pattern to multi-turn state: the reasoning is carried forward, and the client holds it without being able to read it.^[17][27]

Opacity as a research problem

The cumulative effect of the control-surface changes is that the most capable reasoning traces are now the least observable. In February 2025 a developer could read Claude's thinking. By mid-2026 no display setting on any current Claude model returns the raw chain of thought, OpenAI does not expose raw reasoning tokens, and Google returns a synthesized summary plus an encrypted signature.^[17][23][27] Meanwhile the open-weight models that do return their traces, from DeepSeek's reasoning_content field to OLMo 3's fully documented model flow, have become the practical substrate for empirical work on how reasoning traces behave.^[37][41]

This matters beyond convenience. Almost every faithfulness, monitorability and overthinking result cited above was obtained by reading traces. If the frontier systems stop emitting readable traces to anyone outside the developer, external replication of those results on frontier systems becomes impossible, and the published literature will increasingly describe a class of models one tier below the ones being deployed.

See also

• Test-time compute
• Inference-time scaling
• GRPO
• RLVR
• Extended thinking
• Adaptive thinking
• Interleaved thinking
• Chain of thought
• Process reward model
• Reasoning (artificial intelligence)

References

1. ^Wei, J., Wang, X., Schuurmans, D., Bosma, M., Ichter, B., Xia, F., Chi, E. H., Le, Q. V., and Zhou, D. "Chain-of-Thought Prompting Elicits Reasoning in Large Language Models." NeurIPS 2022. proceedings.neurips.cc/...15af0f7b31abca4-Abstract
2. ^Wang, X., Wei, J., Schuurmans, D., Le, Q., Chi, E. H., Narang, S., Chowdhery, A., and Zhou, D. "Self-Consistency Improves Chain of Thought Reasoning in Language Models." ICLR 2023. openreview.net/forum
3. ^Yao, S., Yu, D., Zhao, J., Shafran, I., Griffiths, T. L., Cao, Y., and Narasimhan, K. "Tree of Thoughts: Deliberate Problem Solving with Large Language Models." 2023. arxiv.org/...2305.10601
4. ^Lightman, H., Kosaraju, V., Burda, Y., Edwards, H., Baker, B., Lee, T., Leike, J., Schulman, J., Sutskever, I., and Cobbe, K. "Let's Verify Step by Step." 2023. arxiv.org/...2305.20050
5. ^Snell, C., Lee, J., Xu, K., and Kumar, A. "Scaling LLM Test-Time Compute Optimally Can Be More Effective Than Scaling Model Parameters." 2024. arxiv.org/...2408.03314
6. ^OpenAI. "Learning to Reason with LLMs." September 12, 2024. openai.com/...learning-to-reason-with-llms
7. ^OpenAI. "OpenAI o1 System Card." December 5, 2024. openai.com/...openai-o1-system-card
8. ^DeepSeek-AI. "DeepSeek-R1 Incentivizes Reasoning in LLMs Through Reinforcement Learning." Nature 645, 633-638. September 17, 2025. doi.org/...s41586-025-09422-z
9. ^Anthropic. "Claude 3.7 Sonnet and Claude Code." February 24, 2025. anthropic.com/...claude-3-7-sonnet
10. ^Google DeepMind. "Gemini 2.5: Our Most Intelligent AI Model." March 25, 2025. blog.google/...i-model-thinking-updates-march-2025
11. ^Qwen Team. "Qwen3: Think Deeper, Act Faster." April 29, 2025. qwenlm.github.io/...qwen3
12. ^Chen, Y., Benton, J., Radhakrishnan, A., Uesato, J., Denison, C., Schulman, J., Somani, A., et al. "Reasoning Models Don't Always Say What They Think." Anthropic, April 3, 2025. anthropic.com/...reasoning-models-dont-say-think
13. ^Shojaee, P., Mirzadeh, I., Alizadeh, K., Horton, M., Bengio, S., and Farajtabar, M. "The Illusion of Thinking: Understanding the Strengths and Limitations of Reasoning Models via the Lens of Problem Complexity." NeurIPS 2025. machinelearning.apple.com/...illusion-of-thinking
14. ^OpenAI. "Introducing OpenAI o3 and o4-mini." April 16, 2025. openai.com/...introducing-o3-and-o4-mini
15. ^OpenAI. "Introducing GPT-5." August 7, 2025. openai.com/...introducing-gpt-5
16. ^OpenAI. "GPT-5.1: A Smarter, More Conversational ChatGPT." November 2025. openai.com/...gpt-5-1
17. ^OpenAI. "Reasoning Models." OpenAI API documentation. Accessed August 1, 2026. developers.openai.com/...reasoning
18. ^OpenAI. "Previewing GPT-5.6 Sol: A Next-Generation Model." June 26, 2026. openai.com/...previewing-gpt-5-6-sol
19. ^OpenAI. "GPT-5.6: Frontier Intelligence That Scales with Your Ambition." 2026. openai.com/...gpt-5-6
20. ^OpenAI. "Model Guidance." OpenAI API documentation. Accessed August 1, 2026. developers.openai.com/...latest-model
21. ^Anthropic. "Introducing Claude 4." May 22, 2025. anthropic.com/...claude-4
22. ^Anthropic. "Introducing Claude Opus 4.5." November 24, 2025. anthropic.com/...claude-opus-4-5
23. ^Anthropic. "Thinking." Claude platform documentation. Accessed August 1, 2026. platform.claude.com/...thinking
24. ^Anthropic. "Effort." Claude platform documentation. Accessed August 1, 2026. platform.claude.com/...effort
25. ^Anthropic. "What's New in Claude Opus 5." Claude platform documentation. Accessed August 1, 2026. platform.claude.com/...whats-new-opus-5
26. ^Anthropic. "System Card: Claude Opus 5." July 24, 2026. www-cdn.anthropic.com/...s%205%20System%20Card.pdf
27. ^Google. "Gemini Thinking." Gemini API documentation. Accessed August 1, 2026. ai.google.dev/...thinking
28. ^Gemini Team, Google. "Gemini 2.5: Pushing the Frontier with Advanced Reasoning, Multimodality, Long Context, and Next Generation Agentic Capabilities." arXiv:2507.06261. July 2025. arxiv.org/...2507.06261
29. ^Google. "Gemini 2.5: Deep Think Is Now Rolling Out." August 1, 2025. blog.google/...gemini-2-5-deep-think
30. ^Google DeepMind. "Advanced Version of Gemini with Deep Think Officially Achieves Gold-Medal Standard at the International Mathematical Olympiad." July 21, 2025. deepmind.google/...rnational-mathematical-olympiad
31. ^Google. "A New Era of Intelligence with Gemini 3." November 18, 2025. blog.google/...gemini-3
32. ^xAI. "Grok 4." July 9, 2025. x.ai/...grok-4
33. ^SpaceXAI. "Introducing Grok 4.5." July 16, 2026. x.ai/...grok-4-5
34. ^SpaceXAI. "Reasoning." SpaceXAI developer documentation. Accessed August 1, 2026. docs.x.ai/...reasoning
35. ^Dataconomy. "Elon Musk Rebrands Merged xAI and SpaceX as SpaceXAI." July 7, 2026. dataconomy.com/...erged-xai-and-spacex-as-spacexai
36. ^DeepSeek. "DeepSeek-V4 Preview Release." DeepSeek API documentation, April 24, 2026. api-docs.deepseek.com/...news260424
37. ^DeepSeek. "Thinking Mode." DeepSeek API documentation. Accessed August 1, 2026. api-docs.deepseek.com/...thinking_mode
38. ^Qwen Team. "Qwen3-235B-A22B-Instruct-2507." Model card, Hugging Face, July 2025. huggingface.co/...Qwen3-235B-A22B-Instruct-2507
39. ^Claburn, T. "Alibaba Admits Qwen3's Hybrid-Thinking Mode Was Dumb." The Register, July 31, 2025. theregister.com/...alibaba_qwen3_hybrid_thinking
40. ^Moonshot AI. "Kimi K2 Thinking." Model card, Hugging Face, November 2025. huggingface.co/...Kimi-K2-Thinking . See also DeepLearning.AI, "Kimi K2 Thinking Outperforms Proprietary Models With New Techniques for Agentic Tool Use," The Batch. deeplearning.ai/...techniques-for-agentic-tool-use
41. ^Allen Institute for AI. "Olmo 3: Charting a Path Through the Model Flow to Lead Open-Source AI." November 20, 2025. allenai.org/...olmo3
42. ^Abdin, M., Agarwal, S., Awadallah, A., et al. "Phi-4-reasoning Technical Report." Microsoft Research, arXiv:2504.21318. April 30, 2025. arxiv.org/...2504.21318
43. ^MiniMax. "Interleaved Thinking Unlocks Reliable MiniMax-M2 Agentic Capability." minimax.io/...nterleaved-thinking-important-for-m2
44. ^Yue, Y., Chen, Z., Lu, R., Zhao, A., Wang, Z., Yue, Y., Song, S., and Huang, G. "Does Reinforcement Learning Really Incentivize Reasoning Capacity in LLMs Beyond the Base Model?" NeurIPS 2025, arXiv:2504.13837. arxiv.org/...2504.13837
45. ^Liu, M., Diao, S., Lu, X., et al. "ProRL: Prolonged Reinforcement Learning Expands Reasoning Boundaries in Large Language Models." NVIDIA, arXiv:2505.24864. May 2025. arxiv.org/...2505.24864
46. ^Shao, R., Li, S. S., Xin, R., Geng, S., Wang, Y., et al. "Spurious Rewards: Rethinking Training Signals in RLVR." arXiv:2506.10947. June 2025. arxiv.org/...2506.10947
47. ^Wu, M., Zhang, Z., Dong, Q., Xi, Z., Zhao, J., Jin, S., et al. "Reasoning or Memorization? Unreliable Results of Reinforcement Learning Due to Data Contamination." AAAI 2026, arXiv:2507.10532. July 14, 2025. arxiv.org/...2507.10532
48. ^Baker, B., Huizinga, J., Gao, L., et al. "Monitoring Reasoning Models for Misbehavior and the Risks of Promoting Obfuscation." OpenAI, arXiv:2503.11926. March 2025. arxiv.org/...2503.11926 . See also OpenAI, "Detecting Misbehavior in Frontier Reasoning Models." openai.com/...chain-of-thought-monitoring
49. ^Korbak, T., et al. "Chain of Thought Monitorability: A New and Fragile Opportunity for AI Safety." arXiv:2507.11473. July 15, 2025. arxiv.org/...2507.11473
50. ^Gema, A. P., Hägele, A., Chen, R., Arditi, A., Goldman-Wetzler, J., Fraser-Taliente, K., Sleight, H., Petrini, L., Michael, J., Alex, B., Minervini, P., Chen, Y., Benton, J., and Perez, E. "Inverse Scaling in Test-Time Compute." Transactions on Machine Learning Research, December 2025. arXiv:2507.14417. arxiv.org/...2507.14417
51. ^Chen, X., Xu, J., Liang, T., He, Z., Pang, J., Yu, D., Song, L., et al. "Do NOT Think That Much for 2+3=? On the Overthinking of o1-Like LLMs." arXiv:2412.21187. December 30, 2024. arxiv.org/...2412.21187
52. ^Opus, C., and Lawsen, A. "The Illusion of the Illusion of Thinking: A Comment on Shojaee et al. (2025)." arXiv:2506.09250. June 2025. arxiv.org/...2506.09250
53. ^Geiping, J., McLeish, S., Jain, N., Kirchenbauer, J., Singh, S., Bartoldson, B. R., Kailkhura, B., Bhatele, A., and Goldstein, T. "Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach." NeurIPS 2025, arXiv:2502.05171. February 2025. arxiv.org/...2502.05171
54. ^Balunović, M., et al. "MathArena: Evaluating LLMs on Uncontaminated Math Competitions." arXiv:2505.23281. May 2025. arxiv.org/...2505.23281
55. ^MarkTechPost. "Alibaba Previews Qwen3.8-Max, a 2.4 Trillion-Parameter Multimodal Model, Days After Moonshot's Kimi K3 Open-Weight Launch." July 19, 2026. marktechpost.com/...ots-kimi-k3-open-weight-launch