Graph of Agents (GoA): A Structural Framework

Updated 5 July 2026

Graph of Agents (GoA) is a family of graph-centric abstractions that organize agent interactions and dependencies using explicit nodes and edges.
It enables long-context modeling and multi-agent orchestration by applying query-conditioned compression, dynamic graph generation, and deterministic DAG execution.
GoA frameworks boost performance via parallel processing, adaptive communication structures, and robust error recovery, while also supporting formal monitoring and memory analysis.

Graph of Agents (GoA) denotes a family of graph-structured formulations in which agent interaction, collaboration, memory, execution, or analysis is organized explicitly through nodes and edges. In current arXiv usage, the term spans several distinct but related constructions: a training-free, model-agnostic framework for long-context modeling that treats document understanding as query-conditioned compression (Joo et al., 26 Sep 2025); a graph-based framework for multi-agent LLM communication with relevance-weighted message passing (Yun et al., 18 Apr 2026); deterministic DAG-based orchestration engines (Sarker et al., 8 Mar 2026); learned or input-conditioned topology generators (Vierling et al., 2024, Chen et al., 20 Mar 2026); decentralized graph-learning policies in Networked-MARL (Duan et al., 20 Sep 2025); and graph abstractions for agent programs, memories, and formal monitoring (Wang et al., 2 Jul 2026, Paul et al., 29 Mar 2026, Zhao et al., 20 Jul 2025). Taken together, these works suggest that GoA is not a single standardized formalism but a family of graph-centric abstractions in which the graph is the execution substrate, the communication topology, the compression structure, or the analytical object.

1. Conceptual scope and semantic variants

Different GoA papers instantiate the graph at different semantic levels.

Formulation	Node semantics	Graph role
"Graph of Agents" (Joo et al., 26 Sep 2025)	workers over chunks in a linear forest	query-conditioned compression and manager synthesis
"GraphBit" (Sarker et al., 8 Mar 2026)	typed agent nodes/functions	deterministic DAG execution, branching, parallelism, error recovery
"GoAgent" (Chen et al., 20 Mar 2026)	collaborative groups $M_i=(\mathcal{S}_i,\mathcal{E}(\mathcal{S}_i))$	intra-group cohesion and inter-group coordination
"AgentFlow" (Wang et al., 2 Jul 2026)	agents, prompts, models, capabilities, memory states, control policies	static dependency recovery, BOM generation, security analysis

A recurring misconception is to equate GoA with free-form multi-agent conversation. The literature is broader. Some systems use homogeneous workers and an input-dependent graph to compress long documents; some define workflows explicitly as DAGs and remove orchestration from the prompt; some learn the graph from input, observations, or posterior beliefs; and some use the graph primarily for static analysis, memory retrieval, or formal monitoring. This suggests that the unifying property is not conversational style but explicit graph structure over agent-relevant entities.

Another source of variation is what an edge means. Depending on the paper, edges encode collaboration chains, typed data dependencies, control-flow transitions, inter-group dependencies, sampled communication masks, or data/control/component dependencies in program analysis. Accordingly, GoA should be read as a representational principle rather than a single algorithm.

2. Long-context modeling as graph-structured compression

The most explicit formalization of GoA appears in "Graph of Agents: Principled Long Context Modeling by Emergent Multi-Agent Collaboration" (Joo et al., 26 Sep 2025). That paper treats long-context modeling as a compression problem. Given an LLM $\hat{P}$ with context window $T_{\max}$ , the goal is to find a compressor $g$ such that

$|prompt(g(x;q),q)| \leq T_{\max},$

while preserving the information needed to answer query $q$ . Under a Bayes-optimal predictor, maximizing the expected post-compression log-likelihood is equivalent to maximizing $I(Y;g(X),Q)$ , and the paper then replaces the intractable objective with an embedding-similarity surrogate motivated by pointwise mutual information.

GoA operationalizes that objective through a dynamically constructed linear forest. The graph family is constrained to linear forests, i.e. a set of disjoint path graphs, each path representing a collaboration chain among a subset of chunks. Within a path, workers summarize assigned chunks sequentially, conditioned on the evolving summary and the query; the manager then synthesizes the final summaries from all paths. This yields two stated benefits over a single chain: parallelization across subgraphs and flexible, input-dependent ordering within each subgraph.

Exact combinatorial search over forests is intractable, so the paper uses greedy graph construction. Chunks are first clustered in embedding space; in the experiments the authors use $k=4$ and cluster with $k$ -medoids for robustness to outliers. Within each cluster, the next chunk is chosen by maximizing query similarity conditioned on the current partial summary rather than by isolated query similarity. That contextual selection is central to the method: the collaboration structure emerges from marginal utility under the evolving summary, not from hand-crafted roles.

Empirically, the framework is evaluated on six LongBench question-answering datasets: NarrativeQA, Qasper, MultiFieldQA, HotpotQA, 2WikiMultiHopQA, and MuSiQue, using Llama 3.1 8B and Qwen3 8B. Across the six datasets, GoA improves average $F_1$ over retrieval-augmented generation by 5.7% and over the fixed-structure multi-agent baseline CoA by 16.35%. On Llama 3.1 8B with a 2K context window, GoA reaches 48.67 average $\hat{P}$ 0, exceeding Vanilla (43.86), RAG (43.18), and CoA (38.54). A particularly notable result is that GoA with only a 2K context window scores 48.67, surpassing the 128K context window vanilla baseline at 47.92. The paper further reports that removing contextual search causes severe degradation, that semantic embeddings matter more than BM25-style replacement, and that the best number of subgraphs is task- and backbone-dependent, with $\hat{P}$ 1 best for Llama and $\hat{P}$ 2 best for Qwen.

The broader implication is that GoA here is neither a retrieval heuristic nor a fixed workflow. It is a principled, query-aware compression architecture whose graph is chosen per input instance.

3. Execution graphs and LLM orchestration

A second major GoA line treats the graph as the execution substrate for agentic systems. "GraphBit: A Graph-based Agentic Framework for Non-Linear Agent Orchestration" (Sarker et al., 8 Mar 2026) defines workflows explicitly as typed DAGs executed deterministically by a Rust-based engine. Agents are typed functions; edges are typed data and control dependencies; routing and state transitions are governed by the engine rather than by LLM self-selection. The engine maintains a ready queue, dispatches independent nodes in parallel via a thread pool, validates types at node boundaries, supports conditional control flow over structured state predicates, and applies configurable error recovery including immediate termination, automatic retry with exponential backoff, and checkpointing for resumption. Its three-tier memory architecture consists of ephemeral scratch space, structured state, and external connectors, and the ablation results are explicit: Full GraphBit: 67.6% accuracy, 126.1 MB; Without ephemeral scratch: 64.7%, 189.2 MB; Without structured state: 57.4%, 138.7 MB; Without external connectors: 60.3%, 130.4 MB; Single-tier baseline: 52.9%, 247.8 MB. On a curated 68-task GAIA subset, GraphBit achieves 67.6% accuracy, 0.0% hallucination, 11.9 ms processing time, 5,025 ops/min throughput, and 126.1 MB peak memory, with 1,916 mean total tokens/task.

"Graph-of-Agents: A Graph-based Framework for Multi-Agent LLM Collaboration" (Yun et al., 18 Apr 2026) instead uses the graph to structure test-time collaboration among LLMs. The pipeline has four stages: node sampling from model cards, edge sampling by pairwise response evaluation, directed message passing in two directions, and graph pooling. A Meta-LLM selects the top- $\hat{P}$ 3 agents from model-card summaries; the selected agents answer the query; each agent scores the others; relevance scores induce a weighted directed adjacency matrix; message passing proceeds first from highly relevant agents to less relevant ones and then in reverse; final aggregation uses either max pooling or mean pooling. The paper states that MoA is a special case of GoA when the top- $\hat{P}$ 4 equals the full agent count, the graph is fully connected with all edge weights equal to 1, a self-loop includes the original query at each layer, and final aggregation is mean pooling. With an agent pool of 6 models, GoA achieves superior performance using only 3 selected agents, outperforming baselines that use all 6 agents simultaneously. On MMLU-Pro, MoA requires 19 calls, about 56k tokens, and 240 seconds, whereas $\hat{P}$ 5 uses 11 calls, about 19k tokens, and 100 seconds.

"El Agente Gráfico: Structured Execution Graphs for Scientific Agents" (Bai et al., 19 Feb 2026) is explicitly single-agent, but it is GoA-aligned in a stricter execution-theoretic sense. It embeds LLM routing within typed execution graphs, typed Python scientific objects, an object-graph mapper, and a dynamic knowledge graph used as external persistence, provenance store, and query substrate. The graph nodes are validated computational steps, and edges encode admissible control flow, including conditional transitions and cyclic repair loops. Relative to a prior multi-agent El Agente baseline, the paper reports cost dropping from \$\hat{P}$60.17, wall-clock time dropping from 1,827 s to roughly 200–300 s, and token consumption dropping from about 1.6M to about 100k. These systems collectively show that GoA need not rely on prompt-orchestrated routing; the graph can be the authoritative runtime semantics.

4. Generated and learned communication topologies

Another major interpretation of GoA is that the graph itself should be learned or generated per input. "Input Conditioned Graph Generation for Language Agents" (Vierling et al., 2024) makes this point directly. Building on the abstraction of a language agent as a directed acyclic graph $\hat{P}$7, it replaces a single global edge-probability vector with an input-conditioned mapping $\hat{P}$8. A pretrained LLM produces a hidden representation $\hat{P}$9, which is mapped to edge probabilities by $T_{\max}$0, and REINFORCE is used to optimize expected utility. This generalizes the static objective to an input-conditioned one, so that the communication structure changes with the task instance. The paper also introduces a sparsity-inducing loss

$T_{\max}$1

On specialized agents for MMLU + CMMLU, Static Graph reaches 44.7% and Dynamic Graph reaches 50.3%; with sparsity, Static Graph is 42.1% and Dynamic Graph is 52.4%. In the adversarial-agent MMLU setting, performance improves from 44.6% to 48.6%, and the truthful-to-adversarial critical-edge sampling ratio improves from 1.52 to 2.73.

"GoAgent: Group-of-Agents Communication Topology Generation for LLM-based Multi-Agent Systems" (Chen et al., 20 Mar 2026) moves from node-centric to group-centric graph generation. Its atomic unit is the collaborative group

$T_{\max}$2

and the group-level communication graph is $T_{\max}$3. Candidate groups are first enumerated by an LLM; in the reported setup this is typically $T_{\max}$4 groups. The model then autoregressively selects groups and predicts inter-group edges, jointly modeling predefined intra-group topologies and learned inter-group coordination. To reduce redundant communication and historical noise, it introduces a conditional information bottleneck objective,

$T_{\max}$5

instantiated with task-conditioned compression of historical features for group and edge prediction. Across six benchmarks—MMLU, GSM8K, MultiArith, SVAMP, AQuA, HumanEval—GoAgent reports 93.84% average accuracy while reducing token consumption by about 17%, exceeding the strongest listed learned-topology baseline, ARG-Designer, at 92.62% average accuracy.

These papers converge on a common thesis: fixed communication scaffolds are often suboptimal. The graph can itself be an adaptive policy object, conditioned on query semantics, task domain, or evolving interaction history.

5. Decentralized control and learned coordination in multi-agent systems

Outside LLM orchestration, GoA is also used to describe learned interaction structures in MARL and distributed Bayesian learning. "GCS: Graph-based Coordination Strategy for Multi-Agent Reinforcement Learning" (Ruan et al., 2022) factorizes the joint team policy into a graph generator and a graph-based coordinated policy:

$T_{\max}$6

The graph generator outputs a directed acyclic action-coordination graph, and the policy of each agent conditions on its parents’ current actions. The method imposes a DAGness constraint,

$T_{\max}$7

and a DAG depth constraint via nilpotency to bound the longest path. It is evaluated on Collaborative Gaussian Squeeze, Cooperative Navigation, and Google Research Football, where the paper reports superiority over VDN, QMIX, DCG, and DGN.

"Bayesian Ego-graph inference for Networked Multi-Agent Reinforcement Learning" (Duan et al., 20 Sep 2025) can be read as an inferred GoA structure in a decentralized physical network. Each agent operates over a fixed physical neighborhood $T_{\max}$8 but samples a latent local subgraph $T_{\max}$9 from a learned distribution, constrained to be a subgraph of the environment topology. The effective graph is defined by a binary latent mask,

$g$0

with a factorized Bernoulli variational posterior and Gumbel-Softmax / Concrete relaxation for backpropagation. Message passing is then performed only over the masked graph, and the actor loss is used as the negative log-likelihood term in a variational ELBO. The paper emphasizes that this yields sparse, context-aware communication masks learned from task feedback. On five adaptive traffic signal control benchmarks in SUMO—ATSC_Grid, Monaco, NewYork33, NewYork51, and NewYork167—BayesG reportedly outperforms CommNet, NeurComm, IA2C, ConseNet, FPrint, and LToS, with especially strong behavior on the 167-agent setting. The ablation result is conceptually important: random masking hurts performance, whereas learned masking improves it, implying that the benefit comes from task-adaptive sparsification rather than sparsity alone.

"BayGo: Joint Bayesian Learning and Information-Aware Graph Optimization" (Alshammari et al., 2020) addresses heterogeneous decentralized learning by rewiring communication toward the most informative neighbor. Agents maintain local posteriors over a discretized parameter space and optimize graph weights using inter-posterior KL divergence as a proxy for informativeness. Under the sparse optimum, each agent assigns self-weight $g$ 1 and the remaining mass to the single neighbor with maximum KL divergence. The paper claims exponential decrease of posterior estimation error, eventual B-strong connectivity over time, and faster convergence and higher accuracy than fully connected and star topology baselines. In this line of work, GoA is not a workflow graph but an adaptive statistical communication graph.

The shared pattern across these systems is that the graph is endogenous to coordination. It is generated from observations, latent masks, or posterior beliefs, and it directly changes action dependence, message passing, or information flow.

6. Memory graphs, dependency graphs, and formal monitoring

Some recent work uses GoA-like abstractions not to orchestrate multiple agents directly, but to structure memory, program semantics, and formal specifications. "AgentFlow: Building Agent Dependency Graphs for Static Analysis of Agent Programs" (Wang et al., 2 Jul 2026) introduces the Agent Dependency Graph (ADG),

$g$ 2

with typed nodes drawn from

$g$ 3

where $g$ 4 are agents, $g$ 5 prompts, $g$ 6 models, $g$ 7 capabilities, $g$ 8 memory states, and $g$ 9 control policies. ADG supports Agent BOM generation and prompt-to-tool risk detection. Implemented for OpenAI Agents SDK, LangChain/LangGraph, CrewAI, LlamaIndex, and Semantic Kernel, AgentFlow is evaluated on AgentZoo, a corpus of 5,399 real-world agent programs, and the paper reports 238 taint-style prompt-to-tool risks.

"GAAMA: Graph Augmented Associative Memory for Agents" (Paul et al., 29 Mar 2026) treats memory itself as a typed graph. Its construction pipeline preserves verbatim episodes, extracts atomic facts and concept nodes, and synthesizes higher-order reflections. The resulting memory graph has four node types—episode, fact, reflection, concept—and five structural edge types—NEXT, DERIVED_FROM, DERIVED_FROM_FACT, HAS_CONCEPT, ABOUT_CONCEPT. Retrieval combines cosine-similarity-based $|prompt(g(x;q),q)| \leq T_{\max},$ 0-nearest neighbors with edge-type-aware Personalized PageRank through an additive scoring function. On LoCoMo-10 with 1,540 questions across 10 multi-session conversations, GAAMA reports 78.9% mean reward, exceeding a tuned RAG baseline (75.0%), HippoRAG (69.9%), A-Mem (47.2%), and Nemori (52.1%). The ablation result is narrow but informative: augmenting semantic search with PPR improves overall performance by +1.0 percentage point.

"STL-GO: Spatio-Temporal Logic with Graph Operators for Distributed Systems with Multiple Network Topologies" (Zhao et al., 20 Jul 2025) provides a formal language for MAS requirements over multiple directed graphs. Agent-centered formulas extend STL with graph operators

$|prompt(g(x;q),q)| \leq T_{\max},$ 1

which count agents satisfying $|prompt(g(x;q),q)| \leq T_{\max},$ 2 along incoming or outgoing edges whose weights lie in interval $|prompt(g(x;q),q)| \leq T_{\max},$ 3, with the count constrained by integer interval $|prompt(g(x;q),q)| \leq T_{\max},$ 4 and quantification $|prompt(g(x;q),q)| \leq T_{\max},$ 5 over graph types. The framework models a MAS as a tuple of graph trajectories $|prompt(g(x;q),q)| \leq T_{\max},$ 6 over communication, sensing, mission, and distance graphs, and it gives distributed monitoring conditions under which agents can evaluate formulas using only local information, returning a trinary verdict in $|prompt(g(x;q),q)| \leq T_{\max},$ 7. The case studies are bike-sharing and multi-drone monitoring.

These systems broaden the GoA notion considerably. The graph can encode not only collaboration but also memory provenance, latent software semantics, or formal neighborhood-counting requirements over heterogeneous network topologies.

7. Broader graph-theoretic applications and unresolved questions

A broader graph-of-agents perspective also appears in distributed robotics, swarms, and mobile-agent theory. "Detecting Anomalous Swarming Agents with Graph Signal Processing" (Schultz et al., 2021) treats a swarm snapshot as a weighted undirected graph with distance-based adjacency and analyzes agent properties as graph signals. Using the normalized Laplacian, the paper defines graph Fourier transforms and proposes two anomaly detectors—Out-of-Band Power (OOBP) and Local Graph Smoothness (LGS)—based on filtered nodewise energies. In simulations on the Couzin and swarmalator models, both methods perform better than chance in all cases, performance improves when multiple snapshots are combined, Case 5 is easiest to detect, Case 3 is hardest, and OOBP is usually more effective than LGS.

"Virtual Force-Based Routing of Modular Agents on a Graph" (Casselman et al., 2 May 2025) studies modular vehicles that can join and split on an edge-weighted directed graph. The routing heuristic balances target attraction and agent-agent attraction by evaluating $|prompt(g(x;q),q)| \leq T_{\max},$ 8-shortest paths with inverse-square virtual forces, projecting those forces onto candidate first edges, and allowing agents to wait when beneficial. On the Champaign-Urbana road network, the force-based method slightly outperforms the prior two-agent modular routing baseline and, for 10 agents, is better than a non-modular shortest-path baseline in 81 out of 100 cases.

Two graph-theoretic papers highlight a different issue: which structural properties actually govern mobile-agent complexity. "Broadcast via Mobile Agents in a Dynamic Network: Interplay of Graph Properties & Agents" (Jr. et al., 7 Apr 2025) shows that edge density is not the right differentiating property for Broadcast in constantly connected dynamic graphs. It constructs graphs with edge density $|prompt(g(x;q),q)| \leq T_{\max},$ 9 solvable with only $q$ 0 agents, graphs with density tending to 1 from above that still require $q$ 1 agents, and lollipop graphs with density $q$ 2 requiring exactly $q$ 3 agents for any $q$ 4 and $q$ 5. "Graph Exploration by Energy-Sharing Mobile Agents" (Czyzowicz et al., 2021) studies weighted graph exploration when co-located agents can transfer energy. It gives an $q$ 6 algorithm for paths, an $q$ 7 algorithm for trees with $q$ 8 leaves, proves NP-hardness for general graphs even when they are 3-regular, and shows that exploration is always possible if total energy is at least twice the total edge weight, with that factor being asymptotically optimal.

These applications make clear that GoA is not confined to LLM systems. It also names a style of reasoning in which agents are embedded in, analyzed through, or coordinated by graph structure. At the same time, the literature remains heterogeneous. Open tensions include fixed versus learned graphs, node-centric versus group-centric design, prompted orchestration versus engine-governed execution, and runtime graphs versus analytical graphs. A plausible implication is that future work will need sharper typologies separating communication graphs, execution graphs, memory graphs, and dependency graphs, because current usage places all of them under the same GoA umbrella.