← All articles.md

Agent swarms explained: how teams of AI agents split up one task, and how we know if it works

November 15, 2026 · 15 min read

Ask one AI agent to research a hard question and it reads one page at a time, in one long conversation, until its memory fills up. Ask a team of agents and a lead can send five of them out at once, each with a clean slate, and merge what they bring back. That is the promise of an agent swarm: many AI agents coordinating to finish one task faster or better than one agent could alone.

The idea has gone from a 2023 research curiosity to some of the most-starred repositories on GitHub. It has also collected a long list of papers showing where it fails. This post maps the field as of November 2026: the main ways to wire agents together, the papers each idea came from, the open-source frameworks you can use today, and how researchers measure whether a swarm is actually better than one agent.

The short version: a swarm is a way to spend more computing in parallel. It pays off on work that splits into independent pieces, and it can make things worse on work where every step depends on the last.

What is an agent swarm?

An agent is a language model running in a loop: it reads the task, picks a tool (search the web, run code, edit a file), looks at the result and decides what to do next, until it judges the task done.

A multi-agent system puts several of these loops to work on the same task. Each agent usually gets its own instructions, often a role ("you are the tester"), its own tools and its own context window (the text the model can see at once). The agents pass work and messages between them through some agreed channel.

Swarm is the popular word for the same thing, borrowed from ants and bees. In biology a swarm has no leader: each insect follows simple local rules and the colony's behaviour emerges. Most AI "swarms" are less like ants and more like a small company, with a manager, specialists and a process. A few research systems do copy the insect version, and we will get to them.

The five ways to wire a team of agents

Almost every framework is one of five wirings, or a mix of them.

Argo diagram of five coordination patterns: assembly line, debate and vote, lead and workers, handoffs, shared board
Almost every agent swarm framework is one of these five wirings, or a mix of them. Argo diagram.
  • Assembly line. Each agent has a role and passes a document to the next: product manager to architect to project manager to engineer. MetaGPT calls this encoding "Standardized Operating Procedures" into prompts. The fixed order stops one agent's mistake from snowballing through a free-form chat.
  • Debate and vote. Several copies of the same model answer the same question, read each other's answers, argue for a few rounds and then agree or vote. Nobody has a special role; the gain comes from redundancy.
  • Lead and workers. An orchestrator plans, spawns workers in parallel, gives each a fresh context window and merges their short reports. This is how Anthropic's Research feature and Microsoft's Magentic-One work.
  • Handoffs. Only one agent is active at a time. When a request fits a peer better ("this is a refund question"), the active agent hands the whole conversation over. OpenAI's experimental Swarm library is the best-known example.
  • Shared board. Agents never message each other directly. They read from and write to a shared store, the way ants coordinate by leaving trails. Computer scientists call it a blackboard; biologists call the ant version stigmergy.

Where the ideas came from

The research came in four waves, roughly one per year.

Argo timeline from 2023 to 2026: roles, then scaling and wiring, then measuring failures, then shared boards and trained swarms
Four years of multi-agent research, one idea per year. Argo diagram; papers linked in the sources.

2023: give them roles

CAMEL showed two agents, an "AI user" and an "AI assistant", could finish a task by role-playing with almost no human help. Generative Agents put 25 agents in a small simulated town, each with a memory it summarised into reflections. Seeded with one agent's wish to throw a Valentine's Day party, the agents spread the invitations and turned up together. ChatDev and MetaGPT turned role-play into a software company, with design, coding and testing stages. AutoGen made the conversation between agents the programming model. The shared lesson was that structure beats free chat: fixing who talks to whom, and in what format, cuts the errors that pile up when models simply chain their outputs.

The same year, Du and colleagues showed that debate alone helps. Three copies of gpt-3.5 that debated for two rounds scored 85.0% on the GSM8K grade-school maths test, against 77.0% for a single copy.

2024: add more agents, and design the wiring

"More Agents Is All You Need" found something almost embarrassingly simple: sample the same model many times and take a majority vote, and accuracy keeps rising with the number of samples. With 40 samples, the small Llama2-13B scored 0.59 on GSM8K, beating a single Llama2-70B at 0.54.

Other papers treated the team as a graph to optimise. GPTSwarm tuned both the prompts at each node and the connections between them. MacNet arranged agents on a directed graph, ran more than 1,000 of them, and found performance grows in an S-curve as agents are added, then flattens. Mixture-of-Agents stacked models in layers, each layer refining the last layer's answers. Microsoft's Magentic-One settled on the lead-and-workers pattern, with an orchestrator that tracks progress and re-plans after errors. ADAS and AFlow went further and let a model search for the best agent design itself.

2025: measure what breaks

Production systems shipped and researchers started counting failures. Anthropic described its multi-agent Research feature in detail. Cognition published "Don't Build Multi-Agents" the day before, arguing that parallel agents make conflicting decisions they never tell each other about. A UC Berkeley-led team annotated more than 1,600 traces from seven open-source frameworks and catalogued 14 ways they fail. A Google Research, Google DeepMind and MIT team ran the most careful comparison yet. Both studies get their own section below.

2026: shared boards and trained swarms

The newest work moves coordination out of chat messages. ScaleMAS replaces messages with a shared store that agents read in bounded chunks, and keeps improving up to 128 agents while tolerating agents that drop out mid-task. SwarmWorld shows agents can build a working society from traces left in a shared world alone, like ants, though adding communication helps further. Moonshot's Kimi K2.5 trains the model itself, with reinforcement learning, to decide when to split a task and spawn parallel sub-agents. And a counter-paper, OneFlow, showed that a single agent role-playing a team whose members all run on the same model can match that team, and costs less.

The frameworks you can use today

Here are the main open-source projects, with GitHub stars fetched on 15 November 2026. Stars measure attention, not quality.

Argo bar chart of GitHub stars for fifteen open-source multi-agent frameworks, led by OpenHands, MiroFish, DeerFlow and ruflo
The four biggest repos are full harnesses and apps that run agents for you, not libraries of agent classes. GitHub API, 2026-11-15. Argo chart.
  • OpenAI Agents SDK (30.7k stars): handoffs, or one agent calling others as tools. It replaced OpenAI Swarm, whose README now says "Swarm is now replaced by the OpenAI Agents SDK".
  • CrewAI (60.9k): role-based crews that run in sequence or under a manager agent, plus deterministic "Flows".
  • LangGraph (45.0k): a graph of steps with saved state, so a run can pause, resume or be inspected. Its add-ons langgraph-swarm and langgraph-supervisor give handoffs and a manager.
  • Microsoft Agent Framework (14.7k): graph workflows with sequential, concurrent, handoff, group-chat and Magentic patterns. It is the successor to AutoGen, whose README now says the project is archived.
  • Google ADK (22.2k): agent hierarchies and workflows, and the companion A2A protocol (26.5k), a standard for agents built by different companies to talk to each other.
  • MetaGPT (71.3k), ChatDev (34.7k) and CAMEL (18.0k): the research projects from 2023.
  • smolagents (30.4k): Hugging Face's small library, where a manager agent calls other agents as tools.
  • kyegomez/swarms (7.4k): a menu of ready-made structures, from sequential and group chat to hierarchical, with a router that picks one.

The biggest repos today are not these libraries. They are harnesses: complete programs that run agents for you, with a sandbox, memory and tools. OpenHands (93.5k stars) is a coding agent that delegates to sub-agents. ByteDance's DeerFlow (85.3k) runs a lead agent and sandboxed sub-agents. Ruflo (81.7k, formerly claude-flow) wraps command-line coding agents such as Claude Code and Codex, and ClawTeam runs each such worker in its own git worktree, a separate copy of the code. MiroFish (85.6k) simulates thousands of agents in a shared digital world to make predictions.

One more trend: the newer designs coordinate through shared state rather than open group chat. Claude Code's experimental agent teams use a shared task list that teammates claim work from, plus a mailbox per agent. AG2 replaced its group chat with a hub and typed channels. Magentic-One keeps a progress ledger. These are blackboards under other names.

How do you measure a swarm?

There are two kinds of test.

The first kind are ordinary agent benchmarks, where a swarm competes with single agents on the same tasks:

  • GAIA: 300 test questions that need browsing, files and reasoning; humans score 92%.
  • SWE-bench Verified and SWE-Bench Pro: fix real GitHub issues in real repositories.
  • BrowseComp: 1,266 questions that need persistent web searching for hard-to-find facts.
  • WebArena and OSWorld: complete tasks on websites or a full desktop computer.
  • Terminal-Bench: hard tasks in a command-line environment.
  • tau-bench: customer-service conversations under a company policy.

The second kind are built to test coordination itself. MultiAgentBench scores milestones reached plus the quality of communication and planning. Collab-Overcooked has two agents cook together through chat and scores how often each one starts or answers a useful request. COMMA gives two agents different pieces of the information. DPBench stages the classic Dining Philosophers problem and counts deadlocks. MAST is not a benchmark but a failure taxonomy you can use to label your own traces.

What gets measured has grown beyond "did it succeed". Serious reports now give:

  • Success rate, and pass@k (did at least one of k tries succeed).
  • pass^k, from tau-bench: did all k tries succeed. This measures reliability, which matters more than a lucky best run.
  • Tokens and dollars per task, summed over every agent.
  • Wall-clock time, which is where parallel agents shine.
  • A scaling curve: the score as you add agents.
  • Failure rates by type.

Terminal-Bench shows why cost belongs next to accuracy. On its version 4.1 leaderboard, Claude Code running Opus 5.5 and running Fable 5.2 tie at 65.8%, but the Fable 5.2 runs cost about USD 16.5k in total against USD 4.7k.

The fairest test of a swarm is the same task with and without the team. Here is what four papers report, each against its own single agent.

Argo bar chart of four multi-agent systems against a single agent on the same benchmark, with gains from 17.8 to 1.8 points
Each pair comes from one source with its own baseline, so read the gaps, not the bars across rows. Argo chart; sources in the footer and at the end of the post.

Kimi K2.5's Agent Swarm raised its BrowseComp score from 60.6% to 78.4%. Debate added 8 points on grade-school maths, and AgentVerse's group of GPT-4 agents 1.8 points on coding. At the top, Anthropic's system card for Claude Opus 5 reports a 10-agent team at 93.6% on BrowseComp, only 3.1 points above the best single agent, while 5- and 10-agent teams reached their scores 5.6 and 5.9 times faster than one agent. The card says those runs are for relative comparison only. These pairs come from different tests and years, but they fit what the controlled study below found: coordination pays less once one agent is already good. In Anthropic's frontier test, the team bought mostly speed, at a higher token cost.

When does a swarm pay off?

The most careful answer so far comes from "Towards a Science of Scaling Agent Systems", by researchers at Google Research, Google DeepMind and MIT. They tested 260 setups across six benchmarks and three model families, holding tools, prompts and computing budget equal, so the only thing that changed was how the agents were organised.

First page of the Towards a Science of Scaling Agent Systems paper with the sentence on architecture-task alignment highlighted
260 controlled setups: multi-agent ranged from 80.8% better to 70.0% worse than one agent. Source: Kim et al., arXiv 2512.08296, p. 1.

Compared with one agent, multi-agent setups ranged from 80.8% better on financial reasoning that splits into parts, to 70.0% worse on step-by-step planning. Three patterns held. Coordination pays less once a single agent is already good. Tasks that use many tools appear to carry extra overhead with a team. And teams without a central checker tend to spread errors more than teams with one. Their model picked the best setup for 87% of configurations it had not seen.

Anthropic's own numbers say the same thing from production. Their lead-and-workers Research system beat a single Claude Opus 4 by 90.2% on an internal research test. But on BrowseComp, token usage alone explained 80% of the difference in performance between runs.

Anthropic engineering post with the sentence on multi-agent systems using about fifteen times more tokens than chats highlighted
Anthropic on its multi-agent Research feature, 13 June 2025: the gain comes with a token bill. Screenshot: anthropic.com

A single agent uses about 4 times the tokens of a chat; their multi-agent system uses about 15 times. Anthropic writes that tasks where agents must share the same context, or depend heavily on each other, are a poor fit, and that "most coding tasks involve fewer truly parallelizable tasks than research." Cognition reached the same conclusion from the other side: when two parallel agents each make silent assumptions, such as the visual style of a game, the pieces do not fit together.

A swarm is like hiring a team of researchers: great for reading fifty sources at once, wasteful for writing one paragraph together. The analogy stops working at cost. A human team costs the same however you organise it; an agent team bills you for every word each member reads.

Why swarms fail

"Why Do Multi-Agent LLM Systems Fail?" opens bluntly.

First page of the Why Do Multi-Agent LLM Systems Fail paper with the opening sentence on minimal gains highlighted
The MAST study read more than 1,600 annotated traces from 7 frameworks and found 14 ways teams of agents fail. Source: Cemri et al., arXiv 2503.13657, p. 1.

Across seven open-source frameworks, including ChatDev, MetaGPT and Magentic-One, failure rates ran from 41% to 86.7%. The 14 failure modes fall into three groups: poor system design (bad role specs, agents repeating steps, not knowing when the task is done), misalignment between agents (ignoring each other, withholding information, drifting off task), and weak checking of the final result. The most common single modes were repeating a step, reasoning that did not match the action taken, and failing to recognise that the task was finished.

Quick fixes helped only a little. On ChatDev, clearer role descriptions raised success by 9.4%, and adding a final verification step by 15.6%. The authors conclude that the problems sit in the design, not in a missing prompt.

Swarms also add a risk a single agent does not have: contagion. In a 2026 case study of a 100-agent research swarm, one agent found a way to cheat the scoring system, and the exploit spread through the swarm's shared library and peer messages. A few agents later reported it.

How to use this

If you are deciding whether to build with a team of agents, the evidence points to a short checklist:

  • Start with one strong agent. Measure it. Add agents only where it falls short.
  • Split by reading, not by writing. Parallel agents are good at gathering: searching, reading sources, checking options. Keep the final writing, and any code that has to fit together, in one agent's hands.
  • Give each worker a clean, narrow brief and ask for a short report back, so the lead's context does not fill up.
  • Add a checker. Teams without central verification spread errors.
  • Prefer a shared task list or board to open chat. It is easier to inspect and survives an agent dropping out.
  • Measure cost and reliability, not only success: tokens per task, wall-clock time, and pass^k over several runs.

Agent swarms work, within limits that are now measured. The field has moved from "more agents is better" to asking which wiring fits which task, and the best recent work is starting to let the model make that call itself. We follow this research closely because we run teams of agents ourselves. More on the Argo blog at https://myargoquest.com/blog and on X at https://x.com/myargoquest.

Sources

Papers (arXiv, primary):

Benchmarks (primary):

Engineering posts (company primary):

Repositories (GitHub, stars fetched 2026-11-15): openai-agents-python, openai/swarm, crewAI, langgraph, agent-framework, autogen, adk-python, A2A, MetaGPT, ChatDev, camel, smolagents, swarms, OpenHands, deer-flow, ruflo, ClawTeam, MiroFish

Start your 750 words today

Argo turns a daily entry (typed, spoken, or filmed) into clarity you can actually see. Private, encrypted, and built entirely from your own life.

Download on the App Store