Multi-Agent Systems Are Almost Never the Answer — Nine Months of Data

The 2026 AI agent hype line — "multi-agent systems". Specialized agents collaborating to solve complex tasks.

Over the last nine months we tried multi-agent five times and fell back to single-agent every time. This post is the breakdown and why multi-agent is almost never the answer.

Five cases and outcomes

Case 1 — triage agent + diagnosis agent + remediation agent

Hypothesis: split incident response into three specialist agents.

Why it broke — context loss. The triage agent's intuitions didn't transfer to diagnosis. The diagnosis agent re-analyzed from scratch. A single agent with three tools worked better.

Case 2 — code review + security + performance agents

Hypothesis: review across three concerns separately.

Why it broke — the same code read three times. 3× token cost. Cross-cutting issues (security + performance interaction) got missed because they were split.

Case 3 — manager agent + worker agents

Hypothesis: manager decomposes work; workers execute.

Why it broke — coordination cost. Prompt round-trips between manager and workers ate 50% of total task cost. The single agent doing it directly was faster.

Case 4 — plan agent + execute agent

Hypothesis: separate planning from execution.

Why it broke — plan was either too abstract or too concrete. Too abstract → execute re-plans. Too concrete → planning has no value. Single agent with plan-then-execute instructions in the system prompt was more accurate.

Case 5 — per-language agents (Korean vs English)

Hypothesis: Korean users get a Korean agent; English users get an English one.

Why it broke — translation loss. Intent expressed precisely in Korean degraded going through an English-language agent system. A single multilingual model was more accurate.

The common cause across the five

Why multi-agent broke in all five:

Inter-agent communication losses and costs always exceed the value of specialization.

Every agent is an LLM call; communication happens in natural language (or JSON). Through the serialize-deserialize-reinterpret hops:

• Implicit context lost
• Prompt tokens multiplied — communication overhead
• Mismatched assumptions — agent A's worldview ≠ agent B's

These three always exceed the specialization value. Always.

The rare cases where multi-agent is the answer

Few but real:

1. Physical isolation required — one agent runs in a classified environment, another in unclassified. Same model can't see both
2. Temporal separation — one runs at night, the other during the day. They can't share context
3. Genuinely different model capabilities — one needs a code-specialist model, the other a general model. No single model is strong enough at both

Outside these three, one agent + good tools wins.

Our answer — toolful agent

The pattern we settled on — one agent, many tools. Tools = functions. Function calls = explicit transitions.

Before (multi-agent):
  triage agent → handoff → diagnosis agent → handoff → remediation agent

After (toolful single agent):
  agent
    .tool(triage)
    .tool(diagnose)
    .tool(remediate)
    .tool(check_history)
    ...

A single agent with 15+ tools works better than three agents. The six-month data is unambiguous.

So when do multiple agents actually make sense?

Multi-agent beats a single agent in exactly three situations: physical isolation, temporal separation, and genuinely different model capabilities. If you're designing or considering a multi-agent system, first check whether your hypothesis matches one of the five cases above. If it does, stop. Try a single agent with tools first, and consider multi-agent only if that fails. On six months of our data, it almost never fails in a way multi-agent solves.