Insider Brief
- An analysis by Galileo Labs argues that multi-agent AI systems can outperform or underperform single-agent approaches depending on the coordination costs they impose.
- Multi-agent systems work best when tasks are independent and agents mostly read or analyze data without needing constant interaction or overlapping writes.
- As AI models improve, many complex multi-agent architectures may become obsolete, making careful design and temporary orchestration strategies essential for builders.
AI builders are debating whether more agents really mean smarter systems. Now, a recent analysis by Pratik Bhavsar of Galileo Labs shows why multi-agent systems — the idea of splitting tasks among many specialist AIs — can both outperform and underperform single-agent approaches. The difference, he argues, comes down to the hidden costs of coordination.
The logic seems straightforward: five specialists should beat one generalist. Humans do it every day in project teams. A multi-agent AI setup promises the same with parallel work, faster completion and deeper focus.
In practice, each AI agent works on its own slice of the problem. One agent might design a web app layout, another handle login features and a third set up database connections. An orchestrator coordinates their output into a finished product.
On the surface, this sounds like a great way to optimize efficiency, but Bhavsar shows why the math often fails. Every agent needs context from the others, and sharing that information creates exponential overhead. Two agents require one exchange; ten agents may need 45. With each exchange, costs rise, delays mount, and the chance of errors multiplies.
The Memory Problem
Bhavsar points out that memory is the nervous system of multi-agent systems. Unlike a single model with a unified context, agents must pass details back and forth, according to Bhavsar’s post. If one agent misses a critical detail or receives too much irrelevant data, the chain breaks.
For example, an authentication agent may need a token structure defined earlier. If it receives the wrong version — or none at all — the system fails. When multiple agents write or modify code simultaneously, inconsistencies cascade. Different structures for the same user profile might emerge, leaving the system fragmented.
This problem explains why companies like Cognition and Anthropic emphasize memory management as the make-or-break factor. Without it, even simple workflows collapse.
Where Multi-Agent Actually Works
Not all multi-agent projects fail — some actually succeed spectacularly, and Galileo Labs points to a pattern.
Multi-agent shines when tasks are independent. In these cases, agents can process separate inputs with no need to interact. Think of it like splitting a spreadsheet among ten people who each calculate their own column. Nobody needs to check the others’ work until the end.
Anthropic’s climate change research system is one such example. Specialized agents separately analyzed economic data, environmental studies and policy reports. Since none altered the others’ results, the orchestrator could simply combine findings. The payoff was more sources analyzed, faster, than a single agent could handle.
Another case comes from Bloomberg, which built an experimental system to monitor financial markets. One agent scanned news sentiment, another watched options flow, another tracked social media chatter and a fourth studied technical indicators. Each worked alone, and a master system merged their signals. The results: faster insights, more patterns spotted, and fewer false alarms.
The lesson, according to Galileo Labs, is clear. Multi-agent systems excel when they follow three rules:
- Problems can be divided into pieces that require no cross-talk.
- Agents mostly read and analyze, rather than write and modify.
- Orchestration is deterministic, with clearly defined handoffs and no guesswork.
The Bitter Lesson
The analysis also ties the debate to what AI researchers call “the bitter lesson.” Historically, simple methods paired with more computing power have beaten elaborate, specialized structures.
Multi-agent systems, Bhavsar writes, may be another temporary workaround. They exist because today’s models still hit limits in reasoning, memory and tool use. Breaking tasks into smaller agents is a way to patch those gaps. But as models get stronger, the patches may become unnecessary.
The pattern is already visible through workflows, which once requiring many steps on earlier models and now collapse into single prompts on newer ones. Complex orchestration designed for GPT-3.5 became irrelevant with GPT-4 or Claude 3.
That means a sophisticated multi-agent system built today may be obsolete by the time it reaches production.
A Decision Framework
Galileo Labs offers a practical framework for deciding whether to pursue multi-agent designs.
- Try prompt engineering first. Often, a single well-crafted agent does the job.
- Check task independence. True parallelism means no agent relies on another’s output mid-process.
- Weigh costs. Coordination can make a $0.05 single-agent query balloon to $0.40 with multiple agents.
- Consider latency. Every handoff adds 100–500 milliseconds. If speed matters, multi-agent may be the wrong choice.
- Prepare for debugging. Multi-agent systems multiply failure points, making root-cause analysis harder.
These questions, Bhavsar suggests, reveal whether multi-agent complexity delivers value—or just overhead.
Actionable Takeaways for Builders
For builders, Bhavsar recommends restraint, adding that the place to begin is not with sprawling teams of agents but with a single, well-tuned system. Developers who learn to master prompt design and context management often find that one capable model handles far more than expected. Multi-agent setups should come later — and only when the scale of the problem justifies it. If the task involves thousands of independent subtasks, such as scanning large datasets or processing streams of content in parallel, the higher cost of coordination may be offset by the speed advantage.
Even then, the architecture should be temporary by design. Bhavsar advises thinking in terms of deletion: build orchestration layers so they can be removed when models improve enough to handle tasks on their own. Memory should be treated not as an afterthought but as critical infrastructure. The way agents pass selective context to one another determines whether the system functions smoothly or collapses under its own weight.
Finally, successful systems minimize the risks of conflict. Agents should focus on reading and analyzing data rather than writing or modifying it. Independent reads are safe; overlapping writes create costly, cascading errors. The lesson is clear—complexity should be added sparingly, with each design choice grounded in necessity, not novelty.
The appeal of multi-agent AI is easy to grasp: more specialists, faster results. But as Bhavsar concludes, the reality is somewhat less concrete. Coordination costs often outweigh the gains, and rapid improvements in single models risk making complex agent architectures a dead end. According to the Galileo Labs team, the key may be to start with single agents, then add multi-agent designs only where independence and scale demand it. And always build with the expectation that tomorrow’s models may make today’s clever architectures obsolete.
