💬 NLP

The Detection--Extraction Gap: Models Know the Answer Before They Can Say It

This paper identifies a "detection–extraction gap" in modern reasoning models where the correct answer becomes recoverable from the internal state long before it is explicitly generated, and proposes a Black-box Adaptive Early Exit method that leverages this asymmetry to significantly reduce generation costs while improving accuracy.

Original authors: Hanyang Wang, Mingxuan Zhu

Published 2026-04-09

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Hanyang Wang, Mingxuan Zhu

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

The Big Idea: The Model Knows the Answer, But Can't Say It Yet

Imagine you are taking a difficult math test. You are working through the problem step-by-step on a piece of scratch paper. Suddenly, at step 3 out of 10, you realize, "Oh! I know the answer is 42." Your brain has solved it.

But, because you are following strict instructions to "show your work," you keep writing. You write steps 4, 5, 6, 7, 8, 9, and 10. In fact, you keep writing for so long that by the time you finish, you accidentally change your mind, get confused, or write down the wrong number (43) because you overthought it.

This is exactly what modern AI reasoning models do.

The paper discovers that AI models often figure out the correct answer very early in their thinking process (sometimes after just 10% of the text they generate). However, they keep "thinking" (generating text) for a long time afterward, often messing up the answer or wasting a huge amount of computing power.

The Core Problem: The "Detection–Extraction Gap"

The researchers found a strange gap between what the AI knows and what it can say.

Detection (Knowing): If you let the AI just keep talking freely, it will eventually say the right answer. Even if you stop it early, the "seed" of the correct answer is already there.
Extraction (Saying): If you interrupt the AI early and force it to stop and give you the final answer right now (e.g., by typing "Therefore, the answer is..."), it often fails. It might give you a wrong number, a partial calculation, or nonsense.

The Analogy:
Think of the AI as a chef cooking a complex stew.

Detection: If you let the chef keep stirring, they will eventually taste the stew and say, "It's ready!"
Extraction: If you run into the kitchen at the 10-minute mark and yell, "STOP! Tell me the recipe!" the chef might panic. They haven't finished seasoning yet. They might shout out "Salt!" or "Flour!" (intermediate steps) instead of the final dish name. They know the dish is almost done, but they can't articulate the final result yet because the "forcing" interrupted their flow.

The paper calls this the Detection–Extraction Gap. The AI "knows" the answer is in its head, but the act of forcing it to stop and speak ruins its ability to retrieve that answer correctly.

The Solution: BAEE (The "Smart Pause")

The researchers didn't just find a problem; they built a fix called BAEE (Black-box Adaptive Early Exit).

Instead of forcing the AI to stop and give a final answer (which causes the "panic" described above), BAEE does something clever:

It stops the AI early.
Instead of asking "What is the answer?", it asks the AI to keep thinking a few more times in parallel (like asking the chef to taste the stew three more times quickly).
It looks at those few extra thoughts. If they all agree on the answer, it stops the main process and declares, "We have the answer!"

The Result:

Speed: They cut the time the AI spends thinking by 70–78%. It's like finishing a 10-hour movie by watching the first 2 hours and then fast-forwarding to the end because you figured out the plot.
Accuracy: Surprisingly, the AI got better at answering. Why? Because it stopped before it started overthinking and making mistakes. It prevented the AI from "digging a hole" in its own logic.

Why This Matters

It's a Structural Flaw, Not a Bug: This isn't just a mistake in one specific AI. It happens across different models (like Qwen and GPT) and different tasks (Math, Science, Coding). It seems to be a fundamental quirk of how these models are built: they encode the answer in their "brain" long before their "mouth" is ready to say it.
Coding is the Worst Offender: The gap was biggest in coding tasks. The AI figures out the logic for a program very quickly, but then spends 85% of its time writing the boring details (brackets, formatting, comments). If you stop it early, you save massive amounts of time and actually get better code because the AI didn't have time to introduce bugs while overthinking.
Black-Box Friendly: You don't need to open up the AI's internal code to fix this. You can do it just by talking to the AI (using its public API), which means this trick works on closed-source models like the ones from OpenAI or Google.

Summary in One Sentence

AI models often solve problems way faster than they admit; by letting them "think out loud" briefly to confirm the answer before forcing a final conclusion, we can make them faster, cheaper, and more accurate by stopping them before they overthink and mess up.

1. Problem Statement

Modern reasoning models (Chain-of-Thought or CoT) often generate thousands of tokens after the correct answer has already been determined within the model's internal state. While prior research using white-box probes (internal hidden states) has established that models "know" the answer early, these methods are limited to open-weight models.

This paper identifies a critical structural phenomenon in black-box settings: the Detection–Extraction Gap.

Detection: The model's state encodes the correct answer early in the generation process (recoverable via free continuation).
Extraction: When forced to output the answer immediately via a specific prompt suffix (e.g., "Therefore, the answer is..."), the model frequently fails to produce the correct answer, even though it "knows" it.

This gap implies that standard early-exit strategies, which rely on forcing an answer from a partial prefix, inherit a high failure rate, causing significant accuracy drops.

2. Methodology

The authors propose a black-box evaluation framework using only API access (sampling and logprobs) to quantify this gap and develop a solution.

A. Core Protocols

The study defines two probing mechanisms applied to prefixes of the reasoning trace ( $c_{1:k}$ ):

Prefix Self-Consistency (PSC): Measures recoverability. The model is given the prefix and asked to generate $N=8$ independent continuations. If the majority of these free continuations yield the correct answer, the answer is considered "recoverable" from the prefix.
Early Forced Answering (EFA): Measures extractability. The model is given the prefix and a forcing suffix (e.g., "\nTherefore, the final answer is \boxed{"). It must output the answer immediately.

B. The Detection–Extraction Gap

The gap ( $\Delta$ ) is defined as the difference between PSC accuracy and EFA accuracy at a given prefix fraction.

Finding: At early checkpoints (e.g., 10% of the CoT), PSC often shows high accuracy (70–90%), while EFA accuracy is low (20–40%).
Mechanism: The authors formalize this using a Total Variation (TV) distance bound. The forcing suffix induces a distributional shift that pushes the model's output away from the high-probability region containing the correct answer. Free continuations preserve the natural generation distribution, whereas forced extraction disrupts it.

C. Proposed Solution: Black-box Adaptive Early Exit (BAEE)

BAEE is an inference-time policy designed to exploit the gap:

Detection & Extraction: Instead of using EFA (which fails), BAEE uses PSC for both detecting commitment and extracting the answer.
Process: Starting from a small prefix (e.g., 10%), the system samples 8 continuations. If the self-consistency score exceeds a threshold $\theta$ , the system exits, returning the majority vote of the continuations.
Benefit: By avoiding the forcing suffix, BAEE bypasses the distributional shift, preventing the "overthinking" or "theater" generation that often corrupts correct answers in later tokens.

3. Key Contributions

The Detection–Extraction Gap: The first empirical demonstration that reasoning models can recover answers from early prefixes via free generation but fail to extract them under forced constraints. This is a structural property of partially formed reasoning states, not a model-specific artifact.
Task-Topology Dependence:
- Math (MATH-500): Commitment is early (25–30% of CoT), but PSC trajectories are non-monotone (agreement peaks then drops due to perturbations).
- Science (GPQA-Diamond): Commitment is later, and PSC trajectories are monotone (agreement grows with context).
- Code (HumanEval): Post-commitment generation is highest (85–88%), and the "Thinking vs. No-Thinking" gap collapses, suggesting code generation involves extensive implementation detail after the algorithm is decided.
BAEE Algorithm: A practical early-exit policy that achieves 70–78% reduction in serial generation while improving accuracy by 1–5 percentage points across all models. For "Thinking" models, gains reach 5.8 pp (math) and 13.6 pp (code) by preventing post-commitment overwriting.

4. Experimental Results

The study evaluated five model configurations (Qwen3-8B/32B in Think/NoThink modes, and GPT-OSS-120B) across three benchmarks (MATH-500, GPQA-Diamond, HumanEval).

Commitment Timing: Models commit to the answer early. For Qwen3-32B-Think, 69% of CoT tokens are generated after the answer is recoverable.
The Gap Magnitude: At 10% prefix, PSC accuracy is ~70–90%, while EFA accuracy is ~20–35%. The gap is largest for GPT-OSS-120B (70 pp gap).
BAEE Performance:
- Accuracy: Outperforms full CoT generation on Think models (e.g., 32B-Think: 82% $\to$ 86% on MATH-500).
- Efficiency: Reduces serial token generation by 70–78%.
- Cost: While total token usage increases by 3–5 $\times$ due to parallel sampling (8 samples), the latency is significantly reduced because the longest sequential path is truncated. The median cost is only 9 API calls (vs. full generation).
Overthinking Prevention: In "Thinking" mode models, early exit stops the model from generating tokens that overwrite the initially correct answer. This is the primary driver of accuracy gains.

5. Significance and Implications

Structural Insight: The paper challenges the assumption that CoT generation is a faithful reflection of the model's decision-making process. It reveals a "capability–elicitation misalignment" where models encode answers in latent states before their generation policies can externalize them.
Benchmarking & Safety: Standard evaluation protocols that rely on forced extraction (e.g., "What is the answer?") may systematically underestimate a model's true reasoning capabilities.
Efficiency: BAEE provides a deployable, black-box method to drastically reduce inference latency and cost (by avoiding "theater" generation) without sacrificing, and often improving, accuracy.
Generalizability: The phenomenon holds across math, science, and code generation, suggesting it is a fundamental property of current large reasoning models.

In summary, the paper demonstrates that models "know" the answer long before they "say" it, and that forcing them to speak early causes failure. By switching to a strategy that listens to the model's natural free continuations, we can exit early, save compute, and improve accuracy.