Graph-of-Agents landed at ICML 2025 with a blunt message for anyone shipping LLM agent pipelines: procedural graph architectures beat hand-wired chains.
The framework treats each agent as a node and each communication channel as a directed edge, then constructs that graph fresh for every query instead of following a flowchart you drew last quarter.
That single move is spreading across orchestration, topology design. And memory, and it is the foundation self-evolving agents are being built on.
The short version for skimmers: procedural graph architectures turn agent structure into data the system manipulates.
Graph-of-Agents selects agents by their model cards and builds edges from response relevance.
AMAS generates task-specific topologies with a dynamic graph designer. MAGMA and GAM restructure agent memory across multiple graphs instead of one flat context window. When the wiring and the memory are both computable, an agent stops being a script you maintain and starts being a system that adapts.
Why Hand-Scripted Flows Stop Evolving
I build agent automations for small businesses, and the failure pattern is always the same.
A hand-authored chain encodes your assumptions about the queries you expect. When real traffic shifts, the chain does not, so you get a confident answer routed through the wrong specialist.
The research world has formalized this into a field. A survey titled Graphs Meet AI Agents: Taxonomy, Progress. And Future Directions frames the interaction between graph structures and agentic architectures as its own research area. And a second survey on graph-augmented LLM agents sorts existing methods by function: planning, memory, and tool usage. When two taxonomies appear, a pile of techniques has become a discipline. The shared insight is that chains and trees are special cases of a graph. And the special case is exactly what breaks under variety.
Relevance Decides The Wiring, Not You
Graph-of-Agents runs a procedure, not a plan.
It starts with node sampling, “selecting only the most relevant agents by leveraging model cards that summarize each model’s domain, task specialization. And other characteristics” (ICML 2025). Then it builds edges by “evaluating their responses against one another to determine relevance ordering,” producing a directed graph that records which agents influence which.
Execution follows the graph.
Directed message passing flows from highly relevant agents to less relevant ones to improve their answers, then reverse message passing refines the strong responses. And graph-based pooling with max or mean pooling collapses everything into one unified answer. Read that again: the topology is computed per query from how relevant each agent actually is to the others.
AMAS pushes the same idea into topology design itself. Its dynamic graph designer “autonomously identifies task-specific optimal graph configurations via lightweight LLM adaptation,” eliminating the reliance on fixed structural templates (paper). A separate line of work generates communication topologies outright using autoregressive graph generation and graph diffusion models. And an ACL Findings paper goes furthest, arguing that LLM-based multi-agent systems are scalable graph generative models: the diagram is an output, not an input.
The operator translation is simple. You stop maintaining a diagram and start maintaining the policy that draws diagrams. That is a different job, and it is the procedural part of procedural graph architectures.
Memory Becomes Graphs That Restructure Themselves
Orchestration that rewires itself is only half of self-evolution.
The other half is memory that reorganizes what it knows, and the newest work attacks exactly that.
MAGMA represents every memory item across four orthogonal relational graphs: semantic, temporal, causal, and entity (paper).
One memory event lives in all four views at once. So an agent queries whichever relational dimension the question actually needs. When did this happen, what caused it, and who was involved stop being one blob of retrieved text.
GAM solves the retention problem with hierarchy. It “explicitly decouples memory encoding from consolidation” to resolve the conflict between rapid context perception and stable knowledge retention (paper). Ongoing dialogue sits isolated in an event progression graph and merges into a topic associative network only when the semantics shift, plus a graph-guided, multi-factor retrieval strategy sharpens what gets pulled into context. That decoupling is the piece most homegrown agent stacks get wrong: they write and re-rank in one motion. So every new document nudges the whole retrieval baseline.
Put the two halves together and you get the actual definition of a self-evolving agent worth the name. The orchestration graph adapts per query, and the memory graph adapts per experience, with neither requiring a redeploy.
What To Do If You Run A Lean Shop
You will not implement MAGMA this week, and you should not try. But four steals from this literature pay off immediately:
– Log your pipeline as a graph. Every agent invocation is a node, every handoff a directed edge. When something breaks, you trace edges instead of rereading a chain of prompts.
– Copy the model-card trick. Write a card for each agent describing its domain and specialization, then sample only the relevant ones per task. This is Graph-of-Agents step one, and it cuts wasted calls by refusing to consult agents that have nothing to add.
– Split sense, buffer, execute. GraphCogent, a framework inspired by the human Working Memory Model, decomposes graph reasoning into those three stages: a Sensory Module that samples subgraphs and standardizes unstructured graph text into adjacency lists, a Buffer Module that indexes across formats, and an Execution Module combining tool calls with generation (paper). Separating intake, storage, and execution makes debugging tractable even if you never touch a graph library.
– Budget for the second pass. Graph-of-Agents passes messages in both directions before pooling, so answers get refined rather than forwarded. Refinement is extra calls per query. Bill for it.
The frontier version of this merges with training: one pipeline feeds LLM-derived coordination graph priors into a GNN-based multi-agent reinforcement learning stack across four stages, from natural language observation descriptions through graph prior generation, GNN aggregation.
And policy optimization under centralized training with decentralized execution (paper).
That is lab work, not Monday work, but it tells you where the floor is heading. The graph stops being your job entirely.
The Takeaway
Scripted chains were the prototype phase of agents, and the phase is ending.
The papers converging here point one direction: the next architecture is a graph the system draws, queries.
And rewrites itself, with memory that consolidates on its own schedule.
For a one-person operation that is genuinely good news.
Because structure-as-data means fewer rewrites, inspectable failures, and one policy to tune instead of ten prompts to babysit.
Start small and start now. Draw your current agent pipeline as a graph this week, nodes and edges, no framework required. If you want a second pair of eyes on it, that is exactly what Mediascout does: I build and ship agent automations for small operators. And the first thing I ask for is the edges.
