Aiodic

Back to the table

104 Advanced Ma Multi-agent Systems Agents & Automation

Multi-agent Systems

Several agents working together.

What it is

A multi-agent system is a team of AI agents that share a job. Instead of one AI doing everything from start to finish, several agents each take a part: one researches, one writes, one checks. They pass work between them, the way people in a small office pass a document along a desk.

An agent is an AI system that works towards a goal over several steps, using tools and deciding for itself what to do next. A multi-agent system simply has more than one of them, with some arrangement for how they talk to each other. The agents are usually the same underlying language model. What makes them different is their instructions. Each gets its own system prompt, the standing instructions that set its job, and often its own tools. "You are a researcher. Find sources and list facts with links, and never write prose" produces a very different worker from "You are an editor. Cut anything that isn't supported by the notes you were given."

That's the key idea to hold on to. In most multi-agent systems, the "team" is one model wearing several hats, and each hat has its own separate conversation. The researcher doesn't see the editor's instructions, and the editor sees only what the writer handed over. That separation is both the strength and the weakness of the whole approach, as you'll see.

There are a few common shapes:

The moment where one agent passes the work and responsibility to another is a handoff, which is also its own element. On this page the focus is on the team as a whole: why you'd split a job into roles, what it costs, and when you shouldn't.

Why it matters

Specialisation helps a model focus. A single prompt that says "research this, write it up, check it and polish it" asks for four different mindsets at once. Split into roles, each agent gets a short, clear brief and a small amount of material to work with. This connects to context engineering: a model tends to do better when what's in front of it is focused and relevant, rather than a long pile of everything. A researcher agent's conversation contains only search results. The editor's contains only the draft and the rules. Neither is distracted by the other's clutter.

A second agent can catch what the first one missed. When a model reviews its own work in the same conversation, it tends to be kind to itself, a problem the self-critique page explores. A separate reviewer with different instructions and a fresh conversation hasn't seen the reasoning that produced the draft, so it's more likely to read the draft the way a stranger would. This is the same reason human writers use editors. It doesn't make the reviewer infallible, but it changes the angle of attack.

Independent parts can run at the same time. If a question breaks into separate pieces, such as comparing five competitors or checking ten suppliers, several agents can each take one and work in parallel. That's where the biggest measured gains have come from. When Anthropic described the system behind Claude's research feature in June 2025, it reported that a lead agent working with several helper agents did 90.2 percent better on its internal research test than a single agent working alone. The context engineering page covers that system in more detail.

It's where AI tools are heading, so it helps to understand it. Research tools, coding assistants, and automation products increasingly run several agents behind one chat box. Knowing how they work tells you why some tasks take longer and cost more, why an answer can come back contradicting itself, and what to check.

But it costs more, and it can go wrong in new ways. The same Anthropic post reported that its multi-agent setup used about 15 times as many tokens as an ordinary chat. Tokens are the chunks of text a model reads and writes, and they're what usage is billed and limited by. Every handoff means rewriting context, every reviewer means re-reading the draft, and every round of discussion adds more. A team also introduces a new kind of error that a single agent can't make: two agents misunderstanding each other. The failure study in the examples below found that many breakdowns come from exactly that.

Real-world examples

Stanford's Smallville: 25 agents and a Valentine's Day party (2023)

In April 2023, researchers from Stanford University and Google, led by Joon Sung Park, published "Generative Agents: Interactive Simulacra of Human Behavior". They built a small pixel-art town inspired by the video game The Sims and filled it with 25 AI agents, each with a name, a job, relationships, and a memory of what had happened to it. The agents woke up, made breakfast, went to work, and chatted when they met.

The famous test started with a single instruction to one agent, Isabella Rodriguez: she wanted to throw a Valentine's Day party at Hobbs Cafe. Nobody told the other agents anything. Over two simulated days, Isabella invited people, word spread from conversation to conversation, agents asked each other to go as dates, and some helped decorate. At 5 pm on Valentine's Day, five agents turned up at the cafe. The paper also reported, honestly, that several invited agents didn't come: some had other plans, and some said they were interested but never planned to go.

Smallville wasn't built to get a job done. It showed something important about multi-agent systems in general: interesting group behaviour can come out of simple individual instructions, and so can surprising gaps, like guests who say yes and never make it into their diaries. When you give agents roles and let them talk, what the team does isn't fully written in anyone's prompt.

ChatDev and MetaGPT: an AI software company (2023)

In July 2023, a team led by Chen Qian at Tsinghua University published ChatDev, a system that imitated a small software company. Agents were given roles such as CEO, CTO, programmer, reviewer, and tester, and they worked through the stages of a project, from design to coding to testing, by chatting with each other in pairs. The paper compared it with a single-agent approach and found the multi-agent version produced more complete programs, while openly noting that it was slower and used more tokens.

A month later, in August 2023, a separate team led by Sirui Hong published MetaGPT. Its insight was that free conversation between agents lets mistakes snowball, with one agent's invented detail becoming the next agent's assumption. MetaGPT gave its agents standard operating procedures, the step-by-step checklists a real company uses, so that each role produced a defined document, such as a requirements list or a design, that the next role could check.

Around the same time, in August 2023, Microsoft researchers published AutoGen, an open-source framework that made it much easier for developers to set up conversations between several agents, with tools and optional human input. Between them, these projects made "give the agents job titles and let them talk" one of the most copied ideas of 2023 and 2024.

Multiagent debate: arguing towards better answers (2023)

In May 2023, Yilun Du and colleagues from MIT and Google Brain published "Improving Factuality and Reasoning in Language Models through Multiagent Debate". The method is simple. Several copies of a chatbot each answer a question. Each then reads the others' answers and revises its own. After a couple of rounds, they settle on a final answer.

In their main experiments, three agents debated for two rounds using ChatGPT (gpt-3.5-turbo). On multi-digit arithmetic, accuracy rose from 67.0 percent for a single agent to 81.8 percent with debate. On grade-school maths word problems it rose from 77.0 to 85.0 percent. Short biographies of computer scientists became more accurate too, which suggests agents checking each other can reduce hallucination, the problem of a model confidently stating things that aren't true.

The authors were also candid about the weak spot. Sometimes the agents converged on a wrong answer and then confidently declared it correct and consistent with everyone else's. Agreement between agents is not the same as being right, and when every agent is the same model with the same blind spots, they can reassure each other into an error. The idea is a cousin of self-consistency, where you ask the same question several times and take the majority answer, with the difference that debating agents see and respond to each other.

Why do multi-agent systems fail? (2025)

By 2025 multi-agent frameworks were everywhere, but their results on standard tests were often disappointing. In March 2025, a team at UC Berkeley led by Mert Cemri published "Why Do Multi-Agent LLM Systems Fail?". They studied conversation logs from popular open-source multi-agent systems, including ChatDev and MetaGPT, had expert annotators label what went wrong, and built a taxonomy of 14 failure modes. The latest version of the paper covers more than 1,600 annotated logs across seven frameworks.

The failures fell into three groups, and they read like a list of problems in a badly run office:

The researchers also tried simple fixes. Clearer role descriptions improved ChatDev's success rate, and adding a step that checked the result against the original goal improved it further, but neither fixed everything. Their conclusion was that these failures need better system design, not just better prompts. For anyone building an agent team, the list is a ready-made checklist.

Two views from the builders, and a shop run by agents (2025)

Two posts published a day apart in June 2025 capture the debate among people who build agents. On 12 June, Walden Yan of Cognition, the company behind the coding agent Devin, published "Don't Build Multi-Agents". His example: split the job of building a Flappy Bird clone between two helper agents, and one may build a background in the style of Super Mario while the other builds a bird that doesn't match, leaving a final agent to combine parts that don't fit. His argument was that agents working without the full shared picture make conflicting decisions. On 13 June, Anthropic published how its research feature uses several agents successfully, and noted that the approach suits research that splits into independent questions, while most coding involves fewer tasks that can truly be done in parallel. Both are covered on the context engineering page.

Anthropic's Project Vend, in which Claude ran a small office shop (see the agent page), added a multi-agent twist in its second phase, reported in December 2025. Anthropic added a "CEO" agent to supervise the shopkeeper. The CEO cut discounts but approved lenient requests far more often than it refused them, and the two agents sometimes drifted into long, dreamy late-night exchanges about transcendence. A separate merchandise agent with a clearly separate job did much better. Anthropic's lesson was that clear role separation helped, and that a supervisor made of the same model doesn't automatically bring discipline.

An everyday scenario: a newsletter team of three

Imagine Priya, who writes a weekly newsletter about houseplants. She used to ask one chatbot to "research this week's topic, write 800 words, and fact-check it". The results were fluent but occasionally wrong, and the fact-check at the end never found anything. So she tried roles. In one chat, a researcher agent collects facts about repotting succulents, each with a link. In a second, a writer agent turns only those notes into a draft. In a third, an editor agent compares the draft line by line with the notes and flags anything that isn't supported. The first week, the editor flags a watering tip the writer had added from nowhere. That's the promise of the setup. The price is that the whole thing takes her twenty minutes instead of five, so she keeps the three-role version for her feature articles and uses one chat for quick notes.

Try it yourself

You'll run the same task two ways: as a three-role team in three separate chats, and as one chat doing everything. Then you compare. You need any chatbot, a topic you know reasonably well (so you can judge accuracy), and about 40 minutes. A topic you know is important: it's the only way to tell whether the reviewer is catching real problems.

  1. Pick a small task. A 500-word explainer suits this well, for example "how to price a first self-published book" or "what to check before hiring a freelance designer".
  2. Open Chat 1, the researcher. Paste this, with your topic in the brackets:
You are a researcher. Your only job is to gather material, not to write.
Topic: [your topic]
List 8 to 12 key facts or points a beginner needs.
For each, give one sentence and say how confident you are (high, medium, low).
If a point needs checking, say so. Do not write an article.
  1. Check the notes yourself for two minutes. Delete anything you know is wrong. This is you acting as a human in the loop, and it's the cheapest quality check in the whole exercise.
  2. Open Chat 2, the writer. A brand-new chat, so it can't see the researcher's conversation. Paste:
You are a writer. Write a 500-word explainer for beginners using ONLY the notes below.
Do not add facts that are not in the notes. If something seems missing, write [GAP] instead of filling it in.
Notes:
[paste the researcher's notes]
  1. Open Chat 3, the critic. Another new chat. Paste the notes and the draft:
You are a strict editor. Compare the draft with the notes.
1. List every claim in the draft that is not supported by the notes.
2. List anything important from the notes that the draft left out.
3. Point out anything unclear to a beginner.
Do not rewrite the draft. Just give the list.
Notes:
[paste notes]
Draft:
[paste draft]
  1. Pass the critique back to the writer. Return to Chat 2 and paste: "Here is an editor's feedback. Revise the draft to fix these points, still using only the notes." That handoff is the heart of a multi-agent system, done by hand.
  2. Now do it the single-agent way. Open Chat 4 and paste:
Research the topic below, write a 500-word beginner's explainer, then check your own draft for unsupported claims and revise it.
Show only the final version.
Topic: [your topic]
  1. Compare. Put both final versions side by side. Count factual errors you can spot, claims you can't verify, and useful points each one includes. Note how long each route took and how much copying you did.

What most people find: the three-chat version is more careful and easier to check, because each step's output is visible and the critic has a fresh eye. The one-chat version is faster and often reads more smoothly, because one mind wrote the whole thing. Neither always wins, which is the lesson. If you want to go further, run the critic twice with different instructions, one for accuracy and one for clarity, and see whether the second adds anything. Tools that automate this kind of pipeline, such as agent builders and workflow automation services, change their features and limits often, so check the current details before you rely on one.

Common mistakes and misunderstandings

"More agents means better results." Adding agents adds cost and more places for work to be misunderstood. The Berkeley study found that many multi-agent systems barely beat a single agent on standard tests. Start with one well-instructed agent, and split only where you can name the reason.

Splitting work that needs one shared picture. A story, a program, or a brand voice needs consistent decisions throughout. Hand the first half of a novel chapter to one agent and the second half to another and you'll get two tones and a continuity error. Splitting works best when the parts are genuinely independent, such as researching separate questions, or when one role checks another rather than building half of the same thing.

Thin handoffs. Each agent knows only what it's handed. If the researcher passes a list of facts but not the audience, the writer guesses. Cognition's point was exactly this: pass on the decisions and the context, not just the latest message. When you move work between agents, include the goal, the audience, and anything already decided.

Treating agreement as proof. When several agents built on the same model agree, it may only mean they share the same blind spot. The debate paper saw agents converge on wrong answers and declare them correct. Use agreement as a signal, and keep an outside check: a source, a test, or a person.

Giving the reviewer no teeth. A critic told to "give feedback" tends to praise and nitpick. Tell it exactly what to look for, give it the material to check against, and let its findings actually change the work. The Berkeley study's "incorrect verification" failure is a checker that looks and wrongly says all is well.

Assuming a manager agent brings discipline. Project Vend's AI CEO was made of the same model as the shopkeeper and was often just as easily persuaded. Supervision works when the supervisor has different information or different rules, not merely a grander title.

Forgetting the bill. Anthropic's figure of about 15 times the tokens of a chat is a useful rule of thumb for why agent teams run slower and hit usage limits sooner. For a quick task, the team is overkill.

Thinking job titles are magic. Calling an agent "a world-class editor" doesn't make it one; the role prompting page covers research showing expert personas don't reliably improve accuracy. Roles help because they narrow the job and the material each agent works with, not because of the label.

No clear end point. Agents that don't know when they're done keep going: re-checking, re-writing, or handing work back and forth. Give every team a stopping rule, such as "two rounds of review at most" or "stop when the editor finds no unsupported claims".

Related elements