Multi-hop question answering systems answer a question by retrieving documents, writing a follow-up search query from what they just read, retrieving again, and so on. Each hop trusts the previous hop's output. This note argues that this chaining makes the strongest current poisoning defenses unsound against an attacker who plans ahead. The best of these defenses, RAGSentinel, filters each retrieved set by geometric consensus. It is certified only while fewer than half of the retrieved documents are poisoned. An attacker who controls a small minority of first-hop documents can write them so that the follow-up query lands where the attacker controls most of the results. A filter that is sound at every individual hop can therefore fail on the pipeline as a whole. This is the classic cascading-error problem of pipelines, where an upstream mistake is treated as ground truth downstream, now driven deliberately by an optimizing adversary.
We propose to build this attack, which we call query steering, and to measure how far it pushes the poisoned fraction past one half at later hops. We then test a defense that restores a pipeline-level guarantee. The defense splits the first-hop evidence into disjoint groups. It runs a separate reasoning path from each group, so that every downstream query is computed from evidence the attacker either fully owns or never touched, and it votes over the final answers. The bet is a specific one. Per-hop filtering fails because later queries depend on attacker content. Breaking that dependency for most paths, at the cost of running several paths, buys back an honest majority at the level of answers.
Core Claim
Honest-majority defenses assume that the attacker's share of the retrieved set is fixed by how many documents the attacker managed to insert into the corpus. In a multi-hop pipeline that assumption fails, because the hop-two query is itself a function of hop-one content. Prior work supplies the ingredients for exploiting this. Stepwise Reasoning Error Disruption Attack of LLMs (SEED) showed that models follow a planted, plausible intermediate step instead of their own knowledge, a behavior it calls the "Consistency Trap," and that such plants evade GPT-4o judges more than 80% of the time. SEED studied only single-model chain-of-thought. We carry its insight across a module boundary. The planted step here is a retrieved passage, and what it corrupts is the next search query rather than the next sentence of reasoning.
The second half of the claim is constructive. Suppose the hop-one top-$k$ documents are split into $m$ disjoint groups, at most $t$ of the $k$ documents are poisoned, and $f$ denotes the number of clean-start paths that are still corrupted at a later hop by ordinary corpus poisoning. Ordinary poisoning here means poison aimed at queries the attacker did not steer, which is exactly the case where per-hop filtering retains its honest-majority certificate. Then the vote over paths is correct whenever
$$t + f < m/2,$$
because each poisoned document contaminates at most one group and therefore at most one path. This is a randomized-partition argument familiar from certified robustness, applied at the level of reasoning paths rather than documents. Whether it pays off depends on whether $f$ stays small and whether answer accuracy survives on fewer documents per path. Both are empirical questions.
Research Program
The work has three parts.
Measuring the cascade. We instrument a standard two- and three-hop retrieval pipeline on HotpotQA and HoVer and record the poisoned fraction of the retrieved set at each hop. We do this under the existing attacks RAGSentinel evaluated (PoisonedRAG, PIA, Adversarial Decoding) and under query steering. A query-steering attack inserts a few hop-one passages whose content is optimized to make the pipeline's query writer emit a target hop-two query. It also inserts a cluster of hop-two passages that dominate retrieval for that target query.
The optimization uses black-box query feedback in the style of Greedy Coordinate Query from Query-Based Adversarial Prompt Generation. A white-box variant additionally knows the frozen surrogate encoder RAGSentinel uses (BGE-M3) and penalizes displacement from the geometric median. RAGSentinel explicitly assumes this access away. Building the attack adaptively matters because Optimizing Adaptive Attacks against Content Watermarks for Language Models showed that evaluating against fixed perturbations badly underestimates risk.
The path-partition defense. The defense keeps several hypotheses alive instead of committing to one hop-one reading, which is the "soft evidence" lesson of Bidirectional Integration of Pipeline Models and Claim-Dissector. Unlike those methods, it keeps the alternatives in disjoint, independently executed paths. This makes the attacker's influence countable rather than merely diluted. The approach is close in spirit to KEMLP, which gains robustness from consensus among partially independent components. KEMLP needed hand-written rules and was never attacked through its inference graph; we need neither rules nor an unattacked inference step.
Each path applies RAGSentinel filtering at later hops. We study three things: how to choose $m$ against the loss of evidence per path, whether to group hop-one documents by retrieval rank or at random, and whether later hops on different paths should share retrieval results, which saves compute but couples the paths.
Adaptive evaluation of the defense. We then attack the defense itself with full knowledge of the partition rule, the surrogate encoder, and the vote. The adaptive attacker tries three things: spreading poison across groups, writing hop-two poison that wins even under clean queries (raising $f$), and inflating $t$ by flooding hop one. We report how attack success scales with the attacker's document budget, not a single operating point.
Baselines
Undefended pipeline. The naive reference is a vanilla multi-hop retrieval pipeline over the same corpus, retriever, and generator (Llama-3.1, Mistral, and Qwen-2.5, following RAGSentinel). It sets the attack success ceiling and the clean-accuracy ceiling.
RAGSentinel at every hop. This is the strongest existing competitor. It is the only defense in the file with a certificate, and applying it at every hop is the natural answer to "just defend each hop." We run it with its published surrogate encoder and adaptive radius, tuned on the same held-out split and with the same number of tuning trials as our method. The reference number is the paper's own single-hop result: attack success rate (ASR) of 0.03 on Natural Questions with Llama-3.1, against 0.38 for vanilla retrieval-augmented generation and 0.06 for the next-best baseline. No reported HotpotQA or HoVer number for RAGSentinel was found on Lacuna, so we will reproduce it on those datasets ourselves. Beating it means a statistically clear reduction in ASR under query steering at equal attacker document budget. The reduction must come with clean exact-match within two points of the RAGSentinel-per-hop pipeline. We will also report results at matched generator-call budget, since our method spends $m$ times more calls.
Prompted self-review. The generator is asked to check its intermediate evidence and reasoning before answering. SEED reports this gives "only modest protection," so it serves as the cheap-defense floor.
Ablations. Two ablations isolate the key ingredient. The first keeps $m$ paths but samples hop-one documents with overlap rather than disjoint groups. This removes the counting argument while preserving ensembling, and it separates "independence" from "more samples." The second keeps disjoint groups but feeds all paths the same hop-two query, computed from the full hop-one set. This tests whether decoupling the query, not just the evidence, is what matters.
Why not just…?
Why not just apply RAGSentinel at every hop? This is the hypothesis we are testing, not a strawman. Our prediction is that it fails because the attacker chooses the hop-two query, so the hop-two retrieved set can be majority-poisoned while every individual filter behaves as designed. RAGSentinel itself flags multi-step pipelines and surrogate access as uncovered. If per-hop poisoned fractions stay below one half under our strongest query-steering attack, the core claim is wrong, and we will report it as such.
Why not just retrieve more documents per hop? A larger $k$ raises the number of honest documents an attacker must outnumber. But a steered query can target a niche region of the corpus where few honest documents exist. In that case growing $k$ mostly pulls in irrelevant documents that do not vote coherently against the poison. We will sweep $k$ under query steering. If ASR falls to RAGSentinel's single-hop levels at a $k$ cheaper than $m$ paths, that simpler fix wins, and the proposal reduces to an attack paper.
Why not just write all sub-queries from the original question, never from retrieved text? This removes the cascade by construction. It is the decoupling idea that UCS-SQL applies to text-to-SQL, and it is a real threat to our proposal. Its cost is that bridge entities in multi-hop questions are often unknowable without reading hop one, so accuracy should drop on bridge-type HotpotQA questions and multi-hop HoVer claims. We will run it as a full baseline. If its clean accuracy stays close to the conditional pipeline, decomposing up front dominates our method and we will say so.
Why not just adversarially train the generator or query writer? AdROD notes that adversarial training and purification overfit to the attacks seen in training and fail against adaptive ones. MART-style iterative red-teaming is more promising but was shown only on single-turn prompts. We will run one MART-style round of fine-tuning the query writer on steering examples as a secondary baseline. We expect it to fail against an attacker re-optimized after training.
Proposed Experiments and Decisive Checks
All experiments use HotpotQA and HoVer as multi-hop testbeds and Natural Questions as a single-hop control, where query steering should provide no advantage. Corpora, retrievers, and the three generator families are held fixed across methods. We evaluate on 1,000 questions per dataset, with attacker document budgets from 1 to 10 passages per target question. The metrics are ASR (the attacker's target answer is produced), clean exact-match and F1 or verification accuracy, the poisoned fraction at each hop, the fraction of questions where the path-vote condition above is certifiably met, and generator calls per question.
The first decisive check is mechanistic. Under query steering with a hop-one poisoned fraction below one half, does the hop-two fraction exceed one half on a substantial share of targeted questions? Does ASR against RAGSentinel-per-hop then rise far above its single-hop 0.03 regime? If not, the project stops at a negative result about the threat.
The second check measures the defense: does path partitioning hold ASR down under the fully adaptive attacker while keeping clean accuracy near the per-hop baseline? It must also beat both ablations. Beating overlapping sampling shows that disjointness matters. Beating the shared hop-two query shows that decoupling the query is the operative ingredient.
The third check is against the up-front decomposition baseline on bridge questions. It decides whether keeping conditional queries is worth defending at all.
References
- RAGSentinel: Certifiable Geometric Consensus for Robust Retrieval-Augmented Generation
- Stepwise Reasoning Error Disruption Attack of LLMs
- Query-Based Adversarial Prompt Generation
- Optimizing Adaptive Attacks against Content Watermarks for Language Models
- Bidirectional Integration of Pipeline Models
- Claim-Dissector: An Interpretable Fact-Checking System with Joint Re-ranking and Veracity Prediction
- Knowledge Enhanced Machine Learning Pipeline against Diverse Adversarial Attacks
- UCS-SQL: Uniting Content and Structure for Enhanced Semantic Bridging In Text-to-SQL
- AdROD: HyperNetwork-based Adversarially Robust Object Detection for Autonomous Driving
- MART: Improving LLM Safety with Multi-round Automatic Red-Teaming