💻 computer science

MANTA: Multi-Agent Network Topology Adaptation for Self-Evolving Multi-Agent Systems

MANTA is a novel framework that enables multi-agent systems to self-evolve their communication network topology at inference time by dynamically adapting agent roles, links, and workflows based on collaboration traces, thereby achieving superior performance across diverse complex tasks compared to static or offline-optimized baselines.

Original authors: Mao-xun Huang, Jerry Wang, Yi-Cheng Lai, Zhengxin Zhang, Claire Cardie, Hen-Hsen Huang

Published 2026-07-31

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Mao-xun Huang, Jerry Wang, Yi-Cheng Lai, Zhengxin Zhang, Claire Cardie, Hen-Hsen Huang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a world where solving a giant, messy puzzle isn't just about having one super-smart brain, but about getting a whole team of specialists to work together. This is the heart of Multi-Agent Systems, a hot topic in artificial intelligence where multiple AI "agents" (think of them as digital workers) team up to tackle complex problems. Instead of one robot trying to do everything, you have a planner, a researcher, a critic, and a checker, all chatting and swapping notes. For a long time, scientists thought the best way to organize this team was to draw a fixed map before the game even started: "You talk to you, you talk to her, and you never talk to him." It's like building a factory with a rigid assembly line that can't change, no matter what kind of product is rolling down the belt. But what if the factory could look at a broken machine and instantly redesign the assembly line on the fly? That's the big question this paper asks: Can a team of AI agents reorganize its own communication structure while it's working, just like a sports team might switch from a defensive formation to an offensive one when the game gets tough?

Enter MANTA (Multi-Agent Network Topology Adaptation), a new framework that lets AI teams "self-evolve" their communication map while they are solving a task. Think of MANTA not as a single robot, but as a dynamic conductor who watches an orchestra play. If the conductor hears a violinist struggling to keep up with the tempo, they don't just tell the violinist to try harder; they might instantly rearrange the seating chart, add a second violinist to that section, or change who is listening to whom. In the paper, the authors show that MANTA starts with a plan based on past experience, but as the agents work, a special "auditor" watches the conversation for trouble signs—like a team agreeing too quickly without checking facts, or one worker getting overloaded with too many tasks. When trouble is spotted, MANTA makes a small, safe change to the team's structure: it might split a busy worker into a small sub-team, add a new "critic" to double-check answers, or change the order in which agents speak.

The results are quite promising. The researchers tested MANTA on five different types of challenges, ranging from searching for information on the web to solving math problems and planning complex workflows. Across the board, MANTA achieved an average score of 74.0, beating the next best method by 5.8 percentage points. It was particularly good at a planning challenge called PlanCraft, where it scored the highest. The paper suggests that this improvement comes from the system's ability to fix its own organizational glitches in real-time, rather than just trying harder with the same broken setup. Interestingly, the system didn't just get better; it also used fewer "tokens" (the digital currency of AI thinking) than many other complex multi-agent systems, proving that a flexible structure can be more efficient than a rigid one.

However, the paper is careful to note what MANTA is not. It doesn't change the actual "brain" or weights of the AI models themselves; the agents' intelligence stays the same. Instead, it only changes how they are organized. The authors also found that while the system is great at fixing structural problems (like a missing check or a duplicated effort), it isn't a magic wand for every error. If the agents agree on a wrong answer because they all missed the same clue, the system might not catch it, because the "process" looked clean even if the result was wrong. But for the specific problem of keeping a team organized and adaptable, MANTA suggests that letting the structure evolve during the work is a powerful way to get better results without needing to retrain the AI from scratch. It's a step toward AI systems that don't just think, but also know how to reorganize their own teamwork when things go sideways.

Technical Summary: MANTA (Multi-Agent Network Topology Adaptation)

Problem Statement

Current large language model (LLM)-based multi-agent systems improve complex problem-solving through task decomposition and collaboration. However, existing frameworks typically treat the communication topology—the structure defining who communicates with whom, how information is routed, and where validation occurs—as a fixed design choice or an offline optimization target. These structures are determined before execution and remain static, even when the collaboration process encounters failures such as overloaded branches, premature consensus, or missing validation steps.

The central question addressed by this work is: Can a multi-agent system improve its communication topology while solving each individual task? Unlike prior approaches that rely on training, offline search, or pre-execution optimization, this requires instance-conditioned planning, test-time topology mutation based on intermediate collaboration traces, and the transfer of topology experience without updating model weights.

Methodology: MANTA Framework

MANTA (Multi-Agent Network Topology Adaptation) is a framework that enables communication structures to self-evolve at inference time. It operates through a nested orchestration loop combining LLM-based meta-agents with deterministic code.

1. System Architecture

The system consists of two layers:

Target Multi-Agent System: Executes the task through reasoning, tool calls, and message exchange.
Orchestration Layer: Manages the topology and execution flow without solving the task itself. It comprises three LLM components and deterministic logic:
- Topology Planner: Designs the initial team structure (interaction pattern, agent count, roles) based on the task and accumulated experience.
- Trace Auditor: Monitors the collaboration trace after each turn, flagging process anomalies (e.g., tool errors, premature consensus, missing validation) rather than judging answer correctness.
- Skill Reflector: Periodically rewrites a long-term playbook by distilling lessons from process signals across multiple runs.
- Controller & Deterministic Code: Validates topologies, routes messages, enforces visibility policies, and executes bounded structural repairs.

2. Topology Representation and Mutation

A topology is a versioned specification defining agent roles (coordinator, worker, verifier, etc.), interaction patterns (star, chain, debate, voting), and context policies (information visibility).

Initial Planning: The Planner generates a task-conditioned topology.
Execution & Auditing: Agents execute a turn. The Auditor scans structured artifacts for "process flags" (e.g., tool_error_cascade, premature_consensus, duplicate_state_mutation).
Bounded Repair: If a repairable flag is detected, the Controller permits one bounded mutation per run. The Planner proposes a mutation (e.g., expanding an overloaded worker into a subgroup, adding a verifier, rewiring edges, or changing execution order). Deterministic code validates the new structure before applying it.

3. Memory Mechanisms

MANTA utilizes a two-horizon playbook system:

Short-term Playbook: Logs the topology, audit flags, and repair decisions within the current run to inform immediate repair choices.
Long-term Playbook: Stores general principles and lessons learned across runs (e.g., "voting is preferred over debate for tool-less reasoning"). This is updated by the Skill Reflector every $N$ runs using only process signals (clean vs. flagged traces), never accessing ground-truth benchmark answers.

Key Contributions

A New Problem Formulation: The paper formalizes topology-level self-improvement, arguing that communication structure should be a dynamic variable adaptable during execution, not a static design choice.
The MANTA Method: A framework that plans a task-conditioned topology, audits the collaboration process, and applies targeted structural mutations when failures are detected. It learns from each task to improve future topology selection without weight updates.
Empirical Evidence: Demonstrations across five benchmarks showing that MANTA outperforms static multi-agent topologies, single-agent methods, and automated workflow-design baselines. Case studies illustrate specific recoveries from failures like overloaded branches and missing checks.

Experimental Results

MANTA was evaluated on five benchmarks spanning information seeking (BrowseComp), tool use (StableToolBench), planning (PlanCraft), workflow execution (WorkBench), and mathematical reasoning (MATH), using Gemma 4 as the backbone.

Performance: MANTA achieved the highest average score of 74.0, outperforming the strongest baseline (ADAS) by 5.8 percentage points. It achieved the best result on PlanCraft.
Efficiency: MANTA used the fewest tokens among evaluated multi-agent systems. Its meta-level operations accounted for only ~12% of the inference budget.
Ablation Studies:
- Initial Planning: Replacing task-conditioned planning with a fixed topology caused the largest performance drop (from 71.7% to 57.5%), highlighting the importance of initial structure selection.
- Repair: Removing topology repair reduced performance to 60.8%.
- Memory: Removing the long-term playbook resulted in a smaller but consistent drop, indicating that cross-run learning provides additional value.
Mutation Budget: Performance improved as the mutation budget increased from 0 to 3, with the first mutation providing the largest gain.
Transferability: The long-term playbook successfully transferred knowledge across domains (e.g., from PlanCraft to WorkBench), yielding positive gains, whereas transferring structures from other adaptive baselines resulted in negative or neutral effects.

Significance and Claims

The paper claims that inference-time self-improvement can extend to the architecture of collaboration itself.

Distinct Layer of Adaptation: MANTA positions topology as a distinct level of self-improvement (Level 6 in their hierarchy), separate from adapting outputs, prompts, reasoning traces, or agent weights.
Structural vs. Quantitative: The results suggest that effective adaptation often involves rewiring communication, changing execution order, or adding validation rather than simply increasing the number of agents. For instance, repairs often involved serializing parallel actions or inserting a critic, rather than adding new solvers.
Process-Oriented Learning: The system demonstrates that a multi-agent system can learn to reorganize its collaboration processes in response to emerging failures using only process signals, without requiring ground-truth labels or offline search.

The authors conclude that treating topology as an execution-time object of self-improvement allows agent systems to dynamically adapt their collaboration processes, offering a path toward more robust and flexible multi-agent systems.