Key points
- Split a job into agents only where the roles need different instructions, different tools or an independent check.
- Most failures happen at the handoff, so define exactly what one agent gives the next.
- Every extra agent adds model calls, waiting time and one more place for an error to enter.
- Loops need hard limits: a maximum number of rounds, a named decision-maker and a way to stop and ask a human.
- Start with one agent and good tools. Add a second agent only when you can name the problem it solves.
1. The idea in one paragraph
An AI agent is a language model that is given a goal, a set of tools and permission to take several steps on its own. A multi-agent system is several such agents working on the same job, each with its own instructions and its own tools. One agent finishes a part and passes it to the next.
This sounds complicated, but the idea is old. A newspaper has worked this way for a very long time. A reporter collects the facts, a fact-checker verifies them, an editor shapes the story, and a publisher decides whether it goes out. Nobody in that chain is expected to do everything. This paper uses that newsroom as a running example, because almost every design question in multi-agent systems has a familiar newsroom version.
2. Why split a job into roles at all
Imagine one person who must report a story, check it, edit it and publish it alone. They can do it, but they will check their own work gently. They already believe what they wrote. The newsroom solves this by giving the checking to someone who did not write the story and has no reason to defend it.
The same reasoning applies to agents. A model that has just written a paragraph tends to agree with it when asked to review it in the same conversation. A separate agent, with instructions that say only "find what is wrong or unsupported", looks at the text fresh. That independence is the strongest reason to use more than one agent.
There are two other good reasons. The first is focus. An agent with a short, specific instruction and three tools usually behaves more predictably than an agent with a very long instruction and fifteen tools, because it has fewer ways to go wrong. The second is permission. A reporter agent may search the web, but only the publisher agent should be allowed to post to the live website. Separate roles let you hand out dangerous tools narrowly.
- Independence: a checker that did not produce the work.
- Focus: a short instruction and a small toolset per role.
- Permission: risky actions held by one role only.
3. The four roles in our newsroom
Suppose the job is a short daily report on fuel prices for a local news site. The reporter agent has a search tool and a tool for reading web pages. Its instruction is to collect the current facts and note where each one came from. It does not write polished prose.
The fact-checker agent receives the reporter's notes. It has the same reading tool but a different instruction: open each source again and confirm that the claim really appears there. It marks each claim as confirmed, not found, or contradicted.
The editor agent has no web tools at all. It receives only the confirmed claims and writes the article in the house style. The publisher agent does the final step. It checks the article against a short list of rules, such as length, a headline being present and no unconfirmed claim appearing, and then either publishes it or holds it for a person.
Notice that the roles differ in three ways: instruction, tools, and what they are allowed to see. If two of your agents have the same instruction, the same tools and the same input, you do not have two roles. You have one agent running twice.
4. Handoffs: where most of the trouble lives
In a real newsroom, stories go wrong at the desk boundary. The reporter knew a figure was approximate but did not write that down, so the editor printed it as exact. Agent systems fail in the same place. The receiving agent knows only what it is given. It has no memory of the sender's reasoning, doubts or abandoned attempts.
The fix is to treat a handoff as a form, not as a chat. Decide in advance what fields the reporter must fill in, and reject the handoff if a field is empty. A structured handoff is easier for the next agent to read and easier for you to inspect when something breaks.
- The claim, stated in one sentence.
- The source address where it was found.
- The exact words in the source that support it.
- A confidence note: stated directly, calculated, or inferred.
- Anything the reporter looked for and could not find.
If you can only improve one thing in a multi-agent system, improve the handoff format.
5. Shared memory or passed messages
There are two broad ways for agents to share information. In the first, each agent passes a message to the next, like a file moving from desk to desk. Each agent sees only what the previous one chose to send. This is simple and easy to trace, and it keeps each agent's input small. The weakness is that anything left out of the message is lost.
In the second, all agents read and write to a shared space, like a newsroom whiteboard or a shared story file. The fact-checker can see the reporter's raw notes, not just the summary. Nothing is lost, and agents can work in a flexible order. The weakness is clutter. As the shared record grows, every agent has to read more, which costs more and makes it easier to pick up something irrelevant or out of date. Two agents can also overwrite each other.
Many working systems mix the two. Agents pass short, structured messages, and a shared store holds the bulky material, such as source documents, that an agent can look up when it needs to. A sensible default is to pass messages first and add shared memory only when you see information being lost.
6. Fixed pipeline or a manager
A fixed pipeline runs the roles in a set order every time: reporter, fact-checker, editor, publisher. You write that order in ordinary code. The model decides what to write, but not who goes next. This is predictable, cheap to run and easy to debug, because a failure always belongs to a known step.
The manager pattern, often called an orchestrator, puts one agent in charge. It reads the request, decides which worker to call, reads the result and decides what to do next. It is the news editor who looks at a breaking story and says "this needs two reporters and a legal check", then looks at a weather update and sends it straight to the desk. The manager pattern handles varied work that a fixed order cannot.
The cost of a manager is that routing is now a model decision, and model decisions can be wrong. The manager may skip the fact-checker when it should not, or call the reporter again and again. It also adds its own model calls on top of the workers'. Use a pipeline when the steps are the same every time. Use a manager when the right steps really depend on the input.
Frameworks such as CrewAI exist to make this easier. They give you ready structures for defining roles, tasks and the order or manager that connects them. They save typing, but they do not make the design decisions for you. A badly divided job stays badly divided in any framework.
7. How costs and errors multiply
Each agent makes at least one model call, and often several, because using a tool means calling the model, running the tool and calling the model again with the result. Four agents therefore cost several times what one call costs, and the reader waits for all of them. Text also gets paid for more than once. The reporter's notes are output for the reporter and then input for the fact-checker, and perhaps input again for the editor.
Errors compound in a similar way. If every step is right most of the time but not always, a chain of four steps is right less often than any single step, because one slip anywhere can spoil the result. A wrong figure from the reporter that the fact-checker misses will be written beautifully by the editor and published confidently by the publisher. Later agents tend to trust what they receive.
This is why a checking role must be a real check and not a polite second reading. The fact-checker in our newsroom reopens the sources. If it only read the reporter's notes and judged whether they sounded plausible, it would add cost without adding safety.
An agent that cannot look at anything new is reviewing style, not truth.
8. Stopping agents from arguing in loops
Put an editor agent and a writer agent in a review cycle and a familiar problem appears. The editor asks for a change. The writer makes it. The editor, whose job is to find problems, finds another. Neither has a reason to stop, and each round costs money. Sometimes they simply trade the same two versions back and forth.
Newsrooms have a deadline and an editor whose word is final. Agent systems need the same controls, written into the code around the agents and not left to the agents' good sense.
- A hard limit on rounds, for example two revisions and then stop.
- One named decision-maker whose verdict ends the discussion.
- A written acceptance checklist, so "good enough" is defined before the work starts.
- A total budget of steps or spend for the whole job, after which it halts.
- An exit to a human: when the limit is reached, hold the work and show a person what the disagreement was.
9. A test for when one agent is enough
A single agent with good tools and a clear instruction can do a surprising amount, and it is cheaper, faster and far easier to debug. It should be the default. Before adding a second agent, ask the following questions about the job.
- Does one part need an independent check by something that did not produce the work?
- Do the parts need clearly different instructions that would confuse each other if combined?
- Does one part need a risky tool that the others should not hold?
- Is the material too large for one agent to hold at once, so that separate workers must each take a piece?
- Can parts run at the same time, so that splitting actually saves waiting?
If every answer is no, build one agent. If you answer yes, you should be able to say which agent exists because of which answer.
10. A sensible way to build one
Start with a single agent that does the whole job, and run it on a small set of real examples. Write down where it fails. Perhaps it publishes unverified claims, or its tone drifts when the instruction gets long. Each observed failure is a candidate for a new role. Add one role, run the same examples again and compare. If the results did not improve, remove it.
Log every handoff so you can read what each agent received and produced. Without that record a multi-agent system is very hard to repair, because you can see the wrong final answer but not the desk where it went wrong. Keep a person at the publishing step until the system has earned trust on work that matters.
The newsroom is a useful picture because it was never designed to look impressive. Each desk exists because, at some point, stories went wrong without it. That is the right standard for agents as well: every role should be the answer to a failure you have actually seen.
