---
title: 'Graph of Agents (GoA): A Structural Framework'
url: https://www.emergentmind.com/topics/graph-of-agents-goa-323403e8-5870-4858-b103-ed16edba755f
type: topic
---

# Graph of Agents (GoA): A Structural Framework

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 [2509.21848]; a graph-based framework for multi-agent LLM communication with relevance-weighted message passing [2604.17148]; deterministic DAG-based orchestration engines [2605.13848]; learned or input-conditioned topology generators [2406.11555, 2603.19677]; decentralized graph-learning policies in Networked-MARL [2509.16606]; and graph abstractions for agent programs, memories, and formal monitoring [2607.01640, 2603.27910, 2507.15147]. 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" [2509.21848] | workers over chunks in a linear forest | query-conditioned compression and manager synthesis |
| "GraphBit" [2605.13848] | typed agent nodes/functions | deterministic DAG execution, branching, parallelism, error recovery |
| "GoAgent" [2603.19677] | collaborative groups $M_i=(\mathcal{S}_i,\mathcal{E}(\mathcal{S}_i))$ | intra-group cohesion and inter-group coordination |
| "AgentFlow" [2607.01640] | 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" [2509.21848]. 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 $F_1$, 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 $k=2$ best for Llama and $k=4$ 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" [2605.13848] 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" [2604.17148] 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-$k$ 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-$k$ 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 $\textsf{GoA}_{\textsf{Max}}$ uses **11 calls**, about **19k tokens**, and **100 seconds**.

"El Agente Gráfico: Structured Execution Graphs for Scientific Agents" [2602.17902] 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 **\$4.67** to as low as **\$0.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" [2406.11555] makes this point directly. Building on the abstraction of a language agent as a directed acyclic graph $G(V,E,F,o)$, it replaces a single global edge-probability vector with an input-conditioned mapping $f(x)=\theta$. A pretrained LLM produces a hidden representation $h$, which is mapped to edge probabilities by $\theta = W\cdot h + b$, 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
$$
L(\theta)=\delta \cdot \sum_{i=1}^{|\mathcal{E}|} |\theta_i|,\quad \delta=0.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" [2603.19677] moves from node-centric to group-centric graph generation. Its atomic unit is the collaborative group
$$
M_i=(\mathcal{S}_i,\mathcal{E}(\mathcal{S}_i)),
$$
and the group-level communication graph is $\mathcal{G}=(\mathcal{M},\mathcal{E})$. Candidate groups are first enumerated by an LLM; in the reported setup this is typically **$K=16$ 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,
$$
\min \mathcal{L}_{\text{CIB}} = -I(\tilde{X};Y|Z) + \beta I(\tilde{X};X|Z),
$$
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" [2201.06257] factorizes the joint team policy into a graph generator and a graph-based coordinated policy:
$$
\pi(\mathbf{u},A|s)=\rho(A|s)\prod_{i=1}^n \pi^i(u^i|o^i,u^{pa(i)}).
$$
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,
$$
g(A):=\operatorname{trace}(e^{A\circ A})-d=0,
$$
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" [2509.16606] can be read as an inferred GoA structure in a decentralized physical network. Each agent operates over a fixed physical neighborhood $\mathcal{V}_i$ but samples a latent local subgraph $G_{\mathcal{V}_i}$ from a learned distribution, constrained to be a subgraph of the environment topology. The effective graph is defined by a binary latent mask,
$$
G_i^*=Z_i\odot G_i^{\mathrm{env}},
$$
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" [2011.04345] 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 $\delta$ 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" [2607.01640] introduces the Agent Dependency Graph (ADG),
$$
\mathsf{ADG}_P=\langle \mathsf{ACDG}_P,\mathsf{ACFG}_P,\mathsf{ADFG}_P\rangle,
$$
with typed nodes drawn from
$$
\mathcal{V}=\mathcal{A}\uplus\mathcal{I}\uplus\mathcal{M}\uplus\mathcal{C}\uplus\mathcal{S}\uplus\mathcal{G},
$$
where $\mathcal{A}$ are agents, $\mathcal{I}$ prompts, $\mathcal{M}$ models, $\mathcal{C}$ capabilities, $\mathcal{S}$ memory states, and $\mathcal{G}$ 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" [2603.27910] 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 $k$-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" [2507.15147] provides a formal language for MAS requirements over multiple directed graphs. Agent-centered formulas extend STL with graph operators
$$
\mathbf{In}^{W,\#}_{\mathcal{G},E}\varphi,\qquad
\mathbf{Out}^{W,\#}_{\mathcal{G},E}\varphi,
$$
which count agents satisfying $\varphi$ along incoming or outgoing edges whose weights lie in interval $W$, with the count constrained by integer interval $E$ and quantification $\#\in\{\exists,\forall\}$ over graph types. The framework models a MAS as a tuple of graph trajectories $\pmb{\mathcal{G}}$ 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 $\{0,1,?\}$. 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" [2103.09629] 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" [2505.00928] 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 $k$-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" [2504.05442] shows that edge density is not the right differentiating property for Broadcast in constantly connected dynamic graphs. It constructs graphs with edge density **$>1.1\overline{6}$** solvable with only **$o(n)$** agents, graphs with density tending to **1** from above that still require **$\Omega(n/f(n))$** agents, and lollipop graphs with density **$<\rho$** requiring exactly **$k$** agents for any $k>0$ and $\rho>1$. "Graph Exploration by Energy-Sharing Mobile Agents" [2102.13062] studies weighted graph exploration when co-located agents can transfer energy. It gives an **$O(n+k)$** algorithm for paths, an **$O(n+\ell k^2)$** algorithm for trees with $\ell$ 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.

Source: https://www.emergentmind.com/topics/graph-of-agents-goa-323403e8-5870-4858-b103-ed16edba755f