Language models that answer multi-hop questions ("In what city was the director of Inception born?") are increasingly trained on their own successful reasoning traces. Each trace is a chain of sub-questions, retrieved passages, and intermediate answers, and a trace is kept for training when its final answer is correct. That filter cannot tell two kinds of trace apart. In the first, the chain does the work: the model finds the bridge entity, Christopher Nolan, then finds his birthplace, then answers. In the second, the model reaches "London" from what it memorized during pre-training, and the chain is decoration that happens to agree. Both pass. The second kind teaches the model that its chain is optional, which is the shortcut multi-hop retrieval was built to remove.
We propose to measure, for every candidate training chain, whether the final answer causally depends on it, and to keep only chains that pass. The test comes from front-door causal adjustment, a way of estimating causal effects through an observed intermediate step when a hidden confounder links input and output. Front-door adjustment is valid only if that intermediate step carries the entire effect of the input on the output. We turn this requirement into an operational check. We edit the bridge entity inside a chain to a coherent alternative, for example replacing Nolan with Denis Villeneuve and his birthplace with Trois-Rivières. Then we ask whether the answer step follows the edited chain or keeps returning the memorized answer. Producing these edits correctly is the part machines get wrong, so humans enter the loop as narrow, fast verifiers of edit consistency rather than as general reviewers of fluency.
Core Claim
Correct-answer filtering of synthetic reasoning chains admits many chains whose answers do not depend on them. Replacing that filter with a human-verified test of mediation will produce multi-hop models that stay accurate when retrieved evidence contradicts memorized knowledge. Here, mediation means that the answer depends on the input only through the chain. On standard benchmarks the new filter should cost little or no accuracy. The claim is falsifiable on three points. The rate at which chains fail the mediation test must be substantial among chains that pass correctness filtering. Training on mediation-filtered chains must beat training on an equal number of correctness-filtered chains on counterfactual test sets. Human verification of the edits must matter relative to unverified automatic edits.
Where This Sits
The front-door literature in language models supplies the causal lens and the closest prior work. Causal Walk treats an explicit multi-hop reasoning path over an evidence graph as the mediator between claim-evidence input and veracity label. It estimates the adjusted prediction with a random walk and a weighted geometric-mean approximation. DeCoT treats a chain of thought as the mediator, with pre-training knowledge as the confounder. At inference time it selects the sampled chains with the highest average causal effect under counterfactual context perturbations. CFD-Prompting relaxes the front-door assumptions by conditioning on external knowledge. It builds counterfactual contexts by swapping key entities and compares reasoning paths with a contrastive encoder, without needing model probabilities. All three use the front-door idea at inference time, on a fixed model, to choose or reweight outputs. They assume the mediation structure holds and estimate around it.
We do the opposite. We test whether mediation holds for each training example, and we use the result to shape what the model learns. This also responds to the latency cost that the file notes for DeCoT-style inference, since the causal computation is paid once at data-construction time rather than at every query.
The testability result constrains the design. Bhattacharya and Nabi show that the front-door assumptions cannot be checked from observational data alone. Checking them requires an auxiliary anchor variable, which brings out Verma constraints, independencies that become visible only after a simulated intervention. In our setting we do not need to rely on observational tests. We can intervene directly on the mediator, because we can write any chain we like and feed it to the answer step. The cost moves elsewhere: the intervention must describe a coherent alternative world, or the "correct" counterfactual answer is undefined. That is where human verification earns its place.
The multi-hop work supplies the generator and the main competitor. IRCoT interleaves single chain-of-thought sentences with retrieval. CoRAG builds training data by rejection sampling retrieval chains of sub-queries and sub-answers that reach the correct final answer. It then fine-tunes Llama-3.1-8B-Instruct to produce such chains. GRAT runs tree search with process rewards and self-trains on successful paths. CoRAG and GRAT both select training chains by outcome or by learned step scores. Neither asks whether the final answer would change if the chain changed. Our filter is a drop-in replacement for CoRAG's acceptance criterion.
The human-in-the-loop literature supplies the labor model. Author-reviewer pipelines report large efficiency gains when humans filter model drafts instead of writing from scratch. One example is the roughly 13-fold gain reported in role-specified dialogue construction. Template-grounded pipelines such as ToolQA execute ground truth programmatically for precision. These papers motivate the design. The file's noted failure mode is that tired reviewers miss fluent but wrong reasoning, which tells us to make the human question narrow and checkable rather than open-ended.
Research Program
Notation and score. We write $X$ for the question together with its retrieved passages, $M$ for the chain of sub-queries and sub-answers, and $Y$ for the final answer.
For a candidate chain $m$ with answer $y$, a counterfactual edit $m'$ replaces the bridge entity and recomputes every downstream hop consistently. This yields a new expected answer $y'$. We define the mediation score as follows, where $f(\cdot \mid x, m)$ is the answer step's probability given the question and a chain:
$$s(m) = \tfrac{1}{2}\big[f(y' \mid x, m') + f(y \mid x, m)\big] - \tfrac{1}{2}\big[f(y \mid x, m') + f(y' \mid x, m)\big]$$
A score near one means the answer tracks the chain. A score near zero, or a high $f(y \mid x, m')$, means the answer bypasses the chain. Bypassing is a direct path from $X$ to $Y$, or memorized knowledge acting as the confounder.
A second probe estimates the inner sum of the front-door formula, which averages the effect of a chain over other inputs $x'$. We pair the same chain with unrelated questions $x'$ and check that the answer does not drift.
Edit generation and the human role. A language model proposes bridge-entity substitutions and rewrites the downstream sub-answers. Annotators then answer one question per edit: "Is this edited chain internally consistent, and is $y'$ what it implies?" The task is a binary judgment with an optional one-field correction, designed to take seconds.
We will spend a fixed budget of human verifications on a stratified sample. With those labels we will train and calibrate a lightweight edit validator. The validator then extends verification to the full candidate pool, and humans re-check the cases it is least confident about. We will report human time per edit and agreement between annotators.
Analyses. First, we measure the mediation-failure rate among chains that pass correctness filtering, broken down by hop count and by whether the gold answer is likely memorized. One proxy for memorization is closed-book correctness of the base model.
Second, we train the same student model under different filters and compare the results, using the baselines described below.
Third, we build a human-verified counterfactual test set. Its documents are edited so that the memorized answer is wrong and only the retrieved chain gives the right answer. This is the regime where the multi-hop gap and the confounding story meet.
Baselines
The naive reference point is the base instruction-tuned model, Llama-3.1-8B-Instruct as in CoRAG, run with IRCoT-style interleaved prompting and no fine-tuning. It shows how much any chain training helps.
The strongest existing method is CoRAG-style training. Following CoRAG, we rejection-sample chains and keep those that reach the correct answer. It is the most direct competitor because it uses the same generator, the same student, and the same chain format, and differs only in the acceptance rule. We will run it on the same seed questions and retriever, and give it the same fine-tuning steps and hyperparameter search. We will match the number of accepted training chains, oversampling CoRAG's pool so that dataset size is not the difference.
The research file reports no CoRAG numbers on the benchmarks we will use, so we will reproduce CoRAG ourselves. Beating it means two things. On the counterfactual test set, the mediation-filtered model must show a statistically significant gain in exact match across three seeds. On standard dev sets, it must stay within one point of CoRAG.
A second strong competitor is inference-time front-door selection: DeCoT-style counterfactual chain ranking (DeCoT) applied to the CoRAG-trained model at matched test-time sampling budget. Beating it at a fraction of its inference cost, or matching it at no inference cost, counts as success.
We will also include a process-reward filter in the spirit of GRAT. A learned scorer rates each step, and the highest-scoring chains are kept, again matched in count.
Three ablations isolate the ingredients. A random subset of correctness-filtered chains, equal in size to the mediation-filtered set, separates the effect of the causal test from the effect of discarding data. Mediation filtering with unverified automatic edits separates the human contribution. Mediation filtering without the input-swap probe separates the front-door inner-sum check.
Why not just…?
Why not just keep CoRAG's correctness filter and sample more chains? More samples raise coverage but do not change what the filter rewards. A chain that reaches the right answer from memory passes no matter how many siblings are drawn. The matched-size comparison on the counterfactual test set settles this directly. If correctness-filtered chains do as well there, our mediation-failure measurements were measuring something harmless, and the proposal fails.
Why not just use automatic entity swaps, as CFD-Prompting does, and skip humans? This is the real threat. CFD-Prompting already swaps entities automatically for inference-time debiasing. Multi-hop edits are harder, though, because every downstream hop must change consistently: the new director's actual birthplace, not a random city. An inconsistent edit corrupts the target $y'$ and therefore the score. The unverified-edit ablation tests whether this matters. If automatic edits checked by an LLM judge agree with human verdicts and train equally good models, we will report that the human role reduces to a small calibration set. That would still be a useful finding about cost.
Why not just apply DeCoT or Causal Walk at inference time? Those methods assume mediation and pay for counterfactual sampling on every query. As the file notes for DeCoT, latency grows with the number of paths and perturbations. They also cannot repair a model whose answer step has learned to ignore its chain. The matched-budget comparison will show whether training-time filtering captures most of the benefit for free. Combining the two is also reported.
Why not just train a process reward model? Step-level scorers judge whether each step looks right. They do not judge whether the answer depends on it. A fluent, correct chain attached to a memorized answer scores well. The GRAT-style filter baseline tests whether this distinction shows up in counterfactual accuracy.
Proposed Experiments and Decisive Checks
We will use the standard multi-hop question-answering benchmarks MuSiQue, 2WikiMultihopQA, and HotpotQA for seed questions and standard evaluation. Metrics are exact match and F1. The research file contains no reported results on these benchmarks for any cited method, so all baseline numbers will come from our reproductions under identical settings.
The counterfactual test set will be built through the same human-verified edit pipeline, applied to held-out questions and their documents. It is the primary endpoint. Secondary metrics are the mediation-failure rate of each trained model on held-out chains and the human seconds spent per verified edit.
The first decisive check is descriptive. If fewer than about one in ten correctness-filtered chains fail the mediation test, the problem is too small to matter, and we stop.
The second check is the matched-size comparison against CoRAG and against the random-subset ablation on the counterfactual set. A gain that disappears against the random subset means we merely removed easy data.
The third check is the human-versus-automatic edit ablation, which decides whether the human-in-the-loop component is necessary or only a calibration aid.
Finally, we will test whether mediation scores computed with the base model predict which chains help the student. If they do not, the filter is measuring a property of the generator rather than of the data, and the method needs rethinking before it scales.
References
- Causal Walk: Debiasing Multi-Hop Fact Verification with Front-Door Adjustment
- DeCoT: Debiasing Chain-of-Thought for Knowledge-Intensive Tasks in Large Language Models via Causal Intervention
- Unbiased Reasoning for Knowledge-Intensive Tasks in Large Language Models via Conditional Front-Door Adjustment
- On testability of the front-door model via Verma constraints
- Interleaving Retrieval with Chain-of-Thought Reasoning for Knowledge-Intensive Multi-Step Questions
- Chain-of-Retrieval Augmented Generation
- GRAT: Guiding Retrieval-Augmented Reasoning through Process Rewards Tree Search
- Building a Role Specified Open-Domain Dialogue System Leveraging Large-Scale Language Models
- ToolQA: A Dataset for LLM Question Answering with External Tools