🤖 machine learning

EvoMAS: Evolutionary Generation of Multi-Agent Systems

EvoMAS introduces an evolutionary framework that automatically generates robust and high-performing multi-agent systems by iteratively refining structured configurations through feedback-conditioned mutation and crossover, significantly outperforming both human-designed and prior automatic methods across diverse reasoning, software engineering, and tool-use benchmarks.

Original authors: Yuntong Hu, Yuting Zhang, Matthew Trager, Yi Zhang, Shuo Yang, Wei Xia, Stefano Soatto

Published 2026-05-28

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yuntong Hu, Yuting Zhang, Matthew Trager, Yi Zhang, Shuo Yang, Wei Xia, Stefano Soatto

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 you need to solve a very complex problem, like planning a massive international trip, debugging a broken piece of software, or solving a tricky math puzzle. You could ask one very smart person (a single AI) to do it all. But often, that one person gets overwhelmed, makes mistakes, or misses a crucial detail.

A better approach is to hire a team of specialists. One person plans the route, another checks the budget, a third books the hotels, and a fourth double-checks the itinerary. This is called a Multi-Agent System (MAS).

The problem? Designing the perfect team is incredibly hard. You have to decide:

Who is on the team?
What are their specific jobs?
How do they talk to each other?
Which "brain" (AI model) does each person use?

Usually, humans have to manually design these teams, which is slow, expensive, and often results in teams that don't work well together.

Enter EvoMAS: The "Evolutionary Team Builder"

The paper introduces EvoMAS (Evolutionary Generation of Multi-Agent Systems). Think of EvoMAS not as a designer, but as a naturalist running a survival of the fittest experiment for teams.

Here is how it works, using a simple analogy:

1. The Starting Zoo (The Pool)

Imagine you have a zoo filled with different team structures. Some are "Debate Clubs" where everyone argues to find the truth. Others are "Assembly Lines" where work passes from person to person. Some are "Star Shapes" where one boss gives orders to many workers.

The Innovation: Instead of writing code from scratch, EvoMAS treats these team structures as configurations (like a recipe card or a blueprint). This makes them easy to tweak without breaking the whole system.

2. The Trial Run (Execution)

When you give EvoMAS a specific task (e.g., "Fix this bug in the code"), it picks a few teams from the zoo to try it out.

They attempt the task.
A "Judge" (another AI) watches them and scores them: Did they solve it? Did they make mistakes? Did they take too long?

3. The Evolution (Mutation and Crossover)

This is the magic part. EvoMAS doesn't just pick the winner and stop. It uses the "Judge's" feedback to evolve the teams, just like nature evolves animals.

Mutation (The Tweak): If a team failed because the "Math Expert" was too slow, EvoMAS might swap their brain for a faster one, or tell them to write their steps more clearly. It changes one thing at a time to see if it helps.
Crossover (The Mix-and-Match): If Team A is great at planning but bad at checking, and Team B is great at checking but bad at planning, EvoMAS creates a hybrid child team. It takes Team A's structure but swaps in Team B's checking experts.
The Loop: This happens over and over. The "bad" teams are discarded, and the "good" teams are kept, tweaked, and mixed again.

4. The Memory (Learning from the Past)

EvoMAS has a notebook. If it discovers that "Teams with a dedicated verifier always solve math problems better," it writes that down. Next time it faces a math problem, it doesn't start from scratch; it remembers that trick and uses it immediately.

Why is this better than what we had before?

Old Way (Code Generation): Previous methods tried to write the entire team's software code from scratch. This is like asking a chef to invent a new recipe, a new kitchen, and a new stove all at once. It often leads to "syntax errors" (the code breaks) or teams that are too rigid.
EvoMAS Way (Configuration): EvoMAS changes the blueprint (the configuration), not the raw code. It's like rearranging the furniture in a house rather than rebuilding the walls. This makes the teams much more reliable and less likely to crash.
Better than Humans: The paper shows that EvoMAS consistently creates teams that perform better than teams designed by human experts. It found a "sweet spot" in how to organize the team that humans hadn't thought of.

The Results in Plain English

The researchers tested EvoMAS on three very different types of challenges:

Reasoning: Solving logic puzzles and math problems.
Software Engineering: Fixing real bugs in computer code.
Tool Use: Using digital tools like calendars, email, and data charts.

The Outcome:

EvoMAS teams solved these problems more accurately than single AIs, human-designed teams, and other automatic methods.
They were more reliable. While other methods often crashed or failed to run, EvoMAS's teams almost always finished the job (over 96% success rate).
It even beat the top scores on a famous software engineering leaderboard (SWE-Bench) when using the latest AI models.

The Big Takeaway

EvoMAS proves that instead of trying to manually design the perfect AI team, we can let an AI evolve the perfect team for the specific job at hand. It's like having a coach that watches your team play, realizes who is playing out of position, swaps the players, changes the strategy, and keeps doing this until the team is unbeatable.

The paper claims this is a new, robust way to build AI systems that are flexible, reliable, and smarter than anything we could design by hand.

Technical Summary: EvoMAS – Evolutionary Generation of Multi-Agent Systems

1. Problem Statement

Large Language Model (LLM)-based Multi-Agent Systems (MAS) demonstrate significant potential for complex reasoning, planning, and tool-augmented tasks. However, designing effective MAS architectures remains labor-intensive, brittle, and difficult to generalize. Existing automatic generation methods face a fundamental trade-off between expressiveness and reliability:

Code Generation Approaches: Methods like ADAS and MAS-GPT treat MAS design as open-ended code search or direct code synthesis. While expressive, these often suffer from executability failures, runtime exceptions, and brittle behaviors due to syntax errors and the complexity of generating valid multi-agent programs in a single pass.
Rigid Template Approaches: Methods like AutoAgents and EvoAgent constrain agent structures to improve reliability but limit adaptability and expressiveness. Furthermore, approaches like EvoAgent typically evolve individual agents rather than treating the multi-agent system as a unified optimization object, and they lack mechanisms for cross-query experience transfer.

The core challenge is to efficiently explore the large, combinatorial space of MAS configurations while leveraging execution feedback to guide structured updates, balancing the exploration of new designs with the reuse of successful patterns.

2. Methodology: EvoMAS

The authors propose EvoMAS (Evolutionary Generation of Multi-Agent Systems), a framework that formulates MAS generation as structured configuration generation rather than code synthesis. EvoMAS operates within a bounded, interpretable configuration space, evolving collaborative MAS configurations via selection, mutation, and crossover.

2.1. Configuration Representation

A MAS configuration $C$ is defined as a tuple $(G, \{A_i\}, V_{in}, V_{out})$ :

Graph ( $G$ ): An acyclic communication graph defining the topology (who communicates with whom).
Agents ( $A_i$ ): Each agent is defined by a backbone model ( $b_i$ ), a system prompt template ( $p_i$ ), and a tool set ( $\Gamma_i$ ).
Execution: A lightweight runtime interpreter decouples system structure from execution logic, instantiating agents and managing communication based on the declarative configuration.

2.2. Evolutionary Process

EvoMAS employs an LLM-driven evolutionary search over a candidate pool, using execution feedback as learning signals. The process for a given task $q$ involves:

Selection: Initial configurations are retrieved from a pool seeded with human-designed MASs (e.g., Peer Review, Majority Vote, MetaGPT) based on task relevance and metadata.
Evolutionary Operators: The system iteratively refines candidates using two operators conditioned on execution traces and an experience memory:
- Mutation: Modifies exactly one component type (prompts, model assignments, tool lists, or topology) of a single parent to address specific performance bottlenecks identified in the execution trace.
- Crossover: Recombines two parents by inheriting the communication topology from one parent and recombining agent-level attributes (prompts, models, tools) from both.
Evaluation: Configurations are evaluated using an LLM-as-a-judge reward function that balances task performance (correctness, completeness) against computational cost (tokens and latency).
Pool and Memory Updates: High-reward configurations are added to the pool for future reuse. Evolution traces are summarized into compact representations (e.g., "prompt refinement for output formatting improved accuracy") and stored in an experience memory to guide future searches via similarity-based retrieval.

2.3. Key Design Principles

Structured vs. Code: By generating structured configurations (YAML) rather than executable code, EvoMAS avoids syntax errors and ensures high runtime robustness.
Joint Evolution: Unlike prior work that optimizes prompts or topology separately, EvoMAS jointly evolves all components (topology, prompts, models, tools) as a unified system.
Test-Time Compute Scaling: EvoMAS adapts compute distribution across the multi-agent system through configuration search, rather than allocating more compute to a single agent.

3. Key Contributions

A Configuration-Based Paradigm: Reformulating MAS construction as structured text generation, enabling robust and expressive exploration of the MAS design space without the brittleness of code generation.
The EvoMAS Framework: An LLM-driven evolutionary framework that maintains a pool of candidate configurations seeded from human-designed systems and iteratively refines them via execution-guided mutation, crossover, and memory-based reuse.
Comprehensive Benchmarking: Demonstrating superior task performance across reasoning, coding, and tool-calling domains with higher execution success rates compared to both human-designed MAS and prior automatic generation methods.

4. Experimental Results

EvoMAS was evaluated on five benchmarks: BBEH (reasoning), WorkBench (tool-use), and SWE-Bench-Lite/Verified (software engineering).

Performance Gains: EvoMAS consistently outperformed baselines.
- On BBEH, it achieved 58.7% accuracy (with automatic LLM selection), surpassing the best EvoAgent result by +10.5 points and the best per-LLM configuration by +5.9 points.
- On WorkBench, it reached 48.9%, exceeding the best per-LLM result by +4.4 points.
- On SWE-Bench-Verified, EvoMAS achieved 63.8% resolution rate, outperforming the best single-LLM configuration by +3.4 points and the best predefined MAS (MetaGPT) by a significant margin. With Claude-4.5-Sonnet, it reached 79.1%, matching the top of the public leaderboard.
Robustness and Executability: EvoMAS achieved execution rates exceeding 96% across all benchmarks (e.g., 98.9% on BBEH), significantly outperforming code-generation methods like MAS-GPT (71.5% on BBEH, 1.2% on SWE-Bench-Lite).
Scaling Behavior: Unlike single-agent or fixed-topology methods that plateau or degrade with increased token budgets, EvoMAS continues to improve performance as compute increases, discovering more efficient coordination patterns.
Generalization: The framework generalizes to mathematical reasoning (AIME 2024–2025), achieving 56.7% accuracy, outperforming predefined baselines.

5. Significance and Claims

The paper claims that EvoMAS represents a shift from manual, task-specific MAS engineering to automated, adaptive system synthesis. Its significance lies in:

Structural Optimization: The performance gains are structural, arising from the discovery of effective coordination patterns (e.g., emergent roles like "decomposer" or "verifier" and novel topologies) rather than merely scaling compute or relying on larger models.
Reliability: By decoupling structure from execution logic via configuration, EvoMAS solves the reliability issues inherent in code-generation approaches, making automated MAS generation viable for real-world applications.
Test-Time Adaptation: It provides a state-based learning paradigm where improvements accumulate through configuration updates and execution experience, offering a distinct alternative to gradient-based fine-tuning.
Generalizability: The framework is agent-agnostic and supports heterogeneous model assignments, allowing it to leverage the strengths of different LLMs for specific roles within a single system.

The authors conclude that EvoMAS effectively lowers the barrier to specialized agent development, though they note that future work should address adversarial coordination and further reduce evolution costs.