When a question is ambiguous, a language model usually guesses an interpretation early and then reasons confidently along it. If the guess was wrong, every later step builds on a false premise. This proposal borrows a forty-year-old idea from interactive machine translation. Tomita's system parsed an ambiguous sentence several ways, compared the parses, found where they disagreed, and asked the user a plain-language question about that one spot. We apply the same move to LLM reasoning. The model samples several reasoning chains, lines them up step by step, finds the first step where they split because of a different reading of the question rather than an arithmetic or retrieval slip, and asks the user a short question about that fork only. The user's answer selects a branch that has already been partly computed, and reasoning resumes from there.
This matters because the ambiguity that breaks multi-hop reasoning is often invisible at the start. Whether "Mustang" means a car or a guitar may only become a live question two hops in, after the model has retrieved something. Current systems either ask up front, before the fork exists, or never ask and explore every branch at high cost. The bet is that one well-placed question in the middle of the chain buys most of the accuracy of exhaustive exploration at a fraction of its latency. It should also avoid two known failures: asking about things that are not ambiguous, and giving the same answer regardless of what the user says.
Core Claim
Clarification works better when it is located at the reasoning step where interpretations actually diverge, and when that divergence is distinguished from ordinary computational error. Concretely, at a matched number of questions, a clarifier that asks at the first interpretive fork in a set of sampled chains will beat one that asks before reasoning starts on benchmarks with latent, mid-chain ambiguity. It will also ask less often on unambiguous inputs than a clarifier triggered by disagreement among final answers. Because each option in the question corresponds to a branch already computed, the user's choice changes the output by construction. This removes the "collapse" failure, in which the model returns the same answer whichever option the user picks.
What Prior Work Establishes and Leaves Open
The motivating evidence comes from three groups. The classical interactive translation systems showed that resolving ambiguity at an intermediate representation stops the explosion of wrong downstream hypotheses: Franz et al. did this at the interlingua stage, and ITS-2 found lexical transfer to be the main bottleneck needing user input. Tomita's Explanation List Comparison supplies the method we reuse. It compares candidate analyses, isolates the divergent attachment, and turns it into a non-expert question. We replace parse trees with sampled reasoning chains, and syntactic attachment with step-level interpretation.
On the reasoning side, MARCH and MIRAGE define latent ambiguity that arises at intermediate hops. They propose CLARION, which rewrites a query into every clarified reading and runs a separate agent loop for each. It is fully autonomous. It reaches 38.73% strict exact match on Qwen3-235B but costs 8.9 seconds per query against 0.6 for naive retrieval-augmented generation. InteractComp shows that search agents rarely ask on their own: accuracy is 13.73% on ambiguous queries versus up to 71.50% with disambiguating context. Forcing a question before answering takes GPT-5 from 20% to 40%. So asking helps, but the paper offers no rule for when to ask. Tool-use incomplete-condition work documents over-eager action and fixes it with a verification checklist. That checklist only abstains; it never asks.
Two papers constrain the design. CAMBIGNQ finds that 59% of users prefer a targeted clarification question to a list of all answers. It also finds that downstream models often ignore the chosen option, reaching only 40.5 F1 after clarification. Any design that merely appends the user's answer to the prompt inherits this collapse. Xiao et al. show that high-control editing interfaces raise perceived agency but damage task outcomes, with dyadic alignment falling from 0.57 to about 0.33. Interaction must therefore be a single light choice, not an editing task. That is why we ask one multiple-choice question rather than exposing the chain for editing, as the interactive verification interfaces of Zhou et al. do after reasoning ends.
The closest method is CLAIM. It uses semantic disagreement across sampled generations as an ambiguity signal and trains a model to ask information-gain-optimal questions, reaching 81.85% on ClariLM-test. CLAIM makes a single-turn decision on the input and measures disagreement over whole responses. We measure disagreement per reasoning step, ask mid-chain, and separately test whether a disagreement is interpretive. The reasoning-limitations literature explains why that separation is needed. ConsisEval shows that even strong models fail easy variants through distractors, off-by-one slips and arithmetic errors. Output-level disagreement will therefore often reflect computation noise, not ambiguity, and an output-level trigger will ask users about the model's own mistakes.
Research Program
The system has four parts.
Hop-structured sampling. The model is prompted to reason in explicit hops. Each hop names a sub-question and the entity or value it resolves to, in the spirit of the thought-step format of Cai et al.. We sample $k$ chains (default 8) and advance them together one hop at a time. We stop at the first fork that passes the tests below, so the chains are not run to completion.
Divergence detection. At each hop we cluster the resolved values across chains, using normalized entity match or an LLM equivalence judge. A fork is a hop where two or more clusters each hold a substantial share of the chains and stay distinct at the next hop.
Interpretive-versus-computational test. For each cluster at a fork, a checker asks two questions. Is this value a faithful reading of the original query plus the evidence retrieved so far? Does it survive execution or retrieval checks? Only if at least two clusters pass is the fork treated as interpretive, and only then is the user asked. If only one cluster passes, the fork is treated as an error, and we continue with the passing cluster, which amounts to a local self-consistency repair. This test is the key ingredient. It is what should keep the method quiet on unambiguous problems.
Tomita-style question and resume. Following Explanation List Comparison, the question names only the divergent element. Options come from the passing clusters, phrased in source-language terms and grounded in what was retrieved (for example, "I found a car and a guitar named Mustang; which do you mean?"), plus a "neither" option. The chosen option selects the existing chain prefix, and reasoning resumes from it.
A second fork may trigger a second question, with a cap of two. "Neither" falls back to CLARION-style expansion over the remaining readings.
The user is a simulated oracle, as in INTERCPT, which already shows that isolating the ambiguity beats stuffing the prompt with context. For each MARCH item we sample one gold interpretation as the user's intent. The oracle answers only from that intent and may say "I don't know" when options do not match. We score against that interpretation's gold answer. This single-intent adaptation of MARCH is our own and will be released. Because INTERCPT found interactive ability emerged mainly at 540B scale, we run two backbones: Qwen3-235B, to match reported MARCH numbers, and an 8B model, to test whether forks can be localized without that scale.
Baselines
The naive reference points are single-pass ReAct and NaiveRAG on the same backbone and retrieval corpus, without clarification. On MARCH with Qwen3-235B, MIRAGE reports an average score of 20.99% for ReAct and 25.65% for NaiveRAG. Self-consistency over the same $k$ chains with majority vote is a second naive point. It uses exactly our sampling budget but never asks, so it isolates what the question adds beyond sampling.
The strongest autonomous competitor is CLARION (MARCH). It reports 38.73% strict exact match, 28.38% Disambig-F1 and 33.56% average on Qwen3-235B, at 8.9 seconds per query. We rerun it on the same backbone, corpus and hardware. It is scored in two ways. Under its native multi-answer metrics, we check whether our single-intent answers still cover the benchmark's interpretations when the oracle intent is varied. Under our single-intent accuracy, CLARION must commit to one answer, and we let it use its own ranking. Beating CLARION means higher single-intent accuracy at no more than a third of its latency and generated tokens, with at most two questions per query.
The strongest interactive competitor is forced up-front asking, as in InteractComp. The model must ask one clarifying question before any reasoning, against the same oracle. On InteractComp we compare against its reported ambiguous-query accuracy of 13.73%, the 71.50% context-given ceiling, and the forced-ask jump from 20% to 40% for GPT-5. We also include a CLAIM-style trigger: ask when final answers across $k$ samples disagree semantically, with the question generated from the query. We run this as a training-free reimplementation, since the file gives no released CLAIM checkpoint, and state that caveat. Its reported 81.85% is on ClariLM-test, a single-turn task, so it is not directly comparable. We will evaluate on ClariLM-test only if that data is obtainable. All interactive baselines get the same question cap and the same oracle, and prompts are tuned with the same budget on a held-out split.
Two ablations isolate our ingredients. The first removes the interpretive-versus-computational test, asking at any fork. The second keeps fork localization but drops resume-from-branch: the answer is appended to the prompt and reasoning restarts. This directly measures how much of the gain comes from avoiding collapse.
Why not just…?
Why not just ask one question up front, as InteractComp's forced-ask condition does? This is the most serious threat. If MARCH's ambiguity is mostly visible in the query text, up-front asking will match us at lower cost. Our argument is that latent ambiguity by definition appears only after an intermediate hop. The up-front questioner then either guesses the wrong dimension to ask about or asks something the user cannot map to their intent. The decisive comparison uses exactly one question for both methods, broken down by the hop index where MARCH's gold ambiguity arises. If we do not win on items whose ambiguity arises at hop two or later, the step-localization claim is false, and we will report it that way.
Why not just trigger on disagreement among final answers, as CLAIM does? Final-answer disagreement mixes misreadings with miscalculations, and ConsisEval shows even frontier models make the latter on easy problems. We test this on a control set: unambiguous GSM8K and ConsisEval items, where any ask is a false ask. We also build an ambiguated GSM8K variant using the utterance-removal-and-substitution style of ICT to create genuinely two-reading problems. Our prediction is a much lower false-ask rate at equal recall on the ambiguated items. If the output-level trigger matches us on both, the interpretive test adds nothing.
Why not just explore every branch autonomously and never bother the user? CLARION already does this and still reaches only 38.73% strict exact match, at roughly fifteen times the latency of naive retrieval. When the user has one intent, exhaustive exploration spends most of its compute on branches nobody wanted. It also returns a multi-answer response, which most users in CAMBIGNQ disprefer. CLARION remains the right choice when no user is available, and our "neither" fallback reduces to it.
Why not just append the user's answer and regenerate? CAMBIGNQ's collapse result predicts that the model will often ignore the answer. The resume ablation measures this directly as the fraction of items where different oracle intents yield the same final output.
Proposed Experiments
The primary benchmark is MARCH with the single-intent oracle. The secondary is InteractComp, where the oracle is restricted to that benchmark's yes, no and I-don't-know responses for comparability. The control is the pair of GSM8K and ConsisEval sets described above. Metrics are single-intent accuracy, MARCH's native strict exact match and Disambig-F1, questions asked per item, false-ask rate on unambiguous items, collapse rate, latency and generated tokens.
Two checks are decisive. The first is the hop-stratified comparison against forced up-front asking at one question. The second is the false-ask comparison against the output-level trigger. A secondary check is whether fork localization works at 8B, which would show that step-level comparison removes the scale dependence INTERCPT observed.
A small human study, around 40 participants, addresses the cost concern raised by Xiao et al. Participants receive a written intent and answer questions from each system. We measure time per answer, whether their choice matches their intent, and perceived effort. Up-front questions are compared with fork-localized questions that show one line of retrieved context. The prediction is that grounded mid-chain questions are answered faster and more accurately because they name concrete alternatives. If they turn out to be slower or more confusing, the accuracy gains from simulation overstate real-world value, and we will report both.
References
- Coping With Ambiguity in a Large-Scale Machine Translation System
- ITS-2 : an interactive personal translation system
- Disambiguating Grammatically Ambiguous Sentences By Asking
- MARCH: Evaluating the Intersection of Ambiguity Interpretation and Multi-hop Inference
- MIRAGE: Multi-hop Reasoning with Ambiguity Evaluation for Illusory Questions
- InteractComp: Evaluating Search Agents With Ambiguous Queries
- Can Tool-augmented Large Language Models be Aware of Incomplete Conditions?
- Asking Clarification Questions to Handle Ambiguity in Open-Domain QA
- Sustaining Human Agency, Attending to Its Cost: An Investigation into Generative AI Design for Non-Native Speakers' Language Use
- Improving Human Verification of LLM Reasoning through Interactive Explanation Interfaces
- CLAIM: Leading Open-domain Active Clarification of Large Language Models with Uncertainty Measurement
- Can Large Language Models Always Solve Easy Problems if They Can Solve Harder Ones?
- Beyond Code: Evaluate Thought Steps for Complex Code Generation
- Interactive-Chain-Prompting: Ambiguity Resolution for Crosslingual Conditional Generation with Interaction