Graph-of-Agents (GoA)

Updated 3 July 2026

Graph-of-Agents (GoA) is an algorithmic paradigm that represents multi-agent systems as graphs with nodes as agents and edges as communication or control links.
It supports distributed reasoning and dynamic subgraph selection through local message passing and iterative state updates.
Practical applications include LLM-based graph reasoning, context compression for long-input QA, multi-agent reinforcement learning, and agent software analysis.

A Graph-of-Agents (GoA) is a formal and algorithmic paradigm for representing, reasoning about, and orchestrating multi-agent systems in which agents and their interconnections are naturally modeled as a graph. In GoA, each agent is typically mapped to a node, and edges encode communication, control, or dependency relationships. The GoA paradigm has emerged as a unifying abstraction across diverse fields—graph reasoning, long-context modeling, multi-agent orchestration for LLMs, distributed system logic, and agent software analysis—enabling systematic decomposition, communication, and joint decision-making among agents. Several recent frameworks formalize GoA at different levels: distributed graph computation with LLM-agents, task-specific group-based orchestration for multi-agent systems, coordination graphs in MARL, algebraic spatiotemporal logic for distributed systems, agent orchestration in software pipelines, as well as knowledge graph-based retrieval and evaluation architectures.

1. Core Formalism and Abstraction Principles

In the canonical Graph-of-Agents formalism, an original graph $G=(V,E)$ is mirrored by constructing an agent graph $G_A=(V_A,E_A)$ where:

$V_A = \{a_i : v_i \in V\}$ assigns an agent $a_i$ to each node $v_i$ .
$E_A = \{(a_i, a_j) : (v_i, v_j) \in E\}$ reflects the communication constraints or dependency structure of $G$ , restricting $a_i$ 's messages to $N(a_i)=\{a_j\mid(a_i,a_j)\in E_A\}$ (Hu et al., 2024).

GoA provides a structural backbone for systematizing the exchange of information, enabling distributed computation (e.g., via message passing and local updates), and encoding the locality or modularity of agent interactions. This paradigm unifies approaches in LLM-based graph reasoning (Hu et al., 2024), algorithmic orchestration for context compression (Joo et al., 26 Sep 2025), emergent group-level coordination (Chen et al., 20 Mar 2026), MARL cooperation learning (Duan et al., 2024), and algebraic logic for MAS (Zhao et al., 20 Jul 2025, Paul et al., 25 Jun 2026).

2. Distributed Reasoning and Computation via GoA

In distributed graph reasoning, GoA enables scalable, accurate solutions by assigning each agent to a node and constraining messaging to local neighbors.

A prototypical example is GraphAgent-Reasoner (GAR):

Graph Construction: Each node $v_i$ becomes agent $G_A=(V_A,E_A)$ 0 with local state $G_A=(V_A,E_A)$ 1, storing its own data and neighbor list.
Algorithm Instantiation: The master LLM retrieves or instantiates a distributed algorithm template: agent state $G_A=(V_A,E_A)$ 2, messaging scheme, initializations, local send ( $G_A=(V_A,E_A)$ 3), update ( $G_A=(V_A,E_A)$ 4) rules, and halting condition.
Synchronous Execution: At each round $G_A=(V_A,E_A)$ $G_{A} = (V_{A}, E_{A})$ 5, agents
- Receive inbound messages,
- Update state via $G_A=(V_A,E_A)$ 6,
- Send new messages via $G_A=(V_A,E_A)$ 7,
- Continue until global/per-agent termination.
Master Summarization: Agents report final states; the master composes the global answer.

This model achieves strong empirical and theoretical scalability, with total LLM call complexity $G_A=(V_A,E_A)$ 8 and communication load $G_A=(V_A,E_A)$ 9 ( $V_A = \{a_i : v_i \in V\}$ 0, $V_A = \{a_i : v_i \in V\}$ 1, $V_A = \{a_i : v_i \in V\}$ 2=rounds). On GraphInstruct, GAR yields near-perfect accuracies ( $V_A = \{a_i : v_i \in V\}$ 3 for multiple PTIME tasks), outcompeting fine-tuned and zero/few-shot LLM baselines, and maintaining high accuracy to $V_A = \{a_i : v_i \in V\}$ 4 nodes, where single-agent LLMs fail (Hu et al., 2024).

3. Adaptive Group Structures and Orchestration

Classic node-centric GoA is extended in task-driven settings to exploit higher-order structure.

GoAgent (Chen et al., 20 Mar 2026) introduces an explicit group-based GoA, treating collaborative groups as atomic communication units:

Candidate groups (sets of LLM roles/agents with intra-group topology) are enumerated via LLMs.
Groups are autoregressively selected and linked as meta-nodes, forming a group-level communication graph $V_A = \{a_i : v_i \in V\}$ 5.
Inter-group edges reflect coordination, optimized via a Conditional Information Bottleneck (CIB) objective to compress inter-group communication by maximizing task-relevant mutual information and filtering noise.

This model reduces topological redundancy and token bloat—achieving 93.84% average accuracy across six reasoning and code benchmarks and cutting token consumption by 17% relative to node-centric approaches (Chen et al., 20 Mar 2026).

In MARL, GoA manifests as a Group-Aware Coordination Graph (GACG), learning both pairwise cooperation and higher-order group dependence:

Each agent encodes local state; pairwise edge strengths are dynamically inferred.
Group structure is imposed by partitioning agents by recent trajectory similarity, introducing block-structured (group) covariance in the connectivity matrix.
Decision making and information exchange use multi-layer graph convolutions over these latent group-aware graphs, with explicit group-specialization losses for performance and convergence gains (Duan et al., 2024).

4. Structured Communication, Message Passing, and Compression

GoA naturally supports sophisticated message passing and communication protocols that balance scalability, information retention, and communication cost.

Graph-of-Agents for Long-Context Modeling (Joo et al., 26 Sep 2025): Input documents are partitioned into semantically clustered chunks (via embedding-based $V_A = \{a_i : v_i \in V\}$ 6-means). Each cluster forms a path graph ("chain") implemented as a sequence of LLM worker agents; these jointly summarize in a manner maximizing query information (measured via mutual information or embedding similarity between the compressed summary and the query).

A parallel-manager agent aggregates chain outputs for final answer synthesis. GoA-driven compression enables models with 2K context windows to outperform vanilla 128K models on LongBench (GoA $V_A = \{a_i : v_i \in V\}$ 7 vs Vanilla $V_A = \{a_i : v_i \in V\}$ 8), evidencing dramatic effective context extension (Joo et al., 26 Sep 2025).

Ablations demonstrate that dynamic, query-aware subgraph selection and contextual message passing are critical; naive, uniform, or retrieval-only structures degrade performance.

In heterogeneous model pools, GoA enables efficient orchestrated reasoning via dynamically constructed agent graphs. For example, relevance-weighted, directed message passing between LLM pool agents—guided by peer rating and meta-LLM node selection—yields higher accuracy than fixed-pool or unstructured debate approaches, with substantial reductions in total LLM calls and computational cost (Yun et al., 18 Apr 2026).

5. Formal Logic and Quantitative Semantics over Graph-of-Agents

GoA enables expressive specification, monitoring, and verification of MAS by extending temporal logic frameworks to support graph operators and agent quantification.

STL-GO (Zhao et al., 20 Jul 2025, Paul et al., 25 Jun 2026): Spatio-Temporal Logic with Graph Operators formalizes multi-agent properties over one or more interaction graphs. Local formulas allow specification of "in/out" constraints (e.g., "agent $V_A = \{a_i : v_i \in V\}$ 9 has at least 3 communication neighbors within 2 km who satisfy a property $a_i$ 0") via syntax such as $a_i$ 1. Global formulas quantify over agent sets.

Quantitative semantics are constructed via an algebraic accumulator framework that separates temporal aggregation, graph-operator (neighbor counting) aggregation, and agent-wise robustness evaluation, admitting a spectrum of semantic instantiations: Boolean, min–max (robustness margins), signed-deficit (redundancy), and hybrid (Paul et al., 25 Jun 2026).

Distributed monitoring algorithms enable agents to evaluate local satisfaction of specifications using only partial neighbor information, with sufficient conditions guaranteeing local decision soundness (Zhao et al., 20 Jul 2025). Case studies (bike sharing, drone surveillance) exhibit scalability and precision in both centralized and decentralized contexts.

6. Agent Software and Workflow Analysis as Graph-of-Agents

GoA concepts underpin both the static and dynamic analysis of complex agent-based software.

AgentFlow (Wang et al., 2 Jul 2026) defines an Agent Dependency Graph (ADG) for static program analysis, unifying component-dependency, control-flow, and data-flow between agents, prompts, models, tools, memory stores, and policies as a multi-typed graph.

ADG nodes: agent entities, prompt/instruction contexts, models, capabilities, memory/states, control policies.
Edges encode structural component binding, dynamic invocation/control, and data dependencies (incl. inter-agent messaging).
Analysis supports agent bill-of-materials enumeration, prompt-to-tool taint risk queries, and readiness for emerging security/gov. checks.

Empirically, AgentFlow recovers richer entity/dependency sets and detects taint-style risks at higher rates and lower false positive/negative rates than AST-only tools (Wang et al., 2 Jul 2026).

GraphBit (Sarker et al., 8 Mar 2026) generalizes agent orchestration to deterministic, engine-driven workflow DAGs, where agents, tool nodes, and control nodes are interlinked with type-constrained edges. Explicit routing/state transition logic, memory isolation (ephemeral, structured, external), and fine-grained parallel execution enable reproducible, high-throughput pipelines, provably eliminating framework-induced hallucinations and inefficiencies in practical deployments.

7. Retrieval, Evaluation, and Metrics over Graph-of-Agents

GoA primitives enable layered retrieval and evaluation of both agent pools and agent actions.

Agent-as-a-Graph retrieval (Nizar et al., 22 Nov 2025) represents both agents and their tools as nodes in an attributed bipartite graph. Given a query, vector search and type-specific reciprocal rank fusion (wRRF) rank agent and tool nodes, followed by graph traversal to select top bundles, yielding significant gains in Recall@5 and nDCG@5 over agent- or tool-only baseline retrievers.
WebGraphEval (Qian et al., 22 Oct 2025) abstracts multiple agent trajectories into a directed, weighted action graph, canonically merging steps, and computes per-edge and per-node efficiency, redundancy, and diversity metrics (e.g., step inflation, necessity rate, path entropy). This GoA-style abstraction exposes not only final outcomes but structural inefficiencies, strategy diversity, and cross-agent critical decision points in interactive web agent benchmarks.

References

(Hu et al., 2024) (GraphAgent-Reasoner: fine-tuning-free GoA for distributed graph reasoning with LLMs)
(Joo et al., 26 Sep 2025) (Graph of Agents: principled context compression, dynamic subgraph selection for long-input QA)
(Chen et al., 20 Mar 2026) (GoAgent: group-level GoA communication topology, conditional information bottleneck)
(Duan et al., 2024) (Group-Aware Coordination Graph: GoA for structural group dependencies in MARL)
(Zhao et al., 20 Jul 2025, Paul et al., 25 Jun 2026) (STL-GO: algebraic logic/quantitative semantics over multi-graph MAS)
(Sarker et al., 8 Mar 2026) (GraphBit: engine-driven agent workflow DAG, memory isolation)
(Yun et al., 18 Apr 2026) (Graph-based LLM collaboration: node/edge sampling, relevance, bidirectional message passing)
(Nizar et al., 22 Nov 2025) (Agent-as-a-Graph: bipartite knowledge graph for agent+tool retrieval)
(Qian et al., 22 Oct 2025) (WebGraphEval: graph abstraction for trajectory evaluation)
(Wang et al., 2 Jul 2026) (AgentFlow: static program analysis, ADG queries/governance/security)