Pick the most accurate reason 'more agents' does not automatically beat 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. The honest answer is that adding agents adds three real costs that usually outweigh the parallelism story. - **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. The math compounds against you. - **Fragmented observability.** Traces split across multiple agents, multiple processes, and multiple LLM calls. Attributing a bad output to a specific agent and a specific decision gets harder, not easier, exactly when you need the visibility most. A single well-prompted agent with a long context, good tools, and a clean system prompt skips all three. That is why frontier 2026 production systems (Claude Code, Cursor, Replit Agents) lean on stronger single agents with better context engineering rather than orchestrating ever-more agents.

**Three concrete costs accompany 'more agents'**, and they routinely beat the parallelism story. **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, so each round is two or three extra 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** is the arithmetic that bites 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, not fewer, 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's trace is a forest. The other options are wrong on their face. Parallelism does not guarantee lower cost. Multi-agent setups duplicate context across agents and frequently cost more, not less. A single agent can play multiple roles within one prompt (just describe the personas in the system prompt). Single agents handle tools fine. Multi-agent is a real pattern with legitimate uses: genuinely 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 in 2026 is to push the single agent harder before reaching for 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 eat more time than they save, and the essay reads like four people argued in writing. Multi-agent systems have the same shape: more voices is not automatically more signal, and the seams cost something real.

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 the most persistent oversimplification in the 2026 LLM space, and the MCQ is testing whether you can articulate the honest counter-argument without overcorrecting in the other direction. The right answer names mechanical costs the parallelism story papers over; the wrong answers are factual claims that are simply false.

The senior framing is two-sided: the multi-agent pattern has legitimate sweet spots, and it is wildly over-applied. Both halves need to be in the answer for it to read as calibrated rather than contrarian.

Mental model: every additional agent adds a seam, and seams cost prompts, compound error, and fragment traces. Add an agent only when the work genuinely 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 two agents are 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 gives roughly 59 percent, 10 steps gives 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 a forest: 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 compounds every additional agent.

Why the wrong answer choices are wrong

Where multi-agent legitimately wins

The 2026 single-agent production trend

Situations where this technique stops working.

2–4 min · Everything important, quickly.

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

Claude Code (Anthropic) and Cursor are single-agent at the core, relying on stronger context engineering rather than multi-agent orchestration.
Replit Agents migrated away from a multi-agent architecture toward a single LangGraph state machine with branch nodes for parallel work.

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.