Which is the most accurate reason more agents do not automatically work better than a single well prompted agent?

MCQ·Medium·4.0 · 0·~1 min·Asked atAdobe Alibaba Robinhood

Attempt it

**Multi-agent systems** sound like a free win: more agents must be smarter than one. In practice, adding agents adds three real costs that usually outweigh the gains from parallel work. - **Coordination overhead.** Every handoff between agents is itself a prompt. The planner has to tell the coder what to do. The coder reports back to the planner. The manager picks who speaks next. Each of those is an extra LLM call with its own latency and token cost. - **Compounding per-step error.** If each step is 90 percent reliable, the end-to-end success rate over five steps is `0.9^5`, about 59 percent. Real multi-agent pipelines often have lower per-step rates than that. Each extra step lowers the end-to-end rate. - **Fragmented observability.** Traces split across multiple agents, multiple processes, and multiple LLM calls. Attributing a bad output to a specific agent and decision gets harder exactly when you need the visibility most. A single well-prompted agent with a long context, good tools, and a clean system prompt avoids all three. LangChain's multi-agent docs make the same point: a single agent with the right tools and prompt can often achieve similar results.

**Three concrete costs accompany 'more agents'**, and they often outweigh the parallelism gains. **Coordination overhead** is the prompt and LLM cost of every handoff. A planner / coder / critic GroupChat is three roles plus a manager LLM picking speakers. Each round adds two or three LLM calls before any work happens. Total token cost scales roughly with `n_agents × transcript_length` because every agent re-reads the full history each turn. **Compounding step error** applies to every multi-step pipeline. At 90 percent per-step success, five sequential steps land at `0.9^5 ≈ 0.59` end to end. Multi-agent setups tend to have more steps, because each handoff is its own step. **Fragmented observability** is the late-stage cost. Traces span multiple agents and processes, and attributing a regression to a specific decision becomes a multi-trace investigation. A single agent's trace is one ordered call list. A five-agent system produces many linked traces. The other options are wrong. Parallelism does not guarantee lower cost: multi-agent setups duplicate context across agents and often cost more. A single agent can play multiple roles within one prompt (describe the personas in the system prompt). Single agents handle tools fine. Multi-agent is a real pattern with legitimate uses: parallel branches, role isolation for safety (a reviewer agent with no tool access), or workflows where personas would read very differently. It is not a free win, and the default is to improve the single agent before adding orchestration.

TL;DR

Coordination overhead, multiplicatively compounding per-step error, and fragmented traces routinely outweigh the parallelism gains a multi-agent setup promises.

Memory aid

Easy to grasp

Imagine writing a school essay. One careful student writing it alone with a good outline tends to beat a four-person group where everyone has to read each other's drafts, vote on edits, and reconcile contradictions. The group might finish faster if the work splits cleanly. But most of the time the meetings, handoffs, and reconciliations take more time than they save. The essay then reads like four people argued in writing. Multi-agent systems have the same shape: more voices is not automatically more signal, and every handoff has a real cost.

Key concepts

LLM Frameworks

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

'Multi-agent beats single-agent' is a persistent oversimplification about LLM systems. Mechanical costs that the parallelism story leaves out make it false as a general rule, and several common arguments for it are factually wrong.

The calibrated view is two-sided: the multi-agent pattern has legitimate uses, and it is widely over-applied.

Every additional agent adds a handoff, and each handoff costs prompts, compounds error, and fragments traces. Add an agent only when the work needs one.

The three concrete costs of more agents

Coordination overhead

Every handoff in a multi-agent system is an extra LLM interaction. In a GroupChat-style setup, the manager LLM picks the next speaker each turn. That is one extra call per round. Each agent then re-reads the full shared transcript to produce its reply, so token cost scales roughly as n_agents × transcript_length × turns. A 5-agent, 10-turn pipeline can spend 3 to 5 times more tokens than a single agent on the same task.

Even in handoff-style setups (OpenAI Swarm, Agents SDK) where only one agent is active at a time, every handoff is its own decision and its own prompt. The overhead is smaller than GroupChat but not zero.

Compounding per-step error

End-to-end success is the product of per-step success when steps are sequential. The arithmetic:

P(\text{success}) = \prod_{i=1}^{n} p_i

At 90 percent per step, 5 steps give roughly 59 percent and 10 steps give 35 percent. Multi-agent pipelines have more steps because each handoff is its own decision (manager picks speaker, agent generates response, tool runs, agent reads result). A single agent with a clean plan often executes 2 to 3 steps where a multi-agent loop runs 8 to 10.

Fragmented observability

A single agent's trace is one ordered list of LLM calls and tool calls. A multi-agent system produces many traces: each agent has its own trace, with handoff messages connecting them. Correlating a regression to a specific decision requires joining traces across agents and reasoning about ordering. The cognitive cost on the on-call engineer grows with every additional agent.

Why the other claims are false

Where multi-agent legitimately wins

What published systems show

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

Anthropic's post "Building effective agents" (December 2024) recommends finding the simplest solution possible and adding complexity only when it demonstrably improves outcomes.
Anthropic's post "How we built our multi-agent research system" (June 2025) reports that a lead agent with parallel subagents beat a single agent by 90.2 percent on its internal research eval, while multi-agent systems used about 15 times the tokens of chat.

What an interviewer would ask next. Try answering before peeking at the approach.

QIf you measure your single-agent system at 70 percent end to end success, when does adding a critic agent help vs hurt?

It helps if the critic catches a specific failure mode the agent cannot self-detect (e.g., schema violations on tool outputs) and the critic's per-step error is low. It hurts if the critic introduces its own error or rejects correct answers. Quantify both: per-step critic accuracy times current end-to-end rate, vs single-agent rate without critic. Only add the critic if the math comes out positive on your eval set.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Believing the parallelism story without doing the arithmetic on per-step error. At 90 percent success per step over five steps, end-to-end reliability falls to roughly 59 percent.

60 second bullets to scan on the way to the call.

Coordination overhead as the prompt and LLM cost of every handoff
The compounding-error arithmetic for sequential steps

Primary sources. Browse if you want the original framing.