Answering "In what city was the director of Inception born?" with a search engine takes two lookups. The first finds the film. The second finds the director's biography. Everything depends on what the system carries from the first lookup into the second. Current multi-hop retrieval systems carry one of three things. Some carry only a name ("Christopher Nolan"). Some carry a whole block of reasoning text or the retrieved passage itself. Some carry an opaque vector read out of the language model's middle layers. We propose carrying a short, typed attribute profile of the bridge entity instead, for example "Christopher Nolan: person; film director; British-American; active 1998–present; directed Inception (2010)". That profile is used both as the next search query and as a checklist for rejecting a wrong second-hop document before it poisons the answer.
The idea comes from an adjacent field. Vision-language work on fine-grained recognition found that category names are too "thin" to anchor rich visual features. Pulling features toward descriptive attributes such as "pointed ears" or "silky white coat" is what closed the gap, as shown in Finedefics. We claim the same holds for the hand-off between retrieval hops. A bare entity name is a thin anchor. It fails when names are ambiguous, when the target passage refers to the entity by description rather than by name, or when a same-named distractor ranks higher. A small set of explicit attributes filters that noise without the dilution caused by forwarding a whole passage. The contribution is a head-to-head study of hand-off representations at a fixed token budget, plus a consistency check between the profile and each retrieved document. The study targets the specific slices where names are known to break.
Core Claim
In multi-hop retrieval-augmented generation (RAG, where a language model answers using passages fetched from a corpus), second-hop failures cluster in two places. One is vague references: ChainRAG reports second-hop recall dropping by up to 18% when sub-questions contain phrases like "this author". The other is distractors that derail every later hop. ChainRAG's retrieve-answer-rewrite loop fixes the first problem by substituting the resolved name back into the query, and it leaves the second untouched.
Our claim has two parts. On questions whose bridge entity is ambiguous, rare, or described rather than named in the target passage, an attribute profile beats name substitution on second-hop recall. It also beats forwarding the full first-hop passage when both are held to the same query length. Separately, checking a retrieved passage's consistency against the profile catches a large share of distractor-induced errors at the cost of one short verification call. On easy questions with unambiguous names we expect parity with name substitution. The claim is about where names break, not a uniform lift.
Relation to Prior Work
Several papers motivate this proposal by locating the gap. ChainRAG documents the second-hop "lost-in-retrieval" drop. Failure Modes in Multi-Hop QA shows that multi-hop accuracy collapses to the level of the least visible evidence piece, with drops of up to 14.7% for Ministral-8B when evidence moves position. That tells us recognizing the bridge evidence, not merely fetching it, is a bottleneck. MultiHop-RAG shows that even strong dense retrieval with reranking reaches only 0.7467 Hits@10.
Four systems are the closest existing hand-off designs, and each sits at a different point on the spectrum we study. L-RAG maps middle-layer hidden states straight into a dense retriever's embedding space. It is fast, but the hand-off is uninspectable and limited to two hops. AnchorCoT predicts discrete bridge entities ("anchors") and forces the reasoning chain through them, but it assumes the supporting context is already in the prompt and does no retrieval. IRCoT and Iter-RetGen forward free-form reasoning text or generated content as the next query. That is rich, but diluted and slow. RSF-GLLM routes over knowledge-graph structure precisely because intermediate entities lack surface overlap with the question, but it needs a curated graph. Our attribute profile is a discrete, inspectable, bounded-length hand-off that works over raw text corpora, which none of these four provides.
Other work supplies the method. The attribute-bottleneck literature supplies the template of decomposing a hard mapping through an explicit attribute layer: Finedefics, Mucko's concept layer, and Wu et al.'s attributes-as-knowledge-base-queries. Finedefics' hard-negative mining is the recipe for our optional retriever adapter.
That same literature also constrains the design. It warns that discrete attributes are lossy and that extraction errors cascade. We therefore keep the resolved name inside the profile rather than replacing it, and we measure extraction error directly. Q-DREAM warns that textual similarity diverges from usefulness, which is why the profile must be tested against, not assumed to beat, a well-optimized query.
Research Program
The pipeline has three parts. At each hop after the first, a small language model reads the question and the passage retrieved for the previous hop. It emits a profile in a fixed schema: resolved name, coarse type, two to four distinguishing attributes, and the relation that links the entity to the previous hop. The profile is capped at a token budget (we sweep 16, 32, and 64 tokens).
The profile, rendered as text, is the query to an unchanged dense retriever such as Contriever. In a second variant, a lightweight adapter is trained with profile-conditioned hard negatives. These are same-name or same-type passages about different entities, mined as Finedefics mines visually similar categories.
Each top-ranked candidate passage is then checked for consistency against the profile. The check asks whether the passage contradicts any attribute and whether it matches the entity's type. On a contradiction, the system falls back to the next candidate. Hops continue until the question's relation chain is exhausted, so the method extends beyond two hops, unlike L-RAG.
The analysis side matters as much as the method. We will label every second-hop failure as one of three causes: extraction error (the profile was wrong), retrieval error (the profile was right but the passage was missed), or recognition error (the passage was retrieved but not used, in the sense of the Weakest Link paper). This separates the attribute bottleneck's cost from its benefit.
Baselines
The naive reference point is one-shot RAG: embed the original question, retrieve the top-k passages, and answer. This is the NaiveRAG baseline that ChainRAG reports improving F1 over by about 60% on MuSiQue. It anchors how much any hop-wise hand-off buys.
The most direct competitor is ChainRAG-style name substitution: resolve the bridge entity and substitute its name into the next sub-question. It is the strongest competitor on our exact question, because it isolates "name versus description". It is run with the same small language model, the same retriever, the same corpus, and the same number of retrieval calls as our method. Beating it means higher second-hop Recall@5 and answer F1 on the ambiguity and description slices defined below, with no loss beyond noise on the unambiguous slice.
The passage-forwarding hand-off is represented by Iter-RetGen and IRCoT, which use generated reasoning or content as the next query. The strongest reported figure we have for this family comes from Q-DREAM's paper: on 2WikiMultiHopQA with a ChatGPT backbone, IRCoT reaches 41.9 exact match (EM) and 55.2 F1 at about 25 seconds per query. Q-DREAM itself reaches 48.6 EM and 62.1 F1 at about 4 seconds, which makes Q-DREAM the strongest reported end-to-end number on that benchmark in our file. On HotpotQA, TSSS reports 34.1 EM against 28.0 for IRCoT. We rerun IRCoT and Iter-RetGen with our backbone for a fair comparison, and we add an equal-budget variant that truncates the forwarded passage to the profile's token count. We cite Q-DREAM's and TSSS's numbers as published reference points, and rerun them only if code and budget allow.
The continuous hand-off is L-RAG. It reports 0.352 accuracy on MuSiQue and about 2.8 seconds per query on 2WikiMultiHopQA. We compare against it on its own two-hop setting and report both accuracy and latency. We do not claim to beat it on speed. The comparison asks whether inspectability and the consistency check buy accuracy on the hard slices at an acceptable latency cost.
Three ablations isolate the key ingredient. The first uses the profile as the query without the consistency check. The second runs the check with a name-only representation, which tests whether the check or the profile does the work. The third pads the profile with length-matched but uninformative attributes, which tests whether any gain is just longer queries. All systems share tuning budgets: the same number of prompt-development iterations on a held-out development split, with no tuning on test.
Why not just…?
Why not just substitute the resolved name, as ChainRAG does? This is the real threat. On questions where the bridge entity has a unique name and the target passage repeats it, a name is probably as good as a profile, and we expect a tie there. The proposal lives or dies on the slices where names are ambiguous or absent from the target passage. We construct these slices explicitly and pre-register that the idea fails if profiles do not beat name substitution there by a clear margin.
Why not just forward the whole first-hop passage or chain of thought as the next query? It carries every attribute we would extract, plus everything else. The Q-DREAM paper reports that such CoT-driven queries select passages by surface similarity rather than usefulness, and that this approach is slow (about 25 seconds per query for IRCoT). Our equal-budget comparison tests whether the profile's selectivity matters. If untruncated passage forwarding still wins on recall, we will report that profiles trade accuracy for cost rather than improving accuracy.
Why not just use L-RAG's middle-layer vector? It is faster than anything we propose, and a vector can in principle encode more than a few attributes. It offers nothing to check, however. When retrieval fetches a distractor, the error propagates silently, and the method does not extend past two hops. The distractor-injection experiment measures whether the consistency check recovers errors that L-RAG cannot.
Why not just retrieve more with a reranker and a long context? MultiHop-RAG shows the ceiling of that approach: 0.7467 Hits@10 even with reranking, and 0.32–0.36 accuracy for Llama2-70B and Mixtral-8x7B even when given the ground-truth evidence. The Weakest Link paper shows that burying more passages in context makes the least visible one the limiting factor.
Proposed Experiments
We evaluate on MuSiQue-Ans, 2WikiMultiHopQA, and HotpotQA using their standard corpora, and on MultiHop-RAG for news-domain queries. Metrics are second-hop Recall@2 and Recall@5, answer EM and F1, latency per query, and the failure-cause breakdown described above.
We build three diagnostic slices. The ambiguity slice injects passages about different entities that share the bridge entity's name into the retrieval corpus. The description slice keeps questions whose gold second-hop passage never states the bridge name verbatim. The unambiguous remainder is the control.
The distractor experiment adds adversarial passages that match the bridge name but contradict one of its attributes. It then measures how often each system's final answer is derailed, and what fraction the consistency check catches.
The decisive check is the ambiguity slice. If attribute profiles do not beat name substitution on second-hop Recall@5 by at least five points there, with the padded-profile ablation ruling out a length effect, the claim is false and we stop. A secondary decisive check is extraction error. If profiles are wrong often enough that the extraction-error rate exceeds the retrieval gain, the attribute bottleneck is costing more than it filters. In that case we would retreat to using the profile only as a verifier, not as a query.
References
- Analyzing and Boosting the Power of Fine-Grained Visual Recognition for Multi-modal Large Language Models
- Mitigating Lost-in-Retrieval Problems in Retrieval Augmented Multi-Hop Question Answering
- Failure Modes in Multi-Hop QA: The Weakest Link Effect and the Recognition Bottleneck
- MultiHop-RAG: Benchmarking Retrieval-Augmented Generation for Multi-Hop Queries
- Optimizing Multi-Hop Document Retrieval Through Intermediate Representations
- AnchorCoT: Anchors Pave the Way for Multi-hop Reasoning
- Interleaving Retrieval with Chain-of-Thought Reasoning for Knowledge-Intensive Multi-Step Questions
- Enhancing Retrieval-Augmented Large Language Models with Iterative Retrieval-Generation Synergy
- RSF-GLLM: Bridging the Semantic Gap in Multi-Hop Knowledge Graph QA via Recurrent Soft-Flow and Decoupled LLM Generation
- Mucko: Multi-Layer Cross-Modal Knowledge Reasoning for Fact-based Visual Question Answering
- Optimizing Question Semantic Space for Dynamic Retrieval-Augmented Multi-hop Question Answering
- Think Straight, Stop Smart: Structured Reasoning for Efficient Multi-Hop RAG