Dynamic Generation of Multi-LLM Agents Communication Topologies with Graph Diffusion Models

In plain words

A team of AI agents that talk to each other needs to know who sends messages to whom. Fixed patterns, such as everyone talks to everyone or a single chain, waste effort on easy questions and become bottlenecks on hard ones. This paper learns a fresh message pattern for each task.

The generator starts from a random pattern of links and removes the noise step by step, the same basic idea as image diffusion models, until a clean pattern remains. A small learned predictor estimates how well a pattern would do on the task and how costly it would be. At every step the generator tries several candidate patterns and keeps the one the predictor likes best, so the search is steered as it goes rather than judged only at the end.

The aim is patterns that are accurate, cheap in messages and sparse. The authors report that this beats hand-made and learned baselines on math and code benchmarks, with the caveat that all numbers are their own.

TL;DR

GTD is a guided discrete graph diffusion model that writes a sparse, task-specific communication graph for a multi-agent LLM team. Training needs simulated runs of baseline topologies to fit a GNN proxy and a denoiser. Inference samples K=5 candidates per step and keeps the one with the best proxy score (utility minus 0.1 times cost in the released code). The paper reports top accuracy on most math benchmarks, with GPT-4o-mini agents. All results are author-reported, single-run, with no variance given.

Problem

Choosing the communication graph among LLM agents is a design problem with competing goals: task accuracy, token cost, robustness to failed agents and sparsity §1 eq. 1. Hand-made patterns (chain, star, fully connected) do not adapt to the task §1. Earlier learned topology methods are said to use single-step generators, which limit exploration, and to apply reward only after the whole graph exists §1. Evaluating the reward means running a full multi-agent simulation for each candidate graph, which is too slow to use inside a sampling loop §3.1 §3.3.

Method

GTD writes the team's communication graph as a binary adjacency matrix A in {0,1}^(N×N), where A_ij = 1 means agent i may send to agent j §3.1. Its goal is to find the A that maximises a composite reward R(A, C) of utility, cost, sparsity and further terms, given a task condition C §3.1 eq. 1. The paper's reward has no fixed weights; the released code uses only utility and cost (see Paper vs code).

The method has four stages.

1. Build a seed dataset. Run a set of baseline topologies on a small set of training tasks and record utility and cost for each run §4.1 app. D. The paper uses 50 training samples §5 app. D.
2. Train the proxy P. A graph neural network with two graph attention layers (hidden size 32) reads the graph and node states. Mean pooling gives one vector, which is concatenated with the projected task condition and passed to an MLP that outputs (utility, cost). Training minimises mean squared error §4.1 eq. 4 eq. 5.
3. Train the denoiser G. G is a conditional graph transformer with two layers and two heads §4.2 app. D. It is trained only on high-performing graphs, those above a performance threshold that the paper does not give §4.2. Each training step corrupts a clean graph with a variance-preserving forward process over T=50 steps §4.2 eq. 6 and trains G to predict the clean graph with binary cross-entropy eq. 7.
4. Guided sampling (inference). Start from noise. At each step t, predict the clean graph without guidance, sample K candidate graphs from that prediction, score each candidate with P, keep the one with the best weighted score w_u·utility − w_c·cost eq. 8, and use it in place of the raw prediction when computing the reverse posterior §4.3 alg. 1 app. E. The paper argues this is a zeroth-order (gradient-free) step, because the candidates are discrete and P is not differentiable with respect to G's output §4.3. Appendix G gives a theorem that bounds the performance gap by twice the proxy's maximum error; the bound is for an idealised optimiser, not for the K-sample search app. G.2 eq. 8.

# Guided Topology Diffusion: sample one topology for a task  [alg. 1] [app. E]
# Input:  task condition C (embedding of the query), trained G and P
# Input:  weights w_u, w_c (values not stated in the paper)
# Output: graph A0 with entries in {0, 1}, shape (N, N)

def generate_topology(C, G, P, w_u, w_c, K, T):
    # Start from random noise on the adjacency matrix  [alg. 1]
    A_t = random_noise(N, N)                    # (N, N)
    for t in range(T, 0, -1):                   # T = 50 steps  [§5]
        # Predict the clean graph without guidance  [alg. 1]
        A0_hat = G(A_t, C, t)                   # (N, N), entries in [0, 1]
        # Draw K binary candidates from the prediction  [alg. 1]
        candidates = [bernoulli(A0_hat) for k in range(K)]
        # Score each candidate with the proxy  [alg. 1]
        scores = []
        for candidate in candidates:
            utility, cost = P(candidate, C)
            scores.append(w_u * utility - w_c * cost)
        # Keep the candidate with the best weighted score  [eq. 8]
        A0_best = candidates[argmax(scores)]
        # Take the reverse step using A0_best instead of A0_hat  [alg. 1]
        A_t = sample_posterior(A_t, A0_best, t)
    return A_t

Training pseudocode for the two learned parts, as the paper and code describe them:

# Proxy training on simulated outcomes  [§4.1] [app. D]
# Input: records (A_j, C_j, (utility_j, cost_j)) from baseline runs

def train_proxy(records):
    # 10 epochs, Adam with learning rate 1e-3, batch size 16  [app. D]
    for epoch in range(10):
        for batch in minibatches(records, size=16):
            predicted = P(batch.graphs, batch.conditions)
            # Mean squared error on (utility, cost)  [eq. 5]
            loss = mean(squared_error(predicted, batch.outcomes))
            update(P, loss)
    return P

# Denoiser training on high-performing graphs only  [§4.2] [eq. 6] [eq. 7]
# Input: clean graphs A0 whose utility exceeds a threshold (not stated)

def train_denoiser(clean_graphs, conditions):
    # Learning rate 1e-4 over 50 timesteps  [app. D]
    for A0, C in minibatches(clean_graphs, conditions):
        # Pick a random timestep and corrupt the clean graph  [eq. 6]
        t = random_step(0, T)
        A_t = forward_noise(A0, t)
        # Predict the clean graph; compare with cross-entropy  [eq. 7]
        A0_hat = G(A_t, C, t)
        loss = binary_cross_entropy(A0_hat, A0)
        update(G, loss)
    return G

Key equations, as written in the paper:

\mathcal{R}(A, C) = f(\text{Utility}(A,C), \text{Cost}(A,C), \text{Sparsity}(A), \ldots) eq. 1

q(A_t \mid A_0) = \mathcal{N}(A_t;\ \sqrt{\bar{\alpha}_t}\,A_0,\ (1-\bar{\alpha}_t)\,I) eq. 2 eq. 6

\mathcal{L}_\theta = \mathbb{E}\big[\,\| A_0 - \mathcal{G}_\theta(\sqrt{\bar{\alpha}_t}A_0 + \sqrt{1-\bar{\alpha}_t}\,\epsilon,\ C,\ t)\|^2\big] eq. 3

\mathcal{L}_\phi = \frac{1}{M}\sum_{j=1}^{M} \lVert \mathcal{P}_\phi(A_j, C_j) - P_j \rVert_2^2 eq. 5

\mathcal{L}_\theta = \mathbb{E}\big[\,\mathrm{BCE}\big(\mathcal{G}_\theta(\sqrt{\bar{\alpha}_t}A_0 + \sqrt{1-\bar{\alpha}_t}\,\epsilon,\ C,\ t),\ A_0\big)\big] eq. 7

A^{(t)}_{0,\text{best}} = \arg\max_{A^{(t)}_{0,k}} \big( w_u \hat{u}_k - w_c \hat{c}_k \big), \quad [\hat{u}_k, \hat{c}_k]^T = \mathcal{P}_{\phi^*}(A^{(t)}_{0,k}, C_{\text{new}}) eq. 8

The GNN update in the surrogate is written as a graph attention layer with learned attention coefficients eq. 4. Figures are described in words only: fig. 1 compares three workflows, fig. 2 shows the four-stage pipeline, fig. 3 contrasts static and adaptive graphs, fig. 4 shows robustness to a failed agent, fig. 5 plots accuracy against tokens, and fig. 6 shows the ablations. fig. 7 and fig. 8 are case studies of topologies and agent roles (appendix Q).

Hyperparameters

Results

Author-reported, GPT-4o-mini agents, GSM8K, MATH, MultiArith, HumanEval, MMLU and SVAMP §5 tab. 1. The paper does not report repeated runs, seeds or confidence intervals. Two Avg. entries in the paper's own table do not equal the mean of their row (see Pitfalls).

Headline claims from the text: GTD is best on GSM8K, MATH, MultiArith and SVAMP §5.1. On MATH it is more than 2 points above the strongest baseline, MaAS §5.1.

Other author-reported results:

• Accuracy against tokens fig. 5: the paper plots accuracy against token use on GSM8K, MultiArith, SVAMP and MMLU, and reports for GSM8K about 4.8e+06 tokens for GTD, against about 15% more for G-Designer, and LLM-Debate at over five times that §5.2. On MultiArith, GTD reaches nearly 99% with about 8.4e+04 tokens §5.2. On SVAMP it is the only method above 91% at about 1.4e+05 tokens §5.2.
• Robustness fig. 4 §5.3: when one non-critical agent is made to output errors, GTD drops from 94.1% to 93.8% on GSM8K. DyLAN drops by nearly 13 points, and a complete graph by over 2 points §5.3. Extended failure table below.
• Inference time tab. 6 app. H: 7.9 s per instance on GSM8K (4 agents, one A6000) for GTD, against 8.8 s for MaAS, 9.2 s for G-Designer, 11.7 s for LLM-Debate and 1.8 s for vanilla CoT.

Ablations:

Generalisation to Qwen-3-8B §6.2 tab. 3:

LiveCodeBench, Pass@1, Qwen-3-8B tab. 10: base model 25.4%, MaAS 29.3%, GTD 30.8%.

Failure scenarios on GSM8K, change from the no-failure accuracy tab. 9 app. K:

Ablation on the number of candidates K, GSM8K tab. 12 app. M: K=1 gives 88.42% at 3.2 s; K=3 gives 93.15% at 5.8 s; K=5 gives 94.14% at 7.9 s; K=10 gives 94.31% at 18.1 s; K=20 gives 94.38% at 36.8 s.

Comparison of generation strategies, GSM8K tab. 11 app. L: a direct GNN prediction gives 91.23% with one proxy evaluation; direct GNN with top-K gives 92.15% with 100; 100-step MCMC gives 92.87% with 100; GTD gives 94.14% with 250 evaluations (50 steps × K=5).

Surrogate fidelity on held-out data from the seed dataset tab. 8 app. J: utility MSE 0.0089 and cost MSE 0.0124; Pearson correlation 0.91 (utility) and 0.94 (cost); top-1 of 5 ranking accuracy 78.4% and 85.2%; top-2 of 5 93.6% and 96.1%. On topologies that GTD itself generated, top-1 ranking accuracy is 72.8% and top-2 is 89.3% app. J.

Scalability, GPU memory, diffusion plus proxy tab. 7 app. I: 2.8 GB at 5 agents, 3.4 GB at 50, 3.9 GB at 100, 4.9 GB at 1000.

Compute: four NVIDIA A6000 GPUs, 48 GB each app. C app. N.

Dataset licences, as listed in the paper tab. 4 app. F: MMLU, GSM8K, SVAMP, MATH and HumanEval are listed as MIT License, and MultiArith as "Unspecified". Dataset URLs are in tab. 5 app. F.

Paper vs code

Official code: github.com/ericjiang18/diffusion_agent, linked from the abstract. The owner is the paper's first author. Cloned at commit 22738c3739fd14189193fc8f9e412b2bfe627137. The repository has no LICENSE file, so no code is quoted; citations are for reference only. Only the GSM8K pipeline (experiments/run_gsm8k.py and run_gsm8k.sh) and the GTD modules under GDesigner/gdt/ were read in full. The other run scripts were checked for agent settings only.

Discrepancies between the paper and the released code:

• Attention is local, not global. The paper says the graph transformer uses global attention, so each edge prediction sees all nodes §4.2. The code masks attention with the binarised noisy graph plus self-loops, so each node attends only to its neighbours in that graph graph_transformer.py diffusion_model.py. The code also applies a FiLM layer that conditions every transformer layer on the task and time embedding graph_transformer.py.
• Training loss. The preliminaries write a squared-error loss eq. 3, and the appendix proves that form equivalent to the ELBO app. G.1. The method section trains with binary cross-entropy eq. 7, and the code does too diffusion_model.py.
• Candidate sampling. The algorithm samples candidates from Bernoulli(sigmoid(Â0)) alg. 1. The network already ends with a sigmoid, so the code samples Bernoulli directly from the network's probabilities guided_generation.py graph_transformer.py. Applying sigmoid again, as the paper's notation reads, would give a different distribution.
• Initial noise and state space. The paper starts from N(0, I) alg. 1. The code starts from a uniform matrix in [0, 1], symmetrised diffusion_model.py. States are kept in [0, 1] by a clamp after each noising and denoising step diffusion_model.py diffusion_model.py. The paper does not describe this clamp.
• Reward terms. The reward in eq. 1 includes robustness and sparsity. The released guidance uses only the proxy's utility and cost guided_generation.py run_gsm8k.py. Robustness is measured but not optimised.
• Cost. The paper defines cost as token consumption or communication overhead §3.1. The code uses the number of edges in the topology, not tokens run_gsm8k.py.
• Task condition. The paper says the condition is the query embedding concatenated with an embedding of the current graph state §4.3. The code uses the query embedding only run_gsm8k.py.
• Final output. At t=0 the posterior coefficients reduce to 1 and 0, so under guidance the returned matrix is the guided binary candidate itself. The 0.5 threshold then changes nothing diffusion_model.py diffusion_model.py run_gsm8k.py. This is read from the code, not run.
• Noise schedule. The paper says {β_t} is predefined §3.2. The code uses a linear schedule from 1e-4 to 0.02 over T steps diffusion_model.py. The class default is 1000 steps, but the driver passes 50 gtd_framework.py run_gsm8k.py.
• Proxy GNN. The paper gives the update as a single attention-weighted sum eq. 4. The code uses a GAT with four heads averaged (concat off), followed by ReLU, mean pooling, and an MLP of width 64 proxy_reward_model.py proxy_reward_model.py.
• Proxy data. The paper says the seed data come from baseline topologies run on 50 samples §5. The code runs six baselines per sample (fully connected, chain, star and three random graphs), so up to 300 runs run_gsm8k.py.
• Training filter. The paper says graphs are kept if they exceed a performance threshold §4.2. The code keeps graphs whose utility is above 0.5 run_gsm8k.py.
• HumanEval agents. The paper uses four CodeSolver agents §5. The released HumanEval script names four different roles run_humaneval.sh.
• Inference batch size. The paper says inference uses a batch size of 2 §5. In the code this is the number of queries per loop iteration, and each query generates one graph with num_graphs=1 run_gsm8k.sh run_gsm8k.py.
• Denoiser learning rate and batch. The paper's lr of 1e-4 matches the code run_gsm8k.py. The code uses batch 16 run_gsm8k.py, which the paper does not state.
• Proxy learning rate and batch. Adam at 1e-3 with batch 16 matches the paper run_gsm8k.py.

No code was found for the reported comparison baselines, the robustness and failure experiments, the Qwen-3-8B runs, or the LiveCodeBench runs. Those numbers are not verifiable from the repository.

Pitfalls

• Missing reward weights. w_u and w_c are not given in the paper. The code uses 1.0 and 0.1, with cost subtracted. The guidance depends on that ratio, so an implementation that picks other values will change behaviour.
• Missing architecture details. The paper does not give the denoiser's width, the feed-forward size, the node features, the time embedding, the threshold for the training filter, the noise schedule, or the batch size and epochs for the denoiser. Reproducing the paper alone is not possible without guessing; the code fills these in (see Hyperparameters).
• Node features are undescribed. The paper never says what the node inputs are. The code uses 384-dimensional sentence embeddings of agent role descriptions.
• Global versus local attention. Choosing global attention, as the paper states, gives a different model from the code's edge-masked attention. The paper's motivation (long-range dependencies) rests on global attention.
• Two losses. The preliminaries and the method describe different losses. Implement binary cross-entropy, which is what the method and the code use.
• Guidance is greedy and local. Each step picks the best of K candidates by proxy score. The appendix bound app. G.2 assumes an ε-accurate proxy over all topologies and a global maximiser. Neither holds for K=5 sampling, so the bound does not apply to the method as run.
• The proxy is trained on simulated outcomes of the same agent team. It has to be refit for each domain and team, and the paper says the seed data is still a requirement §7 app. A.
• Hidden costs. Training data needs one multi-agent run per baseline topology per sample. The paper reports about 4.0e5 tokens for GSM8K seed data and about 4.4e6 tokens per test run §5. Inference evaluates the proxy 250 times per query at K=5 with 50 steps tab. 11.
• Single runs, no spread. No seeds, repeats or confidence intervals are reported. Many gaps over MaAS and G-Designer are 1 to 2 points, so run-to-run variance could matter. Treat the ranking as unconfirmed.
• Text and table disagree on SVAMP. The text reports 91.30 for GTD on SVAMP §5.1, and the table reports 91.33 tab. 1.
• Average column errors. The Avg. column for Vanilla (81.75) and CoT (81.99) does not equal the mean of their rows. The rows average to about 81.08 and 81.32 tab. 1. The GTD average (85.74) is consistent with its row. The Avg. deltas shown for the other methods are computed from the stated averages, so they inherit the Vanilla and CoT errors.
• Ablation control. The "w/o guidance" row (88.42%) matches the K=1 entry in the candidate table (88.42%) tab. 2 tab. 12. They appear to be the same configuration, which the paper does not say.
• Robustness is one scenario in the main text. The main figure uses a single failed agent on GSM8K. Other failure modes are in the appendix at one benchmark only tab. 9.
• Scale claims are untested. The 1000-agent memory figure is from the memory scaling table only tab. 7. The benchmarks use 3 to 4 agents.
• Dataset licence. The paper lists MultiArith as "Unspecified" tab. 4. Do not redistribute that dataset.

Lineage

• Builds on: denoising diffusion §2 §3.2 (the paper cites Ho et al., 2020 and Song et al., 2021); discrete graph diffusion (DiGress, Vignac et al., 2023) §2; classifier-free guidance §3.3; graph attention networks §4.1; graph transformers §4.2.
• Compared against: Vanilla, chain-of-thought, self-consistency, LLM-Debate, LLM-Blender, MultiPersona, ComplexCoT, DyLAN, AgentVerse, MacNet, AutoAgents, GPTSwarm, ADAS, AgentSquare, AFlow, G-Designer and MaAS tab. 1 tab. 3.
• Superseded by: not known from wiki content.