Thinking Inertia in LLMs: No-Think Prompts Fail to Stop Visible Reasoning

A team of researchers from Stanford University, the University of Oxford, and Tsinghua University has published empirical evidence for a phenomenon they call "thinking inertia": large language models trained on extended reasoning continue generating visible inference steps even when explicitly instructed to skip them. The findings, released as an arXiv preprint on October 13, challenge a core assumption embedded in how engineers deploy reasoning-capable AI models — that telling a model not to think is a reliable way to make it stop.

The research has direct implications for teams using "no-think" mode to control inference costs, for product teams relying on reasoning model latency guarantees, and for alignment researchers who use visible reasoning traces as a proxy for what a model is actually doing.

Reasoning Models Have a Suppression Problem

Over the past two years, reasoning models — systems designed to produce extended, step-by-step internal monologues before generating a final answer — have moved from a research curiosity to a production tier. DeepSeek V4, Alibaba's Qwen3 series, OpenAI's o-series, and Anthropic's Claude with extended thinking all generate dedicated "thinking" output before committing to a response. These thinking tokens are billed at the same rates as regular output tokens, often making a reasoning-model API call several times more expensive than a standard one.

To manage this cost, every major provider now exposes a suppression control. DeepSeek V4 offers Non-think, Think High, and Think Max tiers; Qwen3 exposes an enable_thinking parameter; OpenAI provides reasoning effort levels; Anthropic's extended thinking API accepts a budget_tokens parameter. The common assumption has been that switching a model to non-thinking mode effectively turns off the reasoning pipeline — saving tokens, reducing latency, and simplifying behavior.

The Stanford-Oxford-Tsinghua paper tests that assumption directly. Across six widely used open-source and commercial models — including DeepSeek-V4-Flash and Qwen3-235B-A22B — and across six distinct prompting intervention strategies, the researchers could not find a prompt-level control that reliably eliminated what they measure as "visible explicit inference" in model outputs. The behavioral pattern persists even under the strictest tested condition, a prompt intervention requiring answer-only responses with no intermediate text. Full details and benchmark materials are available on the paper's project's companion site.

How the Study Measures What "Not Thinking" Actually Means

Prior research in this space relied on two proxies: whether a model's thinking mode was switched off, or whether the output was short. The paper argues both are unreliable. A disabled thinking mode can still emit reasoning-like text before the final answer. A short output can contain concentrated inference. Neither measure tells you whether the model is actually producing visible reasoning or not.

The team instead normalizes each model response into two components: a pre-answer trace — everything generated before the final response — and the final answer itself. They then apply three metrics to characterize the degree of thinking that persists:

Empty-Thinking Ratio (ETR) measures strict answer-only compliance: what fraction of responses have a completely empty pre-answer trace. An ETR of 1.0 would mean the model never generates any pre-answer text; in practice, ETR stays below 1.0 even under the strictest prompting conditions.

Question-Pre-answer Relevance (QRel.) is an instruction-aware similarity score measuring how closely the pre-answer text relates to the question. The researchers caution that this metric detects relevance, not reasoning — non-empty pre-answer text is not automatically reasoning, and the paper does not treat it as such. The metric captures whether the text is substantively related to the problem.

Explicit Inference Rate (EIR) uses a language model judge — Claude Opus 4.8 in robustness testing, with a 600-output human validation — to classify whether the pre-answer trace contains visible, explicit step-by-step reasoning. The EIR is the clearest direct measure of thinking inertia.

Across all three metrics, the researchers find a consistent gradient: Boolean questions (yes/no) show the highest answer-only compliance and lowest visible reasoning. Multiple-choice questions fall in the middle. Open-ended questions show the highest thinking inertia, highest pre-answer relevance, and highest EIR. Moving from the native think-off mode (M2) to a strict answer-only prompt (M5) reduces but does not eliminate EIR across question types.

Why Training Creates Inertia That Instructions Cannot Override

The pattern is not random. Models trained extensively on reasoning datasets develop a strong learned association between question input and reasoning-style output. Reinforcement learning processes that rewarded detailed, step-by-step answers during training create a generation prior that persists at inference time — the model's next-token prediction mechanism has effectively learned to reach for reasoning before producing a final answer, and a prompt instruction competes against that prior rather than replacing it.

To understand why this happens structurally, it helps to consider how modern reasoning models are built. Post-training — the phase that follows pretraining on a large text corpus — typically uses some form of reinforcement learning with verifiable rewards (RLVR) or reinforcement learning from human feedback (RLHF). In reasoning-focused post-training, the model receives positive reward signals for responses that include detailed, step-by-step reasoning leading to a correct answer. Over thousands of training steps, the model learns that question-answering contexts are a strong signal to produce reasoning text before a final answer. This prior is not stored in any single weight; it is distributed across the model's entire learned parameter landscape. A prompt instruction like "do not explain your reasoning" operates at the level of the context window, not the weight distribution. The trained prior and the prompt instruction pull in opposite directions at every autoregressive generation step.

This is structurally different from, say, telling a model to use a different language or avoid certain words. In those cases, the instruction overrides a surface-level stylistic pattern. Thinking inertia describes a case where the instruction conflicts with a deep behavioral preference shaped by the training objective itself. The model can comply with the instruction to varying degrees, but the trained tendency toward reasoning does not disappear at the level of text generation.

The answer-space gradient reveals the mechanism's logic from a different angle. In Boolean tasks, the optimal answer is structurally constrained: the model can produce "Yes" or "No" without a reasoning trace and still be accurate, because the answer doesn't depend on a chain of evidence visible in the output. The training prior toward reasoning has no room to assert itself when the output space is maximally constrained. In open-ended generation, by contrast, the model faces a genuine computational situation: producing a high-quality answer often requires working through intermediate reasoning steps. When suppression is forced in open-ended settings, accuracy drops. The inertia is not irrational — the model is, in some sense, correct that suppressing reasoning in open-ended tasks comes at a cost. The behavioral prior was shaped by a training signal that was itself correct: reasoning helps with complex generation tasks. Instruction-following and performance are in tension, and the model's generation process reflects that tension rather than cleanly resolving it in favor of the instruction.

The Accuracy-Compliance Trade-off That Complicates Suppression

One of the study's more consequential findings is that thinking inertia is not purely a compliance failure — it is partly a competence signal. On Boolean and multiple-choice tasks, accuracy remains stable even when models follow strict answer-only instructions. On open-ended tasks, however, forced suppression produces a measurable accuracy drop. This means engineering teams face a genuine trade-off, not just a reliability problem: applying the strictest available no-think controls to open-ended workloads will reduce the quality of model outputs, not just the length.

The researchers offer a partial mitigation: rewriting open-ended prompts to include candidate answers — effectively converting a generation task into a selection task — substantially improves ETR and reduces the accuracy-compliance trade-off. The model given a list of choices can select without needing to reason out loud, approaching the compliance levels seen on multiple-choice benchmarks. This is a practical workaround for structured use cases, but it requires deliberate prompt engineering and is not applicable to workloads that genuinely require open-form generation.

What Six Interventions Cover — and What None of Them Fixed

The paper tests six prompting intervention settings across the six models, ranging from a native mode switch (M2, which uses the model's built-in thinking-off control, such as DeepSeek's /think toggle or Qwen3's enable_thinking: false parameter) to a strict answer-only prompt (M5, which explicitly instructs the model to produce only a final answer with no preceding text). The paper does not name all six interventions explicitly in publicly available materials, but the M2-to-M5 axis represents a spectrum from the most natural and lightweight suppression (relying on the model's built-in controls) to the most aggressive prompt-based approach.

The finding that M5 reduces but does not eliminate EIR across all task types has direct implications for how practitioners build systems. The strictest readily available prompt intervention — an instruction that explicitly prohibits pre-answer text — is not a ceiling that fully enforces suppression. The gap between M2 and M5 at the open-ended end is meaningful enough to justify switching from default mode controls to explicit prompt instructions, but the gap between M5 and zero-inertia is also meaningful enough that neither approach can be treated as a reliable suppression mechanism for open-ended generation.

The paper's proposed mitigation — candidate-answer injection — works because it sidesteps the suppression problem rather than solving it. Converting an open-ended generation task into a multiple-choice selection task changes the answer space, which changes the model's training-prior dynamics. The model no longer needs to reason out loud to produce a high-quality response; it needs to match one of the provided candidates. This is a legitimate engineering workaround for use cases that permit it, but it requires significant prompt-engineering investment and cannot be applied to tasks where the point is exactly that the output is open-ended.

Production Infrastructure Has Already Seen the Problem

The thinking inertia paper describes a behavior that production engineers have encountered independently. A live bug report on the SGLang inference framework's GitHub tracker documents a Qwen3 model generating approximately 1,400 reasoning tokens on a response where the thinking_budget was set to 200. The model's content field returned null — no answer — while the reasoning trace consumed the entire token budget. Multiple engineering teams reported the same behavior with --enable-strict-thinking having no effect, and with speculative decoding enabled, the draft model generated reasoning tokens before the main model could intervene.

The SGLang issue is a different phenomenon from what the paper measures — it's a budget enforcement failure rather than a behavioral preference — but it illustrates the practical environment in which thinking inertia operates. Enterprises deploying Qwen3 or DeepSeek V4 in cost-sensitive pipelines have multiple points of failure to worry about: the model-level behavioral preference the paper documents, and the infrastructure-level enforcement gaps that independent teams have found in production.

A 2026 TowardsAI analysis described the broader pattern as a "hidden ops problem" — teams that configure reasoning models for high-volume classification tasks without auditing whether thinking tokens are actually being suppressed will face systematically wrong cost projections. At scale, even a modest rate of non-empty pre-answer traces across millions of API calls represents significant uncounted expense.

Read more: DeepSeek V4.1 Flash: New CED Architecture Cuts KV Cache Cost, Beats V4 Pro on Agents

Thinking Traces as Alignment Signals: A Deeper Problem

The paper explicitly scopes its findings to visible behavior — the text that appears in a model's pre-answer trace — rather than internal activation states or hidden computation. That scope boundary is important, but it points to a deeper issue that the study does not resolve.

Alignment researchers and AI safety practitioners have increasingly used visible reasoning traces as a window into model cognition. The intuition is straightforward: if a model shows its work, that work can be audited for errors, manipulated reasoning, or unintended inference patterns. Safety teams at major AI labs have incorporated chain-of-thought inspection into evaluation pipelines. Some interpretability research tries to understand whether the reasoning trace accurately reflects the model's underlying computation, or whether the trace and the final answer can become decoupled — a phenomenon sometimes called "unfaithful" chain-of-thought.

The thinking inertia paper reveals the other direction of this assumption is false — a model told not to think still generates reasoning-like text under many conditions. But it also reveals that the QRel. and EIR metrics rely on an LLM judge to determine what counts as "reasoning," and that non-empty pre-answer text is not automatically reasoning. The paper specifically cautions against treating QRel. as a reasoning detector; it measures relevance. Non-empty pre-answer text that is relevant to the question is not the same as explicit step-by-step inference. If the forward direction of trace reliability is uncertain — is the visible trace a reliable indicator of the model's reasoning? — the backward direction is equally uncertain: a present trace is not proof the model reasoned in the way the trace suggests, and an absent trace is not proof no reasoning occurred at the level of internal computation.

This is not a claim the paper makes explicitly, and it is a meaningful limitation of the study's scope. The researchers measure what appears in the output, not what happens in the model's internal processing. But the significance is that the paper makes the trace-reliability assumption observable as a production engineering problem, not just a theoretical concern. A model that generates a reasoning trace when told not to raises the question: when does it fail to generate a trace that accurately represents its reasoning when it is supposed to?

Several prior papers have examined related dynamics. That UC Berkeley study found that reasoning models can achieve competitive accuracy on structured mathematical benchmarks without any thinking tokens, using a "NoThinking" prefix that fills the thinking block with nothing. On AMC 2023 at low token budgets, their no-thinking approach matched the accuracy of a full thinking pass at a fraction of the token cost. That work suggests the thinking trace is not always necessary for accuracy on well-structured tasks — which is consistent with the current paper's finding that accuracy loss under suppression is concentrated in open-ended tasks, not constrained ones. The UC Berkeley finding also complicates the alignment picture in a parallel direction: if a model can produce correct answers on structured tasks without any thinking trace, then the presence or absence of a trace does not determine correctness — the trace is epiphenomenal in that setting, not causal.

Together, these results paint a picture in which the reasoning trace occupies an ambiguous position: sometimes necessary for accuracy, sometimes not; sometimes suppressed by instruction, sometimes not; generated in response to a trained behavioral prior that operates independently of the immediate prompt. The implications for auditability and alignment verification are not resolved by either paper, and they represent a growing gap between the way interpretability research uses reasoning traces and what the empirical evidence actually supports.

What Model Providers and Engineers Need to Address

The paper does not name specific models that performed best or worst at suppression compliance, and the four models beyond DeepSeek-V4-Flash and Qwen3-235B-A22B remain undisclosed in publicly available materials. That limits the study's immediate utility for model selection, though the multi-model consistency of the finding suggests thinking inertia is not an artifact of any single architecture or training pipeline.

For enterprise teams, the most actionable guidance from the paper is structural: classify workloads by answer-space type before configuring a reasoning model in no-think mode. Boolean classification and fixed-choice selection tasks — document categorization, sentiment tagging, routing decisions — have high ETR under suppression controls and stable accuracy. "No-think" mode on these workloads is likely to function close to its intended behavior. Open-ended generation tasks — summarization, drafting, analysis, free-form question answering — have low ETR and a meaningful accuracy-compliance trade-off. For these, teams face three options: accept reasoning tokens as a necessary production cost (and budget accordingly), use candidate-answer injection to convert prompts to selection format where the task permits, or apply no-think mode and accept that response quality will be meaningfully lower than with reasoning enabled.

The cost accounting implication is immediate. Many enterprise teams running reasoning models at scale have built cost models on the assumption that non-thinking mode routes reliably to cheaper, no-reasoning responses. If ETR at the model level is substantially below 1.0 for their workload mix — which is likely for any pipeline with significant open-ended generation — those cost models are wrong. The degree of underestimation depends on the actual ETR distribution across query types, which the paper establishes cannot be assumed from mode settings alone and must be measured empirically.

For model developers and inference framework engineers, the paper highlights a gap between API contract and runtime behavior that prompt instructions alone cannot close. Providers that advertise cost savings from non-thinking modes implicitly represent that reasoning tokens are suppressed; the study's evidence — and the independent production failures already documented in open-source frameworks like SGLang — suggest that representation requires more careful qualification. The three main solution paths available are not mutually exclusive: training-level changes (reinforcing no-think compliance on open-ended tasks through additional RL from demonstrations of suppressed reasoning), infrastructure-level enforcement (hard token budget cutoffs in the serving layer that truncate pre-answer traces before they can grow), and API-level transparency (publishing ETR distributions by task type and intervention setting so buyers can make informed decisions). Each path has costs and limitations: additional RL post-training risks degrading performance on tasks where reasoning is genuinely beneficial; hard infrastructure cutoffs may truncate legitimate reasoning along with inertia-driven traces; API-level transparency requires the provider to run the experiments and publish results that may be competitively disadvantageous.

The commercial pressure runs in one direction only: providers benefit from users paying for reasoning tokens they believe are suppressed. Without regulatory or market pressure to measure and disclose ETR, the default incentive structure does not favor fixing the problem.

Prior Research and the Adaptive Thinking Gap

The thinking inertia finding fits into a broader 2025–2026 research trend examining when, how, and whether reasoning models actually need to reason. AdaptThink (EMNLP 2025) showed models can learn to selectively apply reasoning effort based on task difficulty. "When to Continue Thinking" (arXiv 2505.15400) proposed adaptive mode-switching as a way to optimize the cost-quality trade-off at inference time without requiring separate model versions. Separate work on thinking budgets and token-efficient reasoning (arXiv 2507.09662) surveys the landscape of approaches for reducing the computational cost of extended inference. These approaches share a premise: that reasoning is a resource with variable marginal value, not a fixed behavior to be always on or always off, and that the goal is smarter allocation rather than blunt suppression.

Thinking inertia complicates that picture from a different direction. Adaptive thinking research assumes the model can reliably transition between reasoning and non-reasoning modes; the current paper shows that assumption is empirically false across multiple models and prompting strategies. If the model cannot reliably turn reasoning off when instructed, then adaptive thinking systems that rely on prompt-level mode switching — rather than training-level behavioral modification — inherit the inertia problem. You cannot build a system that intelligently decides when not to think if the model's trained prior overrides the decision in a significant fraction of cases.

The paper is also implicitly in tension with how providers currently market thinking controls. DeepSeek, Anthropic, OpenAI, and Google all present their thinking controls as meaningful behavioral switches. The thinking inertia study is the first systematic evaluation that tests whether those switches actually work, using metrics designed to detect failure modes that mode switches alone would miss. The fact that none of six tested interventions achieves full suppression across all task types is not a minor calibration issue; it is evidence that prompt-level controls are structurally insufficient for the problem they are being used to solve.

This is the open technical question the paper leaves the field with: not "can models be effective without thinking" — that is already partially answered for structured tasks — but "can models be reliably instructed not to produce visible reasoning, and if not, why not?" The answer will require either deeper interpretability into the trained behavioral prior that generates reasoning-like text under suppression, or a more fundamental rethinking of how reasoning capabilities are embedded during post-training. The thinking inertia benchmark framework the paper introduces — ETR, QRel., and EIR across task types — provides the measurement infrastructure to track progress on that question as the field develops solutions.