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

AI summary

Overview

Research area: Large language model (LLM) multi-agent systems, specifically the automatic design of inter-agent communication topologies, combined with discrete graph diffusion generative models.

Technical level: Advanced. The paper assumes familiarity with diffusion models, graph neural networks, graph transformers, and multi-objective optimization.

Scope: The paper proposes Guided Topology Diffusion (GTD), a conditional discrete graph diffusion framework that generates task-specific LLM agent communication graphs by steering each denoising step with a lightweight learned proxy reward model under zeroth-order (gradient-free) optimization, and evaluates it on reasoning, coding, and knowledge benchmarks.

What This Paper Is About

Multi-agent LLM systems normally use fixed communication patterns (chain, star, fully connected), which waste tokens on simple tasks and bottleneck complex ones. The goal is to generate a communication topology automatically for each new task so that it jointly balances task accuracy, token cost, robustness, and sparsity. The authors reframe topology synthesis as an iterative, guided graph-generation process rather than a one-shot prediction or a post-hoc search.

Key Contributions

1. Problem level: A new conditional discrete graph diffusion framework, GTD, for dynamically generating multi-agent communication topologies conditioned on the task.
2. Algorithm level: A proxy-model-based zeroth-order optimization guidance algorithm that optimizes non-differentiable, high-cost external objectives inside the diffusion sampling loop.
3. Framework level: An end-to-end pipeline combining semantic feature encoding, conditional graph diffusion generation, and multidimensional protocol-based dynamic guidance.
4. Empirical validation: Demonstrations of higher accuracy, lower token consumption, and better failure robustness than a broad set of existing multi-agent and topology-search baselines, including generalization to an open-source backbone (Qwen-3-8B) and to LiveCodeBench.

Main Findings

• Overall accuracy ranking: GTD achieves the best average accuracy (85.74) in the main GPT-4o-mini comparison, above MaAS (84.49), G-Designer (84.41), AFlow (83.53), GPTSwarm (82.96), DyLAN (82.50), AgentVerse (82.27), LLM-Debate (82.79), and the Vanilla baseline (81.75).
• Per-benchmark state of the art: GTD reports 94.14 on GSM8K, 54.07 on MATH, 98.88 on MultiArith, and 91.33 on SVAMP (the body text states 91.30 for SVAMP), with 91.46 on HumanEval and 84.58 on MMLU. The paper states the strongest MATH baseline (MaAS, 51.82) is improved by over 2 absolute percentage points.
• Token efficiency: On GSM8K, GTD exceeds 94% accuracy using 4.8e+06 tokens, while the next best performer, G-Designer, requires 15% more tokens for lower accuracy and methods such as LLM-Debate use over five times the tokens. On MultiArith, GTD reaches nearly 99% accuracy with 8.4e+04 tokens; on SVAMP it is the only method to surpass 91% accuracy at 1.4e+05 tokens.
• Amortized setup cost: The one-time cost of generating training data is approximately 4.0 × 10^5 tokens, versus approximately 4.4 × 10^6 tokens per inference run saved, giving net efficiency gains.
• Robustness to agent failure: On GSM8K, GTD's accuracy dropped by only 0.3 percentage points (94.1% to 93.8%) under a simulated non-critical agent failure, while DyLAN dropped by nearly 13 points and a complete graph dropped by over 2 points.
• Guidance is the key driver: Removing proxy guidance reduces GSM8K accuracy from 94.14 to 88.42 (nearly 6 percentage points) and HumanEval from 91.43 to 87.19; replacing it with random guidance yields only 89.65 and 88.32 respectively.
• Data efficiency: The largest performance gains appear within the first 50 training samples, and the training dataset for the models was built from a minimal subset of only 50 samples.
• Team-size scaling: Accuracy scales effectively up to four agents and shows diminishing returns beyond that, which the authors cite as justification for using four agents.
• Cross-backbone generalization: With Qwen-3-8B, GTD achieves the highest average accuracy of 72.8% (GSM8K 91.7, MATH 61.5, MMLU 65.2), above G-Designer (72.1), MaAS (71.8), GPT Swarm (71.5), SC (CoT×5) (69.9), and Vanilla (CoT) (67.5).
• Harder coding benchmark: On LiveCodeBench (Pass@1), GTD reaches 30.8%, above MaAS (29.3%) and the Base Model (25.4%).
• Theoretical grounding: Appendix G states Theorem G.1 links the binary cross-entropy training objective to maximizing the true Evidence Lower Bound, and Theorem G.2 bounds the performance gap of the generated topology as a function of the surrogate's approximation error.

Methodology in Plain English

The method has two learned components and a guided sampling procedure.

First, the authors build a small dataset by running a multi-agent framework with a set of baseline topologies (chain, star, complete, layered, random, and others) on a handful of tasks, recording each topology's utility and communication cost. This becomes the training data.

Second, they train a surrogate reward model: a graph neural network with two Graph Attention (GAT) layers and a hidden dimension of 32, trained for 10 epochs with Adam at a learning rate of 1e-3 and batch size 16 to minimize mean squared error over predicted utility and cost. This surrogate is cheap to evaluate and stands in for the expensive real simulation.

Third, they train a conditional diffusion generator: a two-layer Graph Transformer with two attention heads, learning rate 1e-4, and 50 diffusion timesteps. The adjacency matrix is scaled from {0,1} to {-1,1}, Gaussian noise is added over the timesteps, and the network learns to predict the clean graph from the noisy one, conditioned on a task vector formed by concatenating a semantic embedding of the query with graph-state embeddings. It is trained only on the high-performing subset of the data using binary cross-entropy. Relative to single-step generators such as VAEs, diffusion was chosen so that a wrong edge can be corrected gradually.

At inference, the process starts from random noise and denoises step by step. At each timestep, the generator predicts a clean graph, K = 5 discrete candidate graphs are sampled from that prediction, the surrogate scores each candidate's utility and cost, and the candidate maximizing w_u · û − w_c · ĉ is chosen. That chosen graph replaces the raw prediction when computing the posterior for the next step. Because the surrogate evaluates discrete graphs, the objective is non-differentiable, so the authors use zeroth-order (gradient-free) optimization instead of gradient-based guidance.

Experimental setup: the backbone is GPT-4o-mini, with four MathSolver agents for GSM8K, MATH, MultiArith, and SVAMP; four CodeSolver agents for HumanEval; and three KnowledgeableAcademic agents for MMLU. Inference uses a batch size of 2. Appendix C reports a scalability analysis measuring GPU memory as the number of agents grows, stating 2.8 GB of memory for 5 agents (the provided text is truncated at that point).

Why This Matters

Impact on research. The work moves topology design from hand-crafted patterns and post-hoc search toward a generative, multi-step, multi-objective construction process. It shows that guidance can be injected during diffusion sampling using a cheap differentiable-free surrogate, which is applicable to other discrete graph-generation problems with expensive black-box objectives. The reported Pareto improvements in accuracy versus token use, and the graceful degradation under agent failure, give the multi-agent community evidence that cost and robustness can be optimized jointly with accuracy rather than traded off after the fact.

Real-world applications.

• Software development pipelines, where the paper notes richer collaboration networks of project managers, programmers, and testers are needed compared with a simple question-answering exchange.
• Cost-sensitive LLM deployments that must serve many queries under token budgets, since generated topologies are sparse and use fewer tokens.
• Code generation assistants (evaluated on HumanEval and LiveCodeBench), where agent coordination must be reliable.
• Mathematics and science tutoring or problem-solving services (GSM8K, MATH, MultiArith, SVAMP, MMLU), where tasks vary widely in difficulty and benefit from matching coordination structure to difficulty.

Industry relevance. Token consumption is a direct operating cost for any product built on LLM agents. A framework that reduces per-run token use by orders of magnitude relative to dense communication—while improving accuracy—is directly relevant to anyone serving agentic systems at scale. The approach also offers a template for routing/coordination policies in production agent platforms, and the paper notes potential energy-consumption and scientific-discovery benefits alongside acknowledged dual-use risks (for example, coordination of disinformation campaigns) and dependence on the bias profile of the seed dataset.

Future Directions

• Removing the seed-data dependency: The authors identify the pre-computed dataset of baseline topologies as a setup cost and name online active learning as a target for future work.
• Dynamic, time-varying topologies: The current topology is fixed before the task begins; the authors propose evolving it during a conversation if task requirements shift unexpectedly.
• Scaling to larger agent populations: The provided text states the framework is technically capable of scaling to larger swarms without memory bottlenecks (Appendix I), but that utility on current reasoning benchmarks diminishes after approximately four agents, leaving the question of when large teams genuinely pay off.
• Broader evaluation of the surrogate's fidelity: The paper reports that the surrogate's top-1 ranking matches the true best candidate in the majority of cases and that its error formally bounds the topology's performance gap; how these guarantees behave on more diverse or adversarial tasks is left open.

Target Audience

Researchers and engineers working on multi-agent LLM systems, agent orchestration, or graph generative models; practitioners who deploy agent pipelines and need to control token cost while preserving or improving accuracy; and readers interested in applying diffusion models with gradient-free guidance to discrete, black-box optimization problems. Readers without a background in diffusion models or graph neural networks will find the method sections demanding, though the motivation and experimental results are accessible.

Authors’ abstract

The efficiency of multi-agent systems driven by large language models (LLMs) largely hinges on their communication topology. However, designing an optimal topology is a non-trivial challenge, as it requires balancing competing objectives such as task performance, communication cost, and robustness. Existing frameworks often rely on static or hand-crafted topologies, which inherently fail to adapt to diverse task requirements, leading to either excessive token consumption for simple problems or performance bottlenecks for complex ones. To address this challenge, we introduce a novel generative framework called \textit{Guided Topology Diffusion (GTD)}. Inspired by conditional discrete graph diffusion models, GTD formulates topology synthesis as an iterative construction process. At each step, the generation is steered by a lightweight proxy model that predicts multi-objective rewards (e.g., accuracy, utility, cost), enabling real-time, gradient-free optimization towards task-adaptive topologies. This iterative, guided synthesis process distinguishes GTD from single-step generative frameworks, enabling it to better navigate complex design trade-offs. We validated GTD across multiple benchmarks, and experiments show that this framework can generate highly task-adaptive, sparse, and efficient communication topologies, significantly outperforming existing methods in LLM agent collaboration.