ReaGAN: Retrieval-Augmented Graph Agentic Network

• The paper redefines node classification by using a frozen LLM and treating each node as an autonomous agent with its own memory and planning capabilities.
• It combines local structural aggregation with global semantic retrieval to overcome conventional GNN limitations, enhancing performance on benchmarks like Cora, Citeseer, and Chameleon.
• Ablation studies demonstrate that both agentic planning and a balanced local-global memory strategy are essential for achieving competitive classification accuracy without training.

ReaGAN, introduced as a “Retrieval-augmented Graph Agentic Network,” is a framework for node classification on text-attributed graphs that replaces parametric graph neural network training with a frozen LLM, retrieval, and few-shot in-context learning. In ReaGAN, each node is treated as an autonomous agent with its own memory, planning prompt, action sequence, and prediction step. The framework is designed to address two limitations attributed to standard graph neural networks: the lack of node-specific autonomy under homogeneous message passing, and an over-reliance on local structural neighborhoods that neglect semantically relevant but structurally distant information (Guo et al., 1 Aug 2025).

1. Problem formulation and motivating challenges

ReaGAN is defined on a text-attributed graph $\mathcal{G} = (\mathcal{V}, \mathcal{E})$, where each node $v \in \mathcal{V}$ has a natural-language text feature $t_v$ and may have a label $y_v \in \mathcal{Y}$. The task is node classification: predict $\hat{y}_v$ for unlabeled nodes. The framework is evaluated on Cora, Citeseer, and Chameleon, but is presented as generic to text-attributed graph settings (Guo et al., 1 Aug 2025).

The motivation is framed against the standard GNN update pattern

$$h_v^{(l)} = \text{UPDATE}^{(l)}\left(h_v^{(l-1)}, \text{AGG}\big(\{h_u^{(l-1)} : u \in \mathcal{N}(v)\}\big)\right),$$

which applies the same aggregation rule to every node at every layer. ReaGAN identifies two resulting difficulties. The first is “Node-Level Autonomy”: nodes differ in informativeness, yet homogeneous aggregation cannot let a sparse node seek more context while allowing an already informative node to avoid additional noise. The second is “Local-Global Complementarity”: standard graph propagation privileges local neighborhoods and structural proximity, while semantically useful nodes may be structurally distant or absent from the immediate neighborhood (Guo et al., 1 Aug 2025).

These two challenges place ReaGAN in a distinct position relative to graph-augmented retrieval systems built for question answering. In graph-based RAG for complex reasoning, graph structure is used to improve retrieval and generation over external knowledge (Dong et al., 2024). ReaGAN instead applies retrieval and agentic planning directly to node-wise graph learning, turning the graph itself into a decentralized inference environment rather than a corpus-level retrieval backend.

2. Node-as-agent architecture

ReaGAN’s central design move is to reinterpret each node as an agent rather than a passive vertex. Each node maintains a private memory $\mathcal{M}_v^{(l)}$, builds a planning prompt from that memory, invokes a frozen LLM to choose actions, executes those actions, and writes the results back to memory. After a fixed number of reasoning layers, the node issues a prediction prompt and the LLM outputs the node label (Guo et al., 1 Aug 2025).

Initialization is

$$\mathcal{M}_v^{(0)} \leftarrow \{ t_v \}, \qquad \tilde{t}_v^{(0)} \leftarrow t_v,$$

where $\tilde{t}_v^{(l)}$ denotes the aggregated text feature after layer $l$. At each layer,

$v \in \mathcal{V}$0

The plan is parsed as structured actions, and at the final layer prediction is performed by

$v \in \mathcal{V}$1

The memory stores three kinds of information: the node’s original text, aggregated text summaries produced by prior local or global actions, and labeled examples gathered from neighbors. Its update rule is

$v \in \mathcal{V}$2

with

$v \in \mathcal{V}$3

This makes memory a textual state rather than a latent vector state. The process is described as decentralized and asynchronous: different nodes may choose different actions and different effective propagation depths, even though the outer loop is indexed by the same abstract layer counter (Guo et al., 1 Aug 2025).

This node-as-agent interpretation differs sharply from the single-controller architectures commonly used in agentic retrieval systems. Surveys of agentic RAG typically describe a central planner, coordinator, or tool-using controller that manages retrieval pipelines, reflection, and tool use (Singh et al., 15 Jan 2025). ReaGAN distributes that control to every node.

3. Retrieval augmentation and local–global information flow

ReaGAN’s retrieval component is built over a structure-free corpus of all node texts,

$v \in \mathcal{V}$4

When a node performs global aggregation, its current textual representation is embedded and used to retrieve semantically similar nodes: $v \in \mathcal{V}$5 The retrieved nodes form the global semantic neighborhood $v \in \mathcal{V}$6, complementing the local structural neighborhood $v \in \mathcal{V}$7 induced by graph edges (Guo et al., 1 Aug 2025).

Local aggregation is defined as

$v \in \mathcal{V}$8

while global aggregation is

$v \in \mathcal{V}$9

In both cases, labeled neighbors are extracted into few-shot example sets,

$t_v$0

which are then inserted into memory (Guo et al., 1 Aug 2025).

A common misconception is to treat ReaGAN as a conventional GraphRAG system for question answering. In ReaGAN, retrieval is node-level text retrieval over the set of node texts; it does not retrieve graph fragments, Cypher query results, or passage-level evidence chains in the style of graph-based QA systems. GeAR, for example, augments conventional retrievers with a graph over triples and an LLM agent that iteratively reads, reasons, rewrites queries, and decides when to stop (Shen et al., 2024). By contrast, ReaGAN uses retrieval to expand a node’s semantic context for classification, not to perform corpus-level answer search.

4. Planning, action space, and inference regime

The planning output is a JSON-encoded action list. The action space includes LocalAggregation, GlobalAggregation, Prediction, and NoOp, and the planning prompt may also allow a combined local+global aggregate choice. The prompt describes the node’s current text feature, its last local and global aggregated text features, the contents of memory, and guidelines for when to continue aggregating or stop (Guo et al., 1 Aug 2025).

The NoOp action is important because it explicitly allows a node to halt further information gathering: $t_v$1 This is the mechanism by which ReaGAN departs from synchronous message passing. In a conventional GNN, every node updates at every layer. In ReaGAN, some nodes may do only local aggregation, some only global aggregation, some both, and some no aggregation at all (Guo et al., 1 Aug 2025).

The prediction prompt exposes candidate labels only as anonymized identifiers such as “Label 0” or “Label 1”, rather than semantic class names. The framework reports that exposing label names harms accuracy. Few-shot in-context learning is implemented by inserting labeled examples from local and global memory into the prediction prompt, with up to a fixed number of local and global examples per node (Guo et al., 1 Aug 2025).

ReaGAN is explicitly training-free. The LLM backbone is frozen, the retrieval encoder is fixed, prompts are hand-designed, and there is no explicit loss function, no backpropagation, and no reinforcement learning in the method as presented. This distinguishes it from later agentic GraphRAG systems that optimize multi-step search with GRPO or related RL objectives, such as A2RAG’s adaptive controller and progressive graph retrieval (Liu et al., 29 Jan 2026), ProGraph-R1’s progress-aware step-wise policy optimization (Park et al., 25 Jan 2026), or PathRouter’s path-aware reward shaping and token-level teacher KL guidance (Wang et al., 15 Jun 2026). ReaGAN’s “agentic” character is therefore architectural rather than learned.

5. Experimental results and ablation findings

ReaGAN is evaluated on three node-classification benchmarks: Cora, Citeseer, and Chameleon. The datasets are split into 60% train, 20% validation, and 20% test. Node text is constructed from title plus abstract on Cora and Citeseer, and from full Wikipedia page text on Chameleon, optionally compressed by an LLM (Guo et al., 1 Aug 2025).

Against parametric baselines, ReaGAN reports the following test accuracies: $t_v$2 For comparison, the same table reports GCN at 84.71, 72.56, and 28.18; GraphSAGE at 84.35, 78.24, and 62.15; and GPRGNN at 79.51, 67.63, and 67.48 on the same datasets. The result highlighted in the paper is that ReaGAN is comparable to the best GNNs on Cora while using a frozen LLM and no graph-specific training (Guo et al., 1 Aug 2025).

The main ablation isolates agentic planning and the local/global split. Full ReaGAN yields 84.95, 60.25, and 43.80 on Cora, Citeseer, and Chameleon. “No Prompt Planning,” where all nodes follow a fixed action sequence, drops to 79.83, 35.87, and 38.29. “Local Only” yields 81.67, 58.73, and 25.60. “Global Only” yields 79.67, 33.45, and 24.94. These results show that both the planning mechanism and the combination of local structural and global semantic information are necessary to the reported performance (Guo et al., 1 Aug 2025).

A second prompt-level ablation compares two memory strategies. Strategy A always includes both local and global memory in the prompt; Strategy B includes global memory only if fewer than two local examples are available. The reported results are 84.95 versus 83.02 on Cora, 50.14 versus 60.25 on Citeseer, and 43.80 versus 38.29 on Chameleon. The paper interprets this as evidence that prompt strategy should depend on graph characteristics, with selective use of global memory helping on the sparser Citeseer graph (Guo et al., 1 Aug 2025).

A final ablation shows that revealing semantic label names hurts performance. On Cora, using label names gives 76.83 versus 84.95 with anonymized label IDs; on Citeseer, 42.11 versus 60.25. The stated explanation is that the LLM overfits to the wording of label names rather than reasoning from the few-shot examples in memory (Guo et al., 1 Aug 2025).

6. Position within graph-based and agentic retrieval research

ReaGAN belongs to a broader research shift from homogeneous graph propagation to retrieval-augmented and agent-mediated graph reasoning. Graph-enhanced RAG systems have used GNN encoders, graph-embedding retrieval, and late fusion with large generators to improve knowledge consistency and reasoning over structured knowledge (Dong et al., 2024). Agentic retrieval systems have introduced iterative graph expansion, gist memory, and query rewriting for multi-hop question answering (Shen et al., 2024). Hybrid graph-text architectures in cyber threat intelligence have combined Cypher-based graph querying, repair loops, and text retrieval to improve structured factual reasoning and safe abstention (Hamzic et al., 13 Apr 2026). Relation-free graph indexes such as LinearRAG’s Tri-Graph have shown that entities, sentences, and passages can support multi-hop retrieval without unstable relation extraction (Zhuang et al., 11 Oct 2025).

Against that background, ReaGAN is unusual in two respects. First, it applies retrieval augmentation to graph learning itself rather than to corpus-level QA. Second, it places agentic control at the node level rather than in a single planner over an external graph store. This suggests a different interpretation of “agentic graph networks”: not only a controller acting on a graph, but a graph whose vertices are themselves decision-making units (Guo et al., 1 Aug 2025).

The method also differs from memory-based multi-agent graph construction frameworks such as MemGraphRAG, which use specialized extraction, conflict-detection, and resolution agents around a shared global memory to build higher-quality retrieval graphs (Wu et al., 30 May 2026). ReaGAN’s memory is private to each node and is used for inference rather than corpus-scale graph construction. A plausible implication is that ReaGAN and such systems address complementary levels of the graph-RAG stack: one reorganizes graph learning as decentralized in-context reasoning, while the other reorganizes graph indexing as coordinated memory-aware extraction.

7. Limitations and future directions

The paper identifies several limitations. ReaGAN incurs LLM calls per node per reasoning layer, which creates scalability and latency challenges on large graphs. Its experiments are confined to static text-attributed node classification, and extension to dynamic or multimodal graphs is left open. The framework depends on retrieval quality: poor semantic retrieval can inject misleading global context. It is also sensitive to prompt engineering, context length, and the balance between local and global examples. Finally, because the core method has no trainable parameters and no explicit learning objective, its behavior is driven by prompt heuristics rather than systematic optimization (Guo et al., 1 Aug 2025).

The stated future directions include extending the framework beyond node classification to link prediction, graph classification, and dynamic graphs; exploring different LLMs, retrieval systems, and agent orchestration frameworks; and using ReaGAN as a basis for scalable decentralized decision-making in multi-agent systems (Guo et al., 1 Aug 2025). Related work points toward several plausible extensions. Token-efficient agentic RAG frameworks such as TeaRAG compress retrieved content with triplets, graph construction, and Personalized PageRank while reducing reasoning steps through process-aware preference optimization (Zhang et al., 7 Nov 2025). Cost-aware adaptive GraphRAG systems such as A2RAG escalate retrieval effort only when evidence is insufficient and explicitly map graph signals back to provenance text (Liu et al., 29 Jan 2026). Progress-aware and path-aware RL systems further show how step-level or route-conditioned rewards can align graph retrieval behavior with useful evidence rather than shortcut answering (Park et al., 25 Jan 2026, Wang et al., 15 Jun 2026).

Those later systems are not ReaGAN, but they clarify the surrounding design space. ReaGAN demonstrates that frozen-LLM, retrieval-augmented, agentic graph inference can be formulated without training. This suggests a broader research program in which node-level autonomy, local–global retrieval, and explicit planning are treated as first-class components of graph learning rather than as auxiliary mechanisms layered onto conventional GNNs (Guo et al., 1 Aug 2025).