DeepMind: Does Adding More Agents Make Results Worse?

The AI industry has long run on a simple logic: more is better. More parameters, more data, more compute. Now DeepMind is challenging the next iteration of that idea: the belief that increasing the number of AI agents inside a system automatically increases its capabilities. The company's new research suggests that multi-agent architectures have a structural ceiling, and approaching it could be costly for those who have bet on agent scaling as the main way forward.

The idea of multi-agent systems is not new in itself. Over the past two years, leading labs such as OpenAI, Anthropic and Google have actively promoted a concept in which several specialized AI agents work together, dividing tasks and cross-checking each other's results. The assumption was that this architecture mimics collective intelligence: one agent writes code, another tests it, a third hunts for errors, and an overall coordinator oversees the process. The logic seemed airtight, until DeepMind started measuring what happens in practice.

The research documented a counterintuitive effect: beyond a certain threshold, adding new agents does not improve the result but worsens it. The cause lies in coordination costs. Every new agent in a system is not just extra computing power but also a new source of potential contradictions. Agents must reconcile intermediate results, pass along context and resolve conflicting interpretations. With few participants, this overhead is negligible. As their number grows, it starts to eat up the very gain the system was built to deliver. At some point the system stops being an orchestra and turns into a crowd.

Technically, the problem is compounded by the fact that current language models lack a reliable mechanism for resolving contradictions between agents. When two agents reach different conclusions, which happens more often the harder the task, the system needs an arbiter, a voting protocol, or a rollback to one of the options. Each of these introduces its own distortions. The arbiter can itself be wrong. Majority voting kills unconventional but correct solutions. A rollback means part of the work was done in vain. None of this reflects bugs in specific implementations; these are fundamental properties of distributed systems, which engineers have wrestled with for decades even in classical software.

For the industry, the finding has serious practical consequences. Startups and large companies have invested significant resources in so-called agent frameworks, including Microsoft's AutoGen, CrewAI, LangGraph and many other tools built specifically to orchestrate large numbers of agents. The thesis that agent scaling compensates for the limits of individual models has become almost dogma in tech pitch decks. If DeepMind is right, some of these architectural decisions will have to be reconsidered not years from now, but today.

At the same time, it is important not to overstate the pessimism of the study. The "agent ceiling" is not a verdict on the multi-agent approach as such, but rather a signal that scaling must be smart, not mechanical. Systems with a small number of well-specialized agents, clearly separated areas of responsibility and minimal task overlap continue to show real performance gains. The problem arises when developers add agents on a "more is better" basis without thinking about how coordination between them works.

DeepMind's finding fits into a broader discussion about the limits of scaling in AI, which has picked up noticeably in recent months. After several years in which more compute almost automatically delivered better quality, the industry increasingly faces diminishing returns, whether in pretraining large models or, now, in agent architectures. This does not mean progress has stopped. It means simple recipes are ceasing to work, and quantitative growth must give way to qualitative architectural solutions. For the labs competing for leadership in the era of agentic AI, DeepMind's results are no reason to panic, but they are a reason to seriously rethink how exactly they plan to build next-generation systems.