When a language model reasons step by step, writing out intermediate steps before answering (chain-of-thought prompting), its uncertainty rises and falls along the way. Two literatures read that uncertainty in opposite ways. Hallucination work treats high predictive entropy as a warning. Predictive entropy is how spread out the model's next-token probabilities are, and hallucination work reads a spread-out distribution as a sign the model is about to make something up. Reasoning work treats high-entropy steps as the ones doing real computation, the steps that must be kept. We propose to separate these two kinds of uncertainty inside a single reasoning chain. The first is uncertainty about which fact is true, for example who directed a film, which retrieving a document can fix. The second is uncertainty about what to do next, for example which sub-question to try or how to combine two numbers, which no document will fix. The model should search the web or a corpus only for the first kind. This is retrieval-augmented generation (RAG), where the model reads retrieved passages before answering, applied mid-chain and only where a search helps.
The practical stakes are concrete. Retrieving at every reasoning step, as Chain-of-Retrieval Augmented Generation (CoRAG) does after fine-tuning, raises multi-hop recall but pays for searches on facts the model already knows. Triggering retrieval on raw entropy fires on hard logic as readily as on missing facts. A trigger that fires on the wrong kind of uncertainty wastes compute and can inject distractor passages, which are known to cause hallucinated reconciliations. A trigger that misses a fabricated bridge entity, the intermediate fact linking two hops, corrupts every later hop.
Core Claim
We claim that uncertainty concentrated on the content slots of a reasoning step predicts whether retrieval will help that step much better than step-level entropy does. Content slots are the entity names, dates and numbers the step asserts. Step-level entropy is the average over all tokens. We measure slot uncertainty semantically, so that synonyms do not count as disagreement. A training-free trigger built on this signal should match always-retrieve accuracy on multi-hop QA with far fewer searches. It should also almost never fire on self-contained arithmetic, where step-entropy triggers fire constantly.
For each step $s$ we define slot semantic entropy as $H_{\text{slot}}(s) = -\sum_{c} p(c)\log p(c)$. Here $c$ ranges over meaning-clusters of $k$ short sampled completions of each content slot, grouped by normalized string match and a lightweight entailment check, and $p(c)$ is the fraction of samples in cluster $c$. The step retrieves if $H_{\text{slot}}(s)$ exceeds a threshold calibrated per model on a small held-out set. When it does, the search query is the step text with the uncertain slot masked, so the retriever is asked the question the model is actually unsure about. The retrieved passage is then used to regenerate that step before it enters the context.
Relation to Prior Work
The gap is motivated by two opposing findings. Compressing Chain-of-Thought in LLMs via Step Entropy shows that on math, low-entropy steps are redundant and can be skipped, while high-entropy steps carry the computation. Its arithmetic setting has no knowledge gaps at all. Tianyu Liu et al. and Meng Cao et al. show that entropy and low entity probability flag factual errors. Both work on free text, not reasoning chains. Neither line asks which of the two meanings a given entropy spike carries. Our slot-versus-step decomposition is the proposed answer.
The method borrows from three sources. GOLFer weights token entropy by attention to isolate semantically risky tokens, and it applies this only to pre-retrieval hypothetical documents. We move the localization idea into the generator's own reasoning steps. The file's note on semantic invariance, that Shannon entropy counts synonyms as disagreement, motivates clustering slot samples by meaning.
The closest competitors decide when to retrieve with trained components. DioR uses integrated-gradients attribution entropy fed to an RNN plus a token-level MLP. RaDIO uses an MLP trained on synthetic perturbations. Both operate on sentence-by-sentence generation rather than explicit reasoning chains, and both need extra training and gradient computation. We use no trained detector. Entropy-based Exploration Conduction and Unveiling the Entropy Dynamics of Chain-of-Thought Reasoning steer closed-book reasoning with entropy, through branching, pruning, early exit and change-point detection. Neither can fetch a missing fact. RCOT detects hallucinated conditions by reconstructing the problem, which takes several extra passes and gives no corpus access.
One finding constrains the proposal and we do not claim to solve it. Models are often confidently wrong (Liyan Tang et al.), and our signal cannot see a fabricated bridge entity asserted with low entropy. We measure how often this happens rather than hide it.
Research Program
The first stage is diagnostic and produces the labeled data the claim depends on. On HotpotQA, 2WikiMultihopQA and MuSiQue, which ship gold supporting paragraphs, we generate chain-of-thought traces with open-weight instruction-tuned models, Llama-3.1-8B plus one larger model. We then label each step retrieval-resolvable if re-generating it with the gold supporting paragraph in context changes its content slot to the correct value, or collapses its slot distribution. This counterfactual label defines "a step where search helps" without human annotation.
We then score candidate signals by how well they predict the label, using area under the ROC curve. The signals are step entropy as in the Step Entropy paper, raw minimum token probability, attention-weighted token entropy in the style of GOLFer, token-level slot entropy, and slot semantic entropy. We run the same analysis on GSM8K traces, where no step should be retrieval-resolvable. This directly measures how often each signal would fire uselessly.
The second stage builds the trigger. It is a slot tagger using a small named-entity/number tagger over the generated step, a $k$-sample slot resampler with $k$ around 5 because slots are a few tokens long, a masked-slot query, and step regeneration. We run it over BM25 on the Wikipedia dumps used by DioR and RaDIO, then report accuracy against searches per question.
Baselines
The naive reference points are closed-book chain-of-thought and static retrieve-then-reason. Static retrieve-then-reason means top-$k$ BM25 passages for the question, then chain-of-thought, as in Retrieval-Augmented Chain-of-Thought in Semi-structured Domains. These bound how much any mid-chain retrieval adds. MultiHop-RAG reports that GPT-4 falls from 0.89 accuracy with gold chunks to 0.56 with retrieved chunks, so static retrieval leaves a large gap to close.
The strongest accuracy competitor is always-retrieve iterative reasoning: a search at every step with the same prompt-based loop, model and retriever. This is the prompt-only analogue of CoRAG. CoRAG itself reports over 10 exact-match points above baselines and a MuSiQue recall rise from 29.0% to 47.1%, but it uses a fine-tuned 8B model. We therefore report its published figures for context and treat the untuned always-retrieve loop as the fair comparison. Beating this baseline means matching its exact match within noise, measured by bootstrap intervals over questions, while issuing at least 40% fewer searches.
The strongest published trigger is DioR. On 2WikiMultihopQA it reports exact match 0.266 and F1 0.335. On IIRC it reports exact match 0.201 against SEAKR's 0.195, and it cuts hallucination counts from 3.696 to 2.010. RaDIO reports 0.254 exact match with an SBERT retriever on 2WikiMultihopQA. Because backbones differ, we re-run DioR's and RaDIO's released or re-implemented triggers on our backbone and retriever where possible, and quote the published numbers only as anchors. Beating DioR means equal or higher exact match on 2WikiMultihopQA and IIRC with no trained detector and fewer searches.
The ablation that isolates our key ingredient is the identical pipeline with the trigger swapped for step-average entropy, then for token-level (non-semantic) slot entropy. Each variant has its threshold tuned on the same held-out split with the same search budget. All methods share data, retriever, backbone and a fixed grid of 10 threshold values on 200 held-out questions.
Why not just…?
Why not just retrieve at every step? This is the most serious threat. If searches are cheap and distractors rarely hurt, always-retrieve may simply win on accuracy. Our claim is therefore about the accuracy-per-search frontier, not raw accuracy. We will report full curves. We will also measure whether unnecessary retrievals on steps labeled non-resolvable ever lower accuracy through distraction. If they never do and accuracy parity requires near-constant triggering, the selective trigger has no case beyond cost, and we will say so.
Why not just threshold step entropy or token probability? That is the ablation above, and it is the test that could kill the idea. The Step Entropy paper implies high step entropy marks necessary computation, so this trigger should fire often on GSM8K. Liu et al. report that hallucinated tokens can carry high probability, which undermines probability thresholds. If step entropy predicts resolvability as well as slot semantic entropy in stage one, the slot decomposition is unnecessary and we would drop it.
Why not just ask the model whether it needs to search? Self-assessment prompts are cheap and black-box. RCOT finds generic double-check prompting unreliable at spotting fabricated conditions, but that evidence comes from math, not retrieval decisions. We include a "do you need to look this up?" per-step prompt as a baseline scored on the same resolvability labels.
Why not just sample many chains and vote? Voting cannot supply a bridge entity absent from the weights. We run self-consistency at matched total token budget, and expect it to help on StrategyQA and fail on MuSiQue. The file reports no MuSiQue self-consistency number, so this is a prediction to test.
Decisive Checks
Three results decide the proposal. First, on the counterfactual resolvability labels, slot semantic entropy must beat step entropy in AUROC on MuSiQue and 2WikiMultihopQA by a clear margin, with non-overlapping bootstrap intervals. Second, on GSM8K it must trigger on a small fraction of steps while step entropy triggers substantially more. Entro-duction's 85.4% on GSM8K with Llama-3.1-8B is the closed-book accuracy we should not degrade. Third, end to end, the trigger must sit on or above the always-retrieve accuracy-per-search curve on HotpotQA, 2WikiMultihopQA, MuSiQue and IIRC. For HotpotQA we found no reported result on Lacuna for DioR, RaDIO or Q-PRM exact match, so we generate all HotpotQA numbers ourselves.
We also report the confidently-wrong residual: the share of final errors traced to a low-slot-entropy fabricated bridge entity. This number bounds what any entropy-only trigger can do and tells the field whether overconfidence, not trigger timing, is the next bottleneck.
References
- Chain-of-Retrieval Augmented Generation
- Making Slow Thinking Faster: Compressing LLM Chain-of-Thought via Step Entropy
- A Token-level Reference-free Hallucination Detection Benchmark for Free-form Text Generation
- Hallucinated but Factual! Inspecting the Factuality of Hallucinations in Abstractive Summarization
- GOLFer: Smaller LMs-Generated Documents Hallucination Filter & Combiner for Query Expansion in Information Retrieval
- DioR: Adaptive Cognitive Detection and Contextual Retrieval Optimization for Dynamic Retrieval-Augmented Generation
- RaDIO: Real-Time Hallucination Detection with Contextual Index Optimized Query Formulation for Dynamic Retrieval Augmented Generation
- Entropy-based Exploration Conduction for Multi-step Reasoning
- Unveiling the Entropy Dynamics of Chain-of-Thought Reasoning
- RCOT: Detecting and Rectifying Factual Inconsistency in Reasoning by Reversing Chain-of-Thought
- Evaluating large language models on medical evidence summarization
- Retrieval-Augmented Chain-of-Thought in Semi-structured Domains
- MultiHop-RAG: Benchmarking Retrieval-Augmented Generation for Multi-Hop Queries