How does hypergraph accumulation differ from single-pass graph retrieval?

This explores two ways graph-based retrieval can work — accumulating knowledge across multiple steps versus pulling it all in one pass — and the corpus frames these as genuinely different bets about where reasoning should happen. The accumulation approach, exemplified by hypergraph memory Can hypergraphs capture multi-hop reasoning better than graphs?, treats retrieval as a process: each step adds evidence as hyperedges that can bind three or more entities into a single relation, so joint constraints survive instead of being flattened into a list. The point isn't just to find more facts but to keep them *coherent together* over time. Single-pass retrieval makes the opposite bet — that if you structure the knowledge well enough up front, you can answer in one reach.

The sharpest example of that single-pass bet is HippoRAG Can knowledge graphs enable multi-hop reasoning in one retrieval step?, which converts the whole corpus into a knowledge graph and then uses Personalized PageRank seeded from the query to traverse multi-hop paths in *one* retrieval step. It matches iterative methods while being 10–20x cheaper and faster. So the surprising thing is that single-pass isn't the naive option — done right, it absorbs the multi-hop work into a single graph walk, where accumulation spreads that work across turns. The difference is less 'shallow vs deep' and more 'where does the reasoning live': in the graph's pre-computed structure, or in the sequence of retrievals?

That raises the cost question, and here the corpus splits along when the graph gets built. Pre-built graphs pay construction cost up front and risk going stale; LogicRAG Can query-time graph construction replace pre-built knowledge graphs? argues you can skip both by constructing a query-specific logic graph at inference time. Accumulation methods sidestep pre-building differently — they grow the structure as they go. And once a graph is large, reading all of it stops being free: Graph-O1 mcts-plus-rl-replaces-whole-graph-reading-with-selective-traversal-in-graphr replaces whole-graph ingestion with learned, selective traversal that fits inside a context window, trading certainty about the full graph for tractable navigation. So 'single-pass' itself fractures into 'pass over everything' versus 'pass along a chosen path.'

There's a deeper reason accumulation can be worth its complexity. Agentic graph reasoning Why do reasoning systems keep discovering new connections? finds that iterative graph building self-organizes into a critical state where roughly 12% of edges stay semantically surprising even after being structurally connected — meaning the act of accumulating keeps surfacing new connections a single pass would never compute. That's the case *for* doing it over time. The case *against* is that no structure is universally right: StructRAG Can routing queries to task-matched structures improve RAG reasoning? shows that routing each query to a task-appropriate structure — table, graph, algorithm, or plain chunk — beats committing to one representation, grounding the choice in cognitive-fit theory.

The thing you might not have known you wanted to know: the accumulation-vs-single-pass split mirrors a broader architectural principle in the corpus. Hierarchical research designs Do hierarchical retrieval architectures outperform flat ones on complex queries? show that separating planning from synthesis reduces interference on hard queries — which is exactly what accumulation does in time (plan the next retrieval, then integrate) and what single-pass graph methods do in space (pre-structure, then read once). Both are ways of refusing the flat retrieval that fails on global, cross-document questions Can multimodal knowledge graphs answer questions that flat retrieval cannot?. The real divide isn't graph-vs-graph; it's whether you front-load the structure or let it emerge.