Most teams treat “thinking mode” as a switch. Turn it on and the model reasons through the problem step by step; turn it off and it should answer directly. That mental model is convenient, and according to a recent study, it is wrong. When researchers tested whether large language models can actually stop reasoning when told to, they found that explicit inference persists even under strict controls — a phenomenon they call thinking inertia.
This matters for anyone shipping LLM features in production. If you pay per output token, residual hidden reasoning means paying for computation the user never asked for. If you serve latency-sensitive endpoints, it means your “fast path” is not as fast as you assume. And if you audit model behavior for compliance, it means the absence of a visible reasoning trace is not evidence that no reasoning happened.
The problem with how we measure “no thinking”
Before the paper Thinking Inertia: LLMs Keep Thinking When Told Not To, the common way to claim a model was “not thinking” was one of two proxies: disable the thinking mode in the API, or check that the output trace is short. Both turn out to be unreliable.
A disabled thinking mode does not guarantee the model stops emitting reasoning — some models still produce inference-like text anyway. And a short trace tells you little, because reasoning can be compressed into a few dense sentences or padded out with filler that looks like reasoning but isn’t. Length is not a proxy for cognition in either direction.
The study takes a cleaner approach. Each response is normalized into two parts: a pre-answer trace (anything the model emits before its final answer) and the answer itself. The pre-answer trace is then scored at three levels:
- Empty-Thinking Rate — the strictest measure: did the model emit literally nothing before the answer?
- Question–Pre-answer Relevance — an instruction-aware similarity score between the question and the pre-answer text. This catches cases where the model writes something relevant but non-inferential, like restating the question.
- Explicit Inference Rate — an LLM-as-judge assessment of whether the trace contains visible, explicit inference steps.
The three levels matter because they separate behaviors that a single binary metric would collapse together. Answer-only output, relevant-but-non-inferential text, and explicit step-by-step inference are different regimes, and the study shows models move between them in ways that prompt engineering alone cannot fully control.
What the experiments found
The researchers evaluated six prompting interventions — variations of instructing the model to answer directly, skip reasoning, or restrict its output — across six LLMs, on three task families: Boolean questions, multiple choice, and open-ended generation. The headline results:
- Explicit no-think controls cannot reliably eliminate visible inference. Models exhibit thinking inertia: reasoning persists even when the instructions demand it not.
- Inertia gets worse as the answer space opens. Closed tasks like Boolean and multiple-choice questions suppress it more easily; open-ended generation shows the most residual reasoning.
- Accuracy stays stable on closed tasks even when the model sneaks in reasoning. On open-ended tasks there is a real trade-off between answer-only compliance and task accuracy — forcing compliance can cost quality.
- When candidate answers are supplied in the prompt, models find it easier to produce answer-only responses. The availability of a constrained answer set changes the model’s urge to reason.
That last point is the most practically interesting one. It suggests thinking inertia is not a fixed model property but a function of the task shape. The model reasons when the space of acceptable outputs is large and answers only when the space is small. Reasoning, in other words, behaves like a search process — and search is only worth running when the search space is not already collapsed.
Why “just turn off the thinking flag” fails
Production systems frequently rely on provider-side controls: a parameter that disables chain-of-thought, or a system prompt line like “answer directly without explanation.” The study’s findings explain the failure reports teams see when they measure instead of assume:
- Provider settings are inputs, not behaviors. Disabling a thinking mode changes the conditioning, but the model’s learned disposition to verbalize inference does not disappear. Compliance has to be measured at the output level.
- Instruction compliance degrades with task openness. The same “no thinking” instruction that works on your classification endpoint will leak reasoning on your summarization endpoint.
- Judged compliance differs from surface compliance. A response can look answer-only to a regex and still contain a full inference chain in the pre-answer text.
A concrete example. Suppose you run a support-ticket triage service that classifies tickets into a fixed set of categories, and you want the fastest possible responses. The measured behavior depends on the response shape you demand:
// High answer-space: free text justification + category
// Model likely produces a reasoning-heavy pre-answer trace
{
"response": {
"category": "billing",
"explanation": "The customer mentions a double charge..."
}
}
// Low answer-space: category only, constrained by schema
// Answer-only compliance is much easier for the model
{
"response": "billing"
}If you need both a category and human-readable justification, the finding implies you should expect (and budget for) the reasoning that comes along with the open-ended justification — not expect to get it for free by toggling a flag.
Practical steps for teams shipping today
The study frames no-thinking as a capability that deserves systematic evaluation, alongside reasoning ability. Concretely, that means adding it to your eval suite rather than trusting config:
- Measure, don’t configure. After changing any thinking-related setting, evaluate the pre-answer trace, not just the answer. Track an explicit-inference metric per task type.
- Segment by answer space. Expect different compliance behavior for closed (classification, extraction) versus open (generation, summarization) tasks, and set token budgets accordingly.
- Constrain outputs structurally. Schema-constrained decoding, choice lists, and enumerated outputs shrink the answer space and — per the study’s own observation — make answer-only responses easier for the model to produce. Structural constraint beats verbal instruction.
- Watch the accuracy trade-off. On open-ended tasks, forcing strict answer-only compliance can degrade quality. Decide explicitly which you value per endpoint instead of enforcing one policy globally.
Related directions in reasoning research
Thinking inertia is one side of a broader 2026 research wave that treats reasoning as something to be controlled and measured rather than maximized. Two other papers from the same period show the range:
TPPO (Tracking-Value PPO) tackles credit assignment in reasoning RL. Standard PPO critics struggle to track how the value of a partial solution evolves toward a sparse terminal reward. TPPO exploits a Bayesian decomposition of successive prefix values — additive updates in log-odds space — to parameterize value as a cumulative sum of position-wise outputs. Trained with terminal-outcome supervision, it improves math reasoning scores over PPO by 7.0 and 8.4 points on Qwen3-4B-Base and Qwen3-8B-Base respectively, with better out-of-distribution generalization. It is about making the model reason better; thinking inertia is about making it stop.
Jeva (System One Models from First Principles) removes verbalized reasoning from the picture entirely for decision tasks. It argues that mapping decisions onto serialized text — the way LLMs pick an option by generating tokens — violates four structural requirements: decisions should distinguish absence of an answer from uncertainty among candidates (null-aware), be invariant to the order of options, scale to growing candidate sets without redefining the output space, and reuse computation across requests. Jeva’s architecture encodes each option independently and refines only the request state, achieving near-perfect null detection, no decision flips under permutation, and lower latency through cross-request caching. It is a reminder that “reason faster” is sometimes the wrong goal — some tasks never needed generative reasoning at all.
Read together, the three papers sketch a maturing field: measure reasoning precisely (Thinking Inertia), assign credit for it correctly (TPPO), and know when to skip it entirely (Jeva).
Takeaway
The comfortable assumption that a model configured not to think will not think is exactly the kind of assumption that produces surprise cloud bills and confusing audit results. Reasoning is a behavior you observe, not a setting you set. Put it under measurement: track pre-answer traces per task type, prefer structural output constraints over verbal instructions, and treat “no thinking” as a capability with a real accuracy trade-off on open-ended work — one your eval suite should cover as seriously as correctness itself.