EvoTeam: evolving the team of agents rather than the agent itself

EvoTeam: Evolving the Agent Team Rather Than the Agent Itself

🔎 Agents are brilliant. Teams, however, remain mediocre.

Models have never been stronger in agentic mode. GPT-5.5 peaks at 98.2 on the reference agentic index, Gemini 3 Pro Deep Think follows at 95.4, and Claude Opus 4.7 (Adaptive) rounds out the podium at 94.3. And yet, multi-agent systems keep failing at almost trivial things: two agents redoing the same work, context drifting apart between virtual colleagues, a task falling through the cracks between roles.

On October 29, 2026, a team affiliated with Jilin University published a paper on arXiv that attacks this wall from an unusual angle. EvoTeam does not seek to make each agent better: it evolves the team itself — its roles, its communication topology, its interaction rules — drawing on execution experience, with a library of reusable teams as a bonus.

Why now? Because the race for individual capabilities is yielding diminishing returns on real tasks, while coordination failures remain the leading cause of failure in multi-agent systems. Prompt and workflow optimization has set the stage. No one had yet systematized the evolution of the org chart. Now it's done — and the code is open source.

The Essentials

• The thesis: improving each agent individually does not produce the best team. The real lever is the organization: roles, communication topology, interaction rules.
• The method: EvoTeam treats the organization as an evolving genome, selected by execution experience — success, cost, quality of exchanges.
• The capitalization: a library of teams stores the winning organizations and readapts them to new tasks, with roughly 40% of evolution budget saved on similar tasks (figures from the paper).
• The results: +4.6 to +8.6 points on four benchmarks (GAIA, SWE-bench Verified, WebArena, MATH-500) compared to a frozen team — and, above all, better than teams whose agents were individually optimized.
• The limitations: cost of evolution, risk of overfitting on the benchmarks, cross-model portability still to be confirmed.

Recommended tools

To experiment with EvoTeam or build comparable agent teams, here is the minimal toolbox. EvoTeam is the only tool here that touches organization; the others are for execution.

The bottleneck is the organization, not the agents' IQ

If your multi-agent systems fail, the culprit is almost never the model. It's the way agents talk to each other.

Individual capabilities are progressing at a dizzying pace. According to METR (2025), the horizon of tasks that AIs manage to complete doubles roughly every seven months. At this rate, this year's "smartest model in the world" will be commonplace next year.

Yet failures aren't moving at the same pace. A landmark study conducted by Berkeley researchers and their partners ("Why Do Multi-Agent LLM Systems Fail?", 2025) sifted through hundreds of execution traces of multi-agent systems and derived a taxonomy of 14 failure modes. The largest category? Inter-agent misalignment, accounting for over 40% of cases. Not the model's reasoning. The exchanges between models.

Cognition made a forceful statement back in June 2025 with its manifesto "Don't Build Multi-Agents": when context fragments across agents, implicit decisions get lost and the team silently self-destructs. Anthropic, the same year, quantified the other side of the problem: its multi-agent research system consumes roughly 15 times more tokens than a simple conversation. Coordination is expensive — when it works.

Existing optimization targets the wrong thing

Look at where the progress in agent engineering has come from over the past three years: OPRO (DeepMind, 2023) optimizes prompts, DSPy industrializes this approach, GEPA (Berkeley/Databricks, 2025) evolves prompts through reflection on failures, AFlow (ICLR 2025) searches for the best workflow, ADAS (CMU, 2024) generates agent code. All of this is useful. All of it optimizes the unit or the path — never the organization.

I had already made this observation in our dossier on multi-agent collaboration: coordination is the hidden cost of the field. EvoTeam is the first systematic answer to this specific cost.

What EvoTeam does differently: evolving the org chart

EvoTeam treats an agent team's organization as an evolving organism, and execution experience as the selection signal.

Concretely, a team's "genome" at EvoTeam describes: the number of agents, their roles, the communication topology (hierarchical, peer-to-peer, debate, pipeline), the exchange protocols — who talks to whom, when, in what format, who arbitrates disagreements — and the assignment of models to each role.

The evolution loop is classic in form, original in its object. You start from a population of organizations, run each team on a batch of tasks, score them (success, token cost, latency, output quality), then selection, mutation, and crossover produce the next generation. Nothing magical. But the level of abstraction changes everything.

The detail that sets EvoTeam apart from simple architecture search: the signal is not limited to success/failure. Execution traces are exploited in fine detail. A verifier that lets errors slip through triggers a protocol mutation — for example, a cross-review loop between peers. A planner saturated with messages sees its prerogatives redistributed. The team learns from its communication dysfunctions, not just from its task failures.

Three levers, one signal

• Structure: create, merge, or remove roles. Evolution can shrink a team just as much as it can grow it.
• Protocol: the interaction rules — turn sequencing, output formats, validation mechanisms, disagreement handling.
• Assignment: which model for which role. A demanding planner justifies a GPT-5.5; a high-volume execution role is fine with a self-hosted option like Kimi K2.6 (88.1) or GLM-5 Reasoning (82).

These three levers mutate under the same selection pressure: real execution experience, not an engineer's intuition.

The team library: the real innovation

In my view, this is where the paper goes beyond being an academic exercise. Every high-performing organization is archived in a library with its metadata: task type, cost profile, model configuration, protocols. When facing a new task, the system retrieves the most similar teams and starts evolution from them — a warm start that, according to the authors, saves roughly 40% of the evolution budget on tasks close to those already encountered.

Think of a sports team: recruiting eleven talented players guarantees nothing if the positioning is wrong. EvoTeam doesn't look for better players. It looks for the positioning, then preserves it in a playbook.

This is the shift from a project logic to an asset logic. Your agent organizations become an asset that appreciates with each run, instead of being rebuilt by hand for every project.

The Numbers: Real Gains, to Be Read with the Footnotes

Across the four benchmarks evaluated, EvoTeam gains 4.6 to 8.6 points over a frozen team — and above all, it dominates teams whose every agent was individually optimized.

Here are the main results reported by the paper (validation subsets, the authors' numbers):

The reading that matters isn't the right-hand column; it's the gap between the last two. Optimizing each member's prompts yields about 2 points. Optimizing the organization yields 5 to 9. That, quantified, is the paper's entire argument: the best team is not the sum of the best agents.

Two honest caveats. First, the gains are concentrated on tasks requiring strong coordination — GAIA, whose historic gap between humans (~92%) and tooled agents (~30% in 2023) struck the community, and WebArena. On MATH-500, which is more linear, the gap narrows. Makes sense: fewer interactions, fewer organizational dividends.

Second, these numbers are self-reported by the authors, on validation subsets, with non-negligible variance across runs. The code and configurations are published, which enables replication — that's the bare minimum. But treat GAIA's +8.6 points as a trend, not a contract.

The Side Effect Nobody Expected: Evolution Slims Down

The paper's most interesting result isn't a score. On MATH-500, the majority of evolution campaigns reduced team size — roles merged, intermediaries removed — for a roughly one-third drop in execution cost at constant quality. Evolution doesn't grow teams: it refines them.

And the converging organizations resemble what humans took decades to invent: a dedicated, independent verifier; structured debate before any costly commitment; selective shared memory rather than a single saturated channel. When evolution rediscovers good managerial practices, that's a good sign for the method.

It's not an isolated result either. We had documented a similar signal with five Qwen3.8-27B orchestrated via a shared folder beating Claude Fable 5: a simple, disciplined organization can compensate for inferior model raw material. EvoTeam systematizes that intuition.

Facing ADAS, AFlow, or GEPA: what "organization" really changes

The difference is not cosmetic. ADAS and AFlow optimize what agents do; EvoTeam optimizes who talks to whom, when, and under what authority.

This table deserves a sideways reading: all of these approaches are complementary, not competing. Nothing prevents you from evolving a team whose members are themselves optimized by DSPy. EvoTeam operates one level above — and that is precisely the level that was empty.

The library also changes the nature of the investment. The artifacts produced by ADAS or AFlow essentially serve the task for which they were searched. An evolved organization, on the other hand, can be capitalized, versioned, and re-adapted. My bet: within eighteen months, serious frameworks will expose a versionable "organization" layer, exactly the way we version prompts today. Those who build this layer early will gain a head start.

The limits: what the paper handles less well

EvoTeam solves neither the cost of evolution, nor team portability across models, nor the thorny question of accountability.

Cost, first. The main experiment relies on roughly 1,500 executions per benchmark. With premium models, the bill runs into hundreds or even thousands of dollars depending on task length — remember the 15× token ratio documented by Anthropic in 2025. With self-hosted models, the bill becomes GPU time, which is more digestible but not free.

Overfitting, next. Organizations evolve on the distributions of their benchmarks. The paper demonstrates transfer from the library to nearby tasks, not to radically different domains. The library is not — yet — a universal solution, and the authors don't claim otherwise.

Model dependence, finally. An organization calibrated with Claude Opus 4.7 (Adaptive) can degrade with Gemini 3.1 Pro: the fine-grained communication protocols are sensitive to the output style of the models. Every configuration change requires revalidation. Promising, not settled.

Then there's the governance blind spot, and it's not theoretical. When a team rewrites its own interaction rules over generations, who validated the emergent protocol? How do you audit it after an incident? The American legislative debate is heading straight toward this question: the AI Agent Accountability Act, championed by Hawley and Murphy, seeks to make developers pay when their agents cause damage. An evolving organization blurs the chain of responsibility even further. If you deploy this kind of system in production, require human review of any evolved protocol before exposing it to the real world.

Integrating EvoTeam into a real stack (without breaking the bank)

Don't evolve everything. Evolve where coordination is expensive, and freeze the rest.

The sequence I recommend, after reading the paper and its configurations:

1. Build your evaluation harness first. Without a reliable metric, evolution optimizes noise. That's 80% of the work, and it's the part nobody wants to do.
2. Measure a frozen team as your baseline. The canonical "orchestrator + three specialists" pattern does the job.
3. Cap the evolution budget: number of runs, tokens, dollars. Without a guardrail, an evolutionary loop can burn through an API budget in a single weekend.
4. Version-control your team library in git, with cost and domain metadata. That's your asset.
5. Revalidate on every model change, however minor.

As for model assignment, the cost-effective strategy is obvious: reserve GPT-5.5 or Gemini 3 Pro Deep Think for planning and arbitration roles, and hand bulk execution to self-hosted models like Kimi K2.6 or GLM-5 Reasoning. Our comparison of the best LLMs for AI agents details these trade-offs. For a 100% local team, Ollama does the job — we have a complete guide on open source AI agents locally with Ollama — and a dedicated VPS is more than enough to get started; Hostinger offers VPS plans from around $5/month (November 2026, verify on hostinger.com).

One last point the paper glosses over: an evolved organization is worthless without rich context to pass along. Memory and persistent user knowledge remain your responsibility — our article on OpenHuman, the open source AI agent that knows your life before you even talk to it explores this aspect.

To launch a first campaign:

git clone https://github.com/DEEP-JLU/EvoTeam
cd EvoTeam
pip install -e .
python evoteam/run.py --benchmark gaia --population 12 --generations 8 \
  --budget-tokens 5000000 --library ./teams

And if you're starting from scratch, begin with our guide on creating an AI agent: there's no point evolving a team before you know how to get a single agent to execute.

❌ Common Mistakes

Three pitfalls recur in every multi-agent deployment — EvoTeam fixes one of them, not the others.

Mistake 1: Optimizing agents when the problem is organizational

You spend weeks fine-tuning prompts while your agents duplicate each other's work and contradict one another. The solution: audit inter-agent failures first — the 2025 MAST taxonomy serves as a checklist — and only touch the prompts once the structure is fixed.

Mistake 2: Running an evolution without a budget or guardrails

A poorly bounded evolution loop consumes tokens endlessly and can degrade teams by over-optimizing a noisy metric. The solution: cap runs and costs, evolve early generations on cheap models, and reserve premium models only for the finalists.

Mistake 3: Copying an evolved team without revalidating it

A team that shines on GAIA can collapse on your business domain. Treat every library entry as a hypothesis, not a truth: systematically revalidate on your own evaluation set before any deployment.

❓ FAQ

Short answers to the most common questions about EvoTeam.

Does EvoTeam replace AutoGen or CrewAI?

No. EvoTeam designs the organization, and the frameworks execute it. The paper itself relies on existing orchestration building blocks to instantiate the teams. Count on EvoTeam to decide the structure, and on AutoGen, CrewAI, or LangGraph for execution: the two layers are complementary.

How much does an evolution campaign cost?

The paper's main experiment involves roughly 1,500 runs per benchmark. With premium models, expect several hundred to a few thousand dollars depending on task length; in self-hosted setups, it's GPU time. The library cuts the budget of subsequent campaigns on similar tasks by about 40%.

Can you evolve a team of local open source models?

Yes, and it's the most economically sensible scenario: evolution requires many runs, hence low per-call costs. Kimi K2.6 (88.1) or GLM-5 Reasoning (82) self-hosted can cover most roles, with a premium model reserved only for final evaluations.

Is the team library transferable from one model to another?

Partially. The organizations — roles and topologies — transfer better than the fine-grained protocols, which are sensitive to each model's output style. The paper recommends revalidation after any configuration change. Treat every entry in the library as tied to a specific combination of models.

Do you need a research lab to use it?

No, but you do need an engineering foundation: a reliable evaluation harness, full traceability, and controlled budget. The code is open source, and getting started takes an evening for anyone who has already orchestrated agents. The hard part isn't the evolution algorithm — it's the evaluation.

✅ Conclusion

The next breakthrough in AI agents may come less from a better model than from a better organization — EvoTeam provides the first systematic demonstration of this, library of teams included. To choose the models that will make up your teams, start with our comparison of the best autonomous AI agents.