04 Nov 2024 AI Engineering 4 min read

Multi-Agent Systems: Promise vs Plumbing

AutoGen, CrewAI, and LangGraph matured through 2024, yet multi-agent systems still pay a steep tax: coordination overhead, compounding errors, and fragmented shared context. We survey the framework landscape as of November 2024, quantify where the overhead comes from, and argue that a single agent with good tools remains the right default for most production tasks.

The Promise of Many Agents

A multi-agent system is a set of LLM-driven control loops that exchange messages to complete a task. A single agent is one loop: model call, tool call, result, next model call. The pitch for many dates to mid-2023: ChatDev (July 2023) and MetaGPT (August 2023) staged entire software companies out of role-playing agents — CEO, architect, programmer, tester. The demos were striking and the analogy intuitive: humans organize into teams, so why not models?

Eighteen months later, the question in production is narrower. Splitting a task across agents multiplies model calls, serializes latency, and fragments context. The honest comparison is not multi-agent versus no agent. It is multi-agent versus one competent agent with good tools. That comparison is much closer than the demos suggest, and it is the one we run before every architecture decision.

A task arrives — the agent plans its next step. 1/4

The Framework Landscape in Late 2024

The tooling matured measurably in 2024. LangGraph reached a stable v0.1 on 27 June 2024 and v0.2 on 7 August 2024, adding SQLite and Postgres checkpointers; Klarna, Replit, and Elastic run it in production. CrewAI announced 18 million US dollars in total funding on 22 October 2024 and claims over ten million agent executions per month. Microsoft announced on 2 October 2024 that AutoGen 0.4 is a ground-up rewrite around an actor model — while recommending users stay on the stable 0.2 for now. OpenAI released Swarm in October 2024, labeled explicitly experimental and educational.

The pattern is instructive. The field is popular enough to fund and unsettled enough that its own authors are rewriting their foundations. Teams building today are building on abstractions that are still moving. Budget for migrations.

Framework	First released	Status on 5 Nov 2024	Core abstraction
AutoGen (Microsoft)	2023	v0.2 stable; v0.4 rewrite announced 2 Oct 2024	Conversable agents in group chats
CrewAI	Late 2023	Enterprise GA; 18M USD funding on 22 Oct 2024	Role-based crews with tasks
LangGraph (LangChain)	Early 2024	v0.2 stable since 7 Aug 2024; Cloud in beta	Graph of nodes with checkpointed state
Swarm (OpenAI)	Oct 2024	Experimental; explicitly not for production	Stateless agents and handoffs

Coordination Overhead Is a Tax

Every agent turn is at least one model call. Group-chat orchestration re-sends the growing transcript on each turn, so token consumption grows roughly quadratically with conversation length. An LLM-based speaker selector — AutoGen's GroupChatManager is one example — adds a further call per turn and a further place to fail. None of this improves task quality by itself. It is plumbing.

Errors compound across handoffs. A pipeline of ten dependent agent steps, each 95 percent reliable, completes correctly about 60 percent of the time (0.95^10 ≈ 0.60). A single agent faces the same arithmetic per tool call, but has fewer interfaces where intent gets paraphrased, summarized, and distorted along the way.

Latency stacks the same way. Sequential handoffs cannot be parallelized when each agent consumes the previous agent's output, so a five-step chain multiplies time-to-answer roughly fivefold. Frameworks stream intermediate messages to soften this, but streaming masks the wait. It does not remove it.

Shared Context Is the Hard Part

Agents do not share memory. They share messages. Anything one agent learned but did not write into the transcript is invisible to the next. Full transcripts blow past context windows; summaries drop exactly the details that mattered. Frameworks call this shared state, but what is shared is a log. The result is divergent world models: a reviewer agent approves code against a file state the coder agent has already changed.

The frameworks' answers are persistence layers, not epistemics. LangGraph v0.2 ships Postgres and SQLite checkpointers; AutoGen 0.4 moves to event-driven state. Both make state durable and resumable. Neither decides what each agent needs to know. That remains the application developer's problem, and it is the hard one.

When One Agent With Tools Wins

The strongest argument against multi-agent designs is how good single agents have become. Mid-2024 models handle parallel tool calls natively, and context windows of 128K tokens (GPT-4o) to 200K tokens (Claude 3.5 Sonnet, June 2024) hold what previously required partitioning. One loop, one consistent context, one transcript to debug.

OpenAI's own Swarm documentation scopes the multi-agent case narrowly: it suits "a large number of independent capabilities and instructions that are difficult to encode into a single prompt". Read that as a threshold test. As long as prompt and toolset fit coherently into one agent's context, they belong there.

Observability also favors the single loop. One transcript can be replayed, diffed, and tested against expected tool calls. Interleaved agent conversations require correlating multiple histories to reconstruct one decision. Every framework in the table above ships dedicated tracing for exactly this reason — the need is a symptom.

Where Multiple Agents Earn Their Keep

There are cases where the split pays, and they are engineering constraints, not org charts. Fan-out over independent subtasks buys real wall-clock parallelism. Separate agents create isolation boundaries: different credentials, different tool permissions, different blast radius. Heterogeneous routing lets a cheap model do extraction while a strong model does synthesis. Genuine context partitioning applies when the combined material exceeds any available window. Naming agents "CEO" and "engineer" achieves none of this. Roles are prompt decoration; boundaries are architecture.

Outlook From November 2024

From where we stand in November 2024, the direction looks legible. Free-form group chat is losing to explicit graphs and state machines; AutoGen 0.4's actor-model rewrite and LangGraph's growth both point there. Research momentum remains firmly multi-agent — Microsoft published Magentic-One, a generalist multi-agent team built on AutoGen, in early November 2024. For 2025 we expect durable execution as a default, first attempts at standardized agent-to-agent protocols, and — overdue — controlled evaluations of when multi-agent designs actually beat single agents on cost and quality.

Our working prediction: most production systems shipping in 2025 will be single agents or small fixed pipelines, not open-ended agent societies. Every model generation raises the bar a task must clear before splitting it pays. Bet on the plumbing you can debug.