🤖 machine learning

When Thinking Hurts: Epistemic Signals in the Reasoning Chains of Visual Language Models

This paper empirically characterizes three distinct patterns of answer entropy behavior in thinking-mode Visual Language Models, demonstrating that reasoning chain entropy serves as a more reliable uncertainty signal than answer entropy and enabling a cost-free abstention mechanism that significantly boosts accuracy on adversarial and reasoning tasks.

Original authors: Mayank Singal

Published 2026-07-10

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Mayank Singal

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a super-smart robot friend who loves to solve puzzles. Usually, when you ask it a question, it thinks for a split second and blurts out an answer. But recently, a new generation of these robots has started doing something different: before they give you the final answer, they write out a whole "thinking chain"—a long, step-by-step diary of their reasoning inside a special ... box. It's like watching them scribble notes on a napkin before ordering their coffee.

The big question researchers asked was: If these robots are thinking so hard, can we tell when they are confused or about to make a mistake?

The "Silent Scream" of the Answer

Traditionally, to check if a robot is unsure, we look at how "jittery" its final answer is. If a robot is confident, its answer is steady; if it's confused, the answer wobbles. This is called answer entropy.

But here is the twist the paper discovered: For these new "thinking" robots, looking at the final answer is like trying to hear a whisper in a hurricane.

When the researchers tested a model called Qwen3-VL-8B-Thinking, they found that the moment the robot finished its thinking chain, it completely locked onto its final answer. The "jitter" vanished. The robot's final answer became so confident that the uncertainty signal dropped to 0.492 (which is basically a coin flip, or pure chance). It's as if the robot did all its thinking, decided on a path, and then shouted the answer so loudly that you couldn't hear any doubt at all.

The paper explicitly argues against the idea that we can just look at the final answer to spot mistakes in these thinking models. In fact, for the Qwen model, looking at the final answer was worse than guessing randomly because the robot was so overconfident in its wrong answers.

The Real Clue: The Thinking Diary

So, if the final answer is a dead end, where do we look? The paper suggests we look at the thinking chain itself—the "napkin notes" the robot wrote before speaking.

The researchers found that the process of thinking holds the secret. They measured the "chaos" or "wobble" inside the thinking chain.

For the Qwen model: The thinking chain had a signal score of 0.647, which is much better than the useless 0.492 from the final answer.
For another model, GLM-4.1V-9B-Thinking: The final answer was actually okay (0.716), but the thinking chain was even better (0.759).
For a third model, InternVL3-8B: It only used its thinking chain for about 50% of the questions. When it did think, the chain signal was slightly better than the answer, but the most important clue was simply whether it decided to think at all. If it skipped the thinking chain, it was more likely to be wrong.

The paper suggests that the thinking chain acts like a "pre-commitment" signal. It's the robot's internal struggle. If the robot is really struggling to figure out the answer (high entropy in the chain), it's more likely to be wrong later. If it thinks quickly and smoothly, it's probably right.

The "Refusal" Gate

There's another weird thing these robots do. Sometimes, instead of giving an answer, they just stop. They "abstain."

On one test (POPE), 22.1% of the time, the Qwen robot refused to answer.
On another test (HallusionBench), it was 12.6%.

The paper notes a funny pattern: the robot is much more likely to quit when asking about things that aren't there (absent objects) compared to things that are there. It's like a robot saying, "I can't see that ghost you're talking about, so I'm not going to guess."

The researchers showed that if we build a simple "gate" that says, "If the robot's thinking chain is too long or too messy, or if it refuses to answer, let's just skip that question," we can boost accuracy dramatically.

Without the gate, the robot was right 71.0% of the time.
With the gate (and skipping about 37% of the hardest questions), the robot's accuracy on the remaining questions jumped to 93.8%.

This isn't a magic fix for everything, but it's a practical trick: if the robot is sweating (long, messy thinking chain) or refusing to play, it's probably not safe to trust its answer.

What About Other Questions?

The researchers also tested this on open-ended questions (not just "Yes/No"). They found the same pattern: the thinking chain was a better predictor of mistakes than the final answer.

For free-form answers, the final answer signal was terrible (0.467, worse than a coin flip).
But the thinking chain signal was strong (0.733).

This suggests the problem isn't just with "Yes/No" questions; the thinking chain is a more reliable map of the robot's confidence than the final destination.

The Bottom Line

The paper concludes that for these new "thinking" robots, you cannot trust the final answer to tell you if they are unsure. The act of thinking collapses their uncertainty, making them look super-confident even when they are wrong.

Instead, we have to listen to the thinking process itself. The "chaos" in the reasoning chain is the real signal. While this works very well for the models they tested (Qwen and GLM), the authors suggest we need to check if this holds true for even bigger models or if we change how the robot thinks (like letting it guess randomly instead of picking the best answer every time). For now, though, if you want to know if a thinking robot is hallucinating, don't look at what it says—look at how it thought.

Technical Summary: When Thinking Hurts: Epistemic Signals in the Reasoning Chains of Visual Language Models

Problem Statement

Visual Language Models (VLMs) are increasingly adopting a "thinking-mode" architecture, where the model generates an explicit reasoning chain (e.g., within <thought>...</thought> tags) before committing to a final answer. While this mimics human deliberation, the authors identify a critical failure in conventional uncertainty quantification (UQ) methods for this paradigm.

Standard UQ techniques rely on the entropy of the answer token distribution ( $H_{ans}$ ) to estimate epistemic uncertainty. The paper demonstrates that in thinking-mode VLMs, the reasoning chain acts as a strong conditioning prior that "pre-commits" the model to a specific answer direction. This process collapses the answer token distribution, destroying the variance that entropy-based methods require to function. Consequently, conventional answer entropy becomes a chance-level predictor of hallucinations (AUROC $\approx$ 0.5), rendering existing output-level uncertainty methods useless for these models under greedy decoding.

Methodology

The study employs a controlled ablation and cross-family empirical characterization to isolate the effects of thinking-mode decoding.

Models: The authors evaluate three distinct thinking-mode VLM families:
- Qwen3-VL-8B-Thinking: Generates reasoning chains before answering.
- GLM-4.1V-9B-Thinking: A competing thinking-mode model.
- InternVL3-8B: A model exhibiting selective thinking behavior.
- Control: Qwen3-VL-8B-Instruct (non-thinking variant of the same family) is used to establish a baseline where answer entropy remains a valid signal.
Benchmarks:
- POPE (Adversarial): 1,000 binary yes/no questions regarding object presence in COCO images, designed to test hallucination.
- HallusionBench: 951 visual questions covering illusions, edited images, and reasoning tasks.
- VQAv2 (Pilot): 300 open-ended questions to test generalization beyond binary tasks.
Signals: The study extracts signals from a single greedy forward pass (no additional inference cost):
- $H_{ans}$ : Mean Shannon entropy over answer tokens.
- $H_{think}$ : Mean Shannon entropy over tokens within the thinking chain.
- $L$ : Length of the thinking chain.
Evaluation: The authors measure the Area Under the Receiver Operating Characteristic (AUROC) for predicting false positives (hallucinations) versus true positives, both unconditionally and conditioned on answer direction (e.g., restricting to "yes" predictions to remove confounds).

Key Findings

1. Answer Entropy Collapse

The core finding is that thinking-mode decoding causes a qualitative collapse in answer entropy.

Qwen3-VL-8B-Thinking: Shows complete collapse. On POPE, the AUROC for $H_{ans}$ drops from 0.899 (non-thinking control) to 0.492 (chance level). The model fully pre-commits during the thinking phase, leaving no variance in the answer distribution to signal uncertainty.
GLM-4.1V-9B-Thinking: Shows no collapse. $H_{ans}$ remains predictive (AUROC 0.716), suggesting its training recipe does not enforce full pre-commitment.
InternVL3-8B: Shows selective thinking. Chains are generated on only 50% of samples. $H_{ans}$ is 0.675 on the full set but drops to 0.602 on the thinking-only subset.

2. Superiority of Chain Signals

Across all models where chains are generated, the entropy of the thinking chain ( $H_{think}$ ) and chain length ( $L$ ) outperform answer entropy.

Qwen: $H_{think}$ achieves an AUROC of 0.647 vs. 0.492 for $H_{ans}$ .
GLM: $H_{think}$ achieves 0.759 vs. 0.716 for $H_{ans}$ .
InternVL3: On the thinking-only subset, $H_{think}$ (0.608) marginally outperforms $H_{ans}$ (0.602), though the small number of false positives (n=17) makes this statistically unreliable. However, the presence of a chain is a strong signal for InternVL3; the false positive rate is more than double when the model skips thinking (13.1%) compared to when it generates a chain (6.0%).

3. Epistemic Hierarchy and Abstention

The authors identify a monotonic hierarchy in chain signals:

Committed-Correct (TP): Shortest chains, lowest entropy.
Committed-Wrong (FP): Longer chains, higher entropy.
Abstaining-with-Chain: Longest chains, highest entropy.
This confirms that chain signals track the model's epistemic state (struggle to resolve) rather than just surface output properties.
Structured Abstention: Thinking models exhibit high abstention rates (22.1% on POPE, 12.6% on HallusionBench), with a consistent asymmetry toward absent-object queries. The mechanism differs by model: Qwen often over-deliberates (long chains that fail to resolve), while InternVL3 often fails to generate a chain at all on difficult queries.

4. Practical Utility: The Abstention Gate

The paper proposes a practical "chain gate" that refuses samples with unclear signals or long chains.

On POPE, applying this gate to the thinking-mode model raises accuracy from 71.0% (baseline) to 93.8% at 62.7% coverage.
While the non-thinking "Instruct" model still achieves higher accuracy (96.7% at similar coverage) using answer entropy, the chain gate is the only viable option for deploying thinking-mode models, as answer entropy provides no signal in this regime.

5. Generalization to Open-Ended Tasks

A pilot on VQAv2 confirms that chain entropy (0.680) outperforms answer entropy (0.595) even in free-form answer scenarios. The gap is largest for free-form answers (0.733 vs. 0.467), suggesting the advantage is not an artifact of binary task structure.

Significance and Claims

The paper claims to provide the first empirical characterization of answer entropy behavior in thinking-mode VLMs, revealing that the "collapse" phenomenon is training-recipe-dependent rather than a universal property of the architecture.

The primary significance lies in shifting the paradigm for uncertainty estimation in reasoning models:

Signal Location: For thinking-mode VLMs, the epistemic signal resides in the reasoning process (the chain), not the final output.
Zero-Cost Solution: Reliable hallucination detection can be achieved using signals ( $H_{think}$ , $L$ ) extracted from a single greedy forward pass, requiring no additional inference, sampling, or external probes.
Deployment Tractability: The authors argue that uncertainty estimation for thinking-mode VLMs must track the reasoning process to be epistemically tractable. They demonstrate that without this shift, these models are effectively "blind" to their own uncertainty when using standard output-level metrics.

The authors remain modest regarding the universality of these findings, noting that results are based on 8–9B scale models and greedy decoding. They explicitly state that whether these patterns persist under stochastic sampling (temperature > 0) or in larger models (32B+) remains an open question.