- Rating
- 1
- Confidence
- 4
- Informativeness
- 1
- Presentation
- 2
- Soundness
- 1
Read review
Paper summary
This paper proposes BRIDGE-Prop, an iterative GraphRAG framework that uses LLM-generated bridge entities as additional seeds for Personalized PageRank. The method maintains bridge entities across retrieval rounds and combines retrieved evidence for multi-hop question answering.
Critical strengths
-
The problem of multi-hop evidence retrieval is important.
-
The experiments show improvements over iterative retrieval baselines.
Critical weaknesses
-
Limited novelty. The main idea is to use LLM reasoning to identify intermediate entities and guide subsequent graph retrieval. Similar ideas have already been explored in agentic graph retrieval methods [1, 2, 3, 4]. The proposed approach mainly combines bridge-entity extraction, PPR seeding, and rank fusion, without a sufficiently clear methodological contribution beyond existing approaches.
-
Insufficient baselines. The paper lacks comparisons with many recent agentic retrieval methods[1,2,3,4]. These methods also support multi-step reasoning and graph exploration. Comparing primarily against IRCoT and ITER-RETGEN is insufficient to demonstrate the advantages over modern agentic GraphRAG systems.
-
Limited generalizability. Although the authors evaluate two graph construction methods, both rely on PPR for retrieval. Different GraphRAG systems employ substantially different retrieval mechanisms, including agentic graph traversal and learned retrieval policies. It is unclear whether the proposed approach generalizes beyond PPR-based retrieval.
-
Limited datasets. The evaluation only includes MuSiQue and 2WikiMultiHopQA, two traditional multi-hop QA benchmarks. More diverse datasets and reasoning tasks are needed to support the generality of the findings.
-
Missing efficiency comparison. The proposed framework requires multiple LLM reasoning rounds, bridge-entity grounding, and repeated PPR retrieval. However, the paper does not provide a comprehensive comparison of actual LLM calls, token consumption, inference latency, and computational costs. The additional overhead should be justified against the performance improvements.
[1] Sun et al. Think-on-Graph: Deep and Responsible Reasoning of Large Language Model on Knowledge Graph.
[2] Li et al. GraphReader: Building Graph-based Agent to Enhance Long-Context Abilities of Large Language Models.
[3] Luo et al. Graph-R1: Towards Agentic GraphRAG Framework via End-to-end Reinforcement Learning.
[4] Han et al. Reasoning by Exploration: A Unified Approach to Retrieval and Generation over Graphs.
Questions for authors
Please refer to the weaknesses.
4 comments
(Part 2/2)
W3: Applicability of PPR and generalization
PPR is a widely used graph ranking algorithm. It has been used for word sense disambiguation on WordNet (Agirre and Soroa, 2009), for subgraph retrieval in knowledge-graph question answering (Sun et al., 2018), and for passage retrieval in recent GraphRAG methods such as LinearRAG (Zhuang et al., 2026). It needs no training and only requires nodes and edges, so it applies to very different kinds of graphs. BRIDGE-Prop improves two inputs of PPR, the quality of the seeds and the weight of each seed. This finding is relevant to a wide range of existing systems, and our results add empirical evidence on how to steer untrained graph propagation. We have not tested retrieval mechanisms other than PPR, and we will acknowledge this in the revised Discussion. Given how many methods build on PPR, however, we believe this does not limit the scope of our findings.
W4: Datasets
The standard multi-hop benchmarks in this line of work are HotpotQA, 2WikiMultiHopQA and MuSiQue. HotpotQA's questions are only 2 hops deep though, which is why our paper covers the last two. For this revision, we add HoVer (Jiang et al., 2020). HoVer is built from HotpotQA: each claim is written from a HotpotQA question-answer pair, and it is then extended to three and four hops by replacing an entity with information from a further Wikipedia article. The task is to decide whether a claim is supported, and the evidence comes from up to four articles.
Table 3: HoVer (1000 samples)
| Method | EM | R@5 |
|---|---|---|
| Single-pass graph retrieval | .633 | .594 |
| ITER-RETGEN | .693 | .735 |
| BRIDGE-Prop | .725 | .758 |
On HoVer the answer is a label (supported or not supported), so EM is the accuracy of the predicted label. A closed-book LLM reaches .503. Both iterative methods are well above single-pass retrieval. BRIDGE-Prop is above ITER-RETGEN in both metrics. The EM difference is +.032 (p=.012) and the R@5 difference is +.024 (p=.019).
W5: Efficiency
We agree that this was missing. We will add Tables 4 and 5 to the revised paper. Table 4 gives the LLM calls per question for reasoning and for answering.
Table 4: LLM calls per question (reasoning and answering)
| Method | MuSiQue | 2Wiki | HoVer |
|---|---|---|---|
| Single-pass graph retrieval | 1 | 1 | 1 |
| Single-pass dense retrieval | 1 | 1 | 1 |
| IRCoT | 2.7 | 2.8 | 3.4 |
| ITER-RETGEN | 3 | 3 | 3 |
| BRIDGE-Prop | 2.8 | 2.7 | 2.8 |
| Self-Ask | 6.9 | 6.6 | 7.1 |
| Think-on-Graph† | 13.1 | 21.6 | 17.8 |
† 200 questions per dataset. All other rows use 1000.
Single-pass retrieval makes no LLM call during retrieval and one call for the answer.
Tokens and latency. Table 5 gives the tokens that we logged on HoVer.
Table 5: Tokens per HoVer sample, in thousands
| Method | Samples | Input | Output | Input + output |
|---|---|---|---|---|
| Single-pass graph retrieval | 1000 | 1.0 | 0.3 | 1.3 |
| Single-pass dense retrieval | 1000 | 1.1 | 0.3 | 1.4 |
| IRCoT | 1000 | 8.3 | 1.3 | 9.6 |
| ITER-RETGEN | 1000 | 6.8 | 1.2 | 8.0 |
| BRIDGE-Prop | 1000 | 6.7 | 1.8 | 8.5 |
| Self-Ask | 1000 | 5.1 | 0.7 | 5.8 |
| Think-on-Graph | 200 | 23.7 | 13.9 | 37.6 |
Think-on-Graph was run on 200 samples because of its cost. All numbers include the QA call that reads the five retrieved passages.
BRIDGE-Prop uses about as many tokens as ITER-RETGEN (8.5k against 8.0k per sample). We did not measure latency. All methods use the same LLM. All except Think-on-Graph also use the same retrieval backbone, so their cost differs mainly in calls and tokens.
Bridge prediction is built into the query-rewriting call and adds no separate call. BRIDGE-Prop also stops early when the LLM judges the evidence sufficient, so its number of calls stays close to that of ITER-RETGEN (see Table 4).
References
Agirre and Soroa. Personalizing PageRank for Word Sense Disambiguation. EACL 2009.
Jiang et al. HoVer: A Dataset for Many-Hop Fact Extraction And Claim Verification. Findings of EMNLP 2020.
Press et al. Measuring and Narrowing the Compositionality Gap in Language Models. Findings of EMNLP 2023.
Sun et al. Open Domain Question Answering Using Early Fusion of Knowledge Bases and Text. EMNLP 2018.
Zhuang et al. LinearRAG: Linear Graph Retrieval Augmented Generation on Large-scale Corpora. ICLR 2026.
Thank you for the author’s response. I am curious as to why the authors chose "Self-Ask" as a baseline for performance evaluation, rather than other, more recent benchmark methods? I list a few baselines.
Thank you for the question. We chose the baselines to cover the main reasoning paradigms for multi-hop retrieval. Each is a well-established, training-free representative of its paradigm:
- Interleaved chain-of-thought (IRCoT). Each reasoning step guides the next retrieval.
- Generation-as-query (ITER-RETGEN). The model's hypothetical answer is appended to the question as the next query.
- Question decomposition (Self-Ask, added in the revision). Each sub-question is answered by retrieval.
- LLM-driven graph traversal (Think-on-Graph, added in the revision). The LLM chooses which neighbouring entities to follow.
All methods use the same LLM on the same graph as BRIDGE-Prop, so the comparison is controlled.
Think-on-Graph is the first method in your list [1] (Section 5.7, Appendix A.10), and GraphReader [2] belongs to the same paradigm. BRIDGE-Prop is more effective than Think-on-Graph at a much smaller LLM budget.
Graph-R1 [3] and Reasoning by Exploration [4] train the model with reinforcement learning. BRIDGE-Prop is training-free, and training these two methods is beyond our compute budget. We cite and discuss both in Related Work.
Response to Reviewer bdAG (Part 1/2)
We thank the reviewer for engaging with our work and for acknowledging the improvements our method provides. We address the five weaknesses in order.
W1: Novelty and relation to agentic graph retrieval
Our related work discusses Think-on-Graph [1] and GraphReader [2] and states the difference. In these methods the LLM navigates the graph step by step, and it is called at every step. BRIDGE-Prop does not navigate the graph. It uses PPR to propagate over the graph nodes. Our contribution is to make untrained PPR work for multi-hop retrieval by improving its seeds and their weights (W3).
In this revision we add Think-on-Graph as a baseline on the same NER graph we use (W2). With the search width and depth of the original paper (both three), it needs 13 to 22 LLM calls per question, against about three for BRIDGE-Prop (W5), and its EM and R@5 are lower on both datasets.
Graph-R1 [3] and Reasoning by Exploration [4] are not cited in the paper, and we will add them. Both train the LLM with reinforcement learning. BRIDGE-Prop is training-free. These directions are complementary: the bridge entities that BRIDGE-Prop grounds could serve as an intermediate training signal for such learned policies, which we leave to future work.
W2: Baselines
We add two baselines. Both run on our NER graph with the same LLM.
Self-Ask (Press et al., 2023) is an iterative method based on question decomposition. The LLM breaks the question into follow-up questions, retrieves passages for each one, answers it, and then composes the final answer. Table 1 compares it with ITER-RETGEN and BRIDGE-Prop on all 1000 questions.
Table 1: Self-Ask on all 1000 questions
On 2Wiki Self-Ask has a higher EM than ITER-RETGEN and a lower EM than BRIDGE-Prop (p=.029). Self-Ask writes an intermediate summary of the retrieved passages for each follow-up question. Its final answer reads the passages of the last round together with these intermediate summaries. This helps its EM and takes 6.6 to 6.9 LLM calls per question. The evidence of earlier rounds is kept in the summaries and not in the final five passages, which is why its R@5 is lower than both on both datasets.
In Think-on-Graph [1] the LLM navigates the graph step by step. It was designed for knowledge graphs with typed relations. We adapt it to our NER graph by treating the sentence in which two entities co-occur as the relation between them. It explores the graph with a limited search width and depth (both three, as in the original paper). At each step the LLM selects a few neighbouring entities to follow, so only a small part of the graph is visited. This takes 13 to 22 LLM calls per question and more tokens than any other method (37.6k against 8.5k for BRIDGE-Prop on HoVer, Table 5). Because of this cost we ran it on 200 questions per dataset. Its difference from the other methods is already clear on this subset.
Think-on-Graph returns only the passages on its reasoning paths, so we also report Think-on-Graph + fill, which fills the passages up to five with single-pass graph retrieval and answers with the same QA prompt as all other methods. The fill raises R@5 from .332 to .566 on MuSiQue and from .454 to .691 on 2Wiki. PPR retrieval on the same graph therefore provides useful evidence that is different from the passages on the reasoning paths.
Table 2: Think-on-Graph on 200 questions
BRIDGE-Prop is above both Think-on-Graph variants on both datasets.