Agentic systemsMulti-agent systems · Architecture · LLM

When a multi-agent system loses to a single agent

A multi-agent system looks convincing on a slide: a whole team of specialists in place of a lone worker. In production it often turns out slower, more expensive and less predictable than one agent with good tools. This article is about where the line runs.

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

How to decide

  1. Build a single agent and measure it on a set of real tasks. This step is inexpensive, and it becomes your baseline.
  2. Find where it fails: not enough context, mixes up roles, loses steps, lacks permission to act.
  3. Add a split only to address a specific failure, and measure again.
  4. 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

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.

Frequently asked questions

When does a multi-agent system usually lose to a single agent?

When the task fits into the context of one model and is solved in sequential steps without different access rights. Splitting it then adds handovers between participants. Each one loses part of the information and raises the probability of error, and cost and latency grow with them.

How many agents do you need?

As many as you can justify with a metric. Most business tasks are covered by one agent with a good set of tools. Two or three participants make sense when you need independent verification or different permissions. A design with a dozen agents more often means the task was never fully broken down.

Does a multi-agent design help against hallucinations?

Only if the checker has an independent source of truth: tests, documents, a calculation. Checking with the same model on the same data produces agreement in place of control, and a false sense of reliability.

How do you know it is time to move to several agents?

When you have a measured failure of the single agent and a clear hypothesis about which split will fix it. Without a hypothesis, moving to several agents turns one reproducible failure into several that are hard to debug.

How we help with this

Read next

Tell us about your problem

If you’re dealing with something similar, describe it in your own words in the form on the homepage. If it has a simpler solution than it seems, we’ll say so.

New write-ups on TelegramEmail hello@xteam.pro