What we are talking about
In a multi-agent system a task is solved by several autonomous participants, each with its own role, tools and permissions: one plans, another searches, a third checks. A single agent is simpler: one language model, a set of tools and one decision-making loop.
The argument between the two is almost always settled by three measurable quantities: how many tasks are carried through to the end without a person, how much one task costs and how long it takes.
Where multi-agent designs lose
The task fits in one context
If all the data and tools you need fit into the context of one model, splitting the work between agents adds nothing but retelling. Every handover compresses the information: the next participant gets someone else’s summary in place of the original data and works with losses.
Errors build up along the chain
This is the main reason for failure. Say each step is done correctly nine times out of ten. That sounds decent, but five sequential steps already give roughly six successful outcomes out of ten, because the probabilities multiply. A single agent has fewer steps, so it makes mistakes less often.
Coordination costs more than the work itself
Every message between agents is one more model call with its own context. Cost and latency grow faster than the benefit of specialisation. Sometimes most of the budget goes on agents telling each other what they have already done.
The system cannot be debugged
When an answer is wrong, you need to find out who made the mistake: the planner broke the task down badly, the executor misunderstood it or the reviewer let the error through. If every step is not logged with its inputs and outputs, debugging becomes guesswork, and improvements become random prompt edits.
Agents agree with each other
The “one does, another checks” pattern works only if the checker has an independent source of truth: a test, a document, a calculation. A checker on the same model with the same information tends to confirm. The control it gives is imaginary.
Non-determinism multiplies
Each agent adds its own share of randomness. A system of five agents gives a noticeably less reproducible result than one agent, and reproducibility is exactly what a business pays for.
When a multi-agent design is really needed
- Different access rights. An agent that works with personal data and an agent that writes to an external system should not be the same actor.
- Independent verification. The checker has its own source of truth: a test run, a comparison against a document, a recalculation.
- Real parallelism. Ten subtasks of the same kind run at the same time, and that saves time.
- Different models for different steps: a cheap, fast one for routine work, a strong, expensive one for reasoning.
- Context isolation. A subtask needs so much data that it would otherwise push everything else out of the context.
How to decide
- Build a single agent and measure it on a set of real tasks. This step is inexpensive, and it becomes your baseline.
- Find where it fails: not enough context, mixes up roles, loses steps, lacks permission to act.
- Add a split only to address a specific failure, and measure again.
- Compare cost per task and latency as well as quality. A quality gain of a few per cent at double the cost usually does not pay off.
What to measure in both cases
- the share of tasks carried through to the end without a person stepping in;
- the share of answers that had to be corrected;
- the cost of one task in model calls;
- the time from assignment to result;
- reproducibility: how many times out of ten the same task is solved the same way.
Our experience
We do our engineering work together with AI agents from several vendors, under one set of rules. People start the sessions and accept the results, so we see clearly where an agent goes wrong and how to catch it. The most useful habit from this work: solve the task with one agent first and prove that a second one is needed. A multi-agent design helps against specific constraints; on its own it says nothing about how mature a system is.