Multi-Agent Orchestration: How to Make Different Agents Collaborate
Orchestration patterns for AI agents, typical causes of coordination failures, the role of MCP and A2A, and multi-agent economics: a practitioner's view.
Oleksandr Ivanchuk
Software Developer
A multi-agent system is not several language models running at the same time, but an organizational structure with a division of roles, rules for handing over work, and control of the result. In this article we examine which orchestration patterns actually work, why agents most often fail to "reach agreement" with one another, how much coordination costs, and under what conditions a multi-agent approach is justified for an industrial enterprise.
Introduction
Over the past two years, the focus of enterprise AI has shifted from individual assistants to systems in which several agents perform a shared task: one collects data, a second analyzes it, a third verifies it, and a fourth prepares the result. The idea is intuitively clear, since human teams work the same way. In practice, however, the gap between a demonstration and stable operation is wider here than in any other class of AI solutions.
Gartner predicts that over 40% of agentic AI projects will be canceled by the end of 2027 due to escalating costs, unclear business value, or inadequate risk controls [8]. In our practice, the cause of such outcomes rarely lies in the quality of the models themselves. Far more often it lies in the fact that coordination between agents has not been designed: the agents exist, but the system does not.
We wrote about how an agent differs from a chatbot in the article "AI Agent Is Not a Chatbot". Here we discuss the next level: what happens when there are several agents.
When One Agent Is No Longer Enough
The first question worth asking is whether a multi-agent architecture is needed at all. Anthropic's engineers state this directly in their overview of agentic systems: one should start with the simplest solution and add complexity only when simpler options have been exhausted [1]. The Cognition team goes further and argues that for many tasks a single agent with full context is more reliable than several agents that each see only fragments of the task, because decisions made independently begin to contradict one another [4].
Based on our observations, distributing work among agents is justified in three situations:
- The task decomposes into independent branches. For example, simultaneous analysis of data from different shops or different systems, where the results are consolidated only at the final stage.
- The volume of information exceeds the capacity of a single context. Each agent works with its own context window and returns a condensed result rather than the entire body of raw data.
- Separation of privileges is required. An agent that reads data from the ERP and an agent that has the right to create documents represent different access levels, and combining them in a single executor is not always acceptable from a security standpoint.
If none of these conditions is met, a multi-agent architecture adds complexity without tangible benefit.
Orchestration Patterns: Who Hands Work to Whom
Orchestration is the answer to three questions: who decides what to do next; what information each agent receives; who verifies the result. Most industrial implementations come down to a few basic patterns [1][7].
| Pattern | How the work is organized | When it is appropriate | Main risk |
|---|---|---|---|
| Sequential pipeline | Each agent processes the result of the previous one | Processes with fixed stages: extraction → verification → formatting | An error at an early stage propagates to the end |
| Routing | A dispatcher agent determines the type of request and passes it to a specialized executor | Heterogeneous requests: support, reference queries, applications | Misclassification sends the request to the wrong executor |
| Orchestrator and workers | A lead agent breaks down the task, distributes subtasks, and consolidates the results | Research and analytical tasks with an unpredictable structure | Vague assignments, duplicated work, high cost |
| Parallel execution with aggregation | Several agents independently solve the same or adjacent tasks, and the results are compared | Tasks where the reliability of the conclusion matters | A multiple-fold increase in costs |
| Executor and reviewer | One agent produces the result, another evaluates it against specified criteria | Documents, reports, calculations with formal requirements | The reviewer agrees with a plausible but incorrect result |
| Peer-to-peer interaction | Agents exchange messages without a central coordinator | Research scenarios, simulation | Endless dialogues, no one accountable for the result |
In our practice, the first three patterns and their combinations are used most often for production scenarios. Peer-to-peer interaction without a coordinator looks good in research papers, but in industrial operation it complicates the main thing: the ability to explain why the system made a particular decision.
Why Agents Do Not Collaborate
The most systematic study of this question was conducted by a group at the University of California, Berkeley. The authors analyzed more than 1,600 annotated execution traces across seven popular multi-agent frameworks and built a taxonomy of 14 failure types grouped into three categories [3]:
- System design issues. Poorly defined roles, an agent overstepping the boundaries of its role, loss of conversation history, unawareness of the conditions for terminating work.
- Inter-agent misalignment. An agent does not ask for clarification, withholds or fails to pass on important information, ignores a peer's result, or deviates from the task.
- Task verification and termination. Premature termination, missing or superficial verification of the result.
The authors' conclusion is consistent with what we see in deployments: a significant share of failures cannot be eliminated by replacing the model with a more powerful one. These are flaws of organizational design, not of an individual agent's intelligence. The analogy with a human team is apt here: a group of strong specialists without a division of responsibilities and rules for handing over work performs worse than a mediocre but well-organized one.
I consider it important to note the most common mistake we observe: an assignment from one agent to another is formulated in a single short sentence. The executing agent does not have the context that the orchestrator had and fills in the missing details at its own discretion. Anthropic describes the same problem in its own research system: without a detailed description of the objective, the expected output format, and the task boundaries, subagents duplicated one another's work or left gaps [2].
Contracts Between Agents: Protocols and Shared State
Agent collaboration requires the same things as the integration of any software systems: an agreed interface and a shared understanding of the state of the task. Two complementary standards have taken shape here over the past two years.
Model Context Protocol (MCP) describes how an agent connects to tools and data sources such as ERP systems, databases, and file storage [5]. It answers the question "what can the agent do in the outside world." We wrote in more detail about its role in the article on the standardization of AI integration with business systems.
Agent2Agent (A2A) is an open protocol that describes interaction between the agents themselves: how an agent advertises its capabilities, how it accepts a task, how it reports on progress and returns the result [6]. It matters where agents are built by different teams or vendors.
However, a protocol solves only the transport part. No less important is the question of shared state: where the plan is stored, who has the right to change it, and how an agent learns what has already been done. In the stable systems we have seen, intermediate results are stored outside the agents' context, in a structured store, and what is passed between agents is references and concise summaries rather than full texts. This reduces the loss of information during "retelling" and makes the course of the work verifiable.
The Economics of Coordination
A multi-agent system consumes substantially more computing resources than a single agent. According to Anthropic, agents typically use about 4 times more tokens than an ordinary conversation with a model, and multi-agent systems about 15 times more [2].
At the same time, these costs can pay off. In the same company's internal evaluation, a system with a lead agent and several subagents outperformed a single agent by 90.2% on research tasks, and the volume of tokens used by itself explained about 80% of the difference in results [2]. In other words, a multi-agent design is a way to "buy" quality at the expense of computation, and it makes sense only where the value of the result exceeds the cost of obtaining it.
For an enterprise this means a simple check before starting: how much one solved task costs and how much it saves. We examined the structure of such costs in detail in the article on the cost of owning an AI agent.
Specifics of the Industrial Context
In a production environment, the general requirements are supplemented by constraints that do not exist in office scenarios.
Separation of reading and acting. Agents that analyze SCADA or ERP data and agents that can modify records or initiate operations must be separated not only logically but also at the level of access rights. Any action with consequences for production goes through human confirmation. We described the approach to gradually expanding autonomy in the article on the trust boundary for AI agents.
Reproducibility. For every result it must be possible to reconstruct the chain: which agent received what, what it returned, and on what basis. Without this it is impossible either to investigate an incident or to pass an audit.
Predictable response time. Every additional agent means additional model calls. Scenarios in which an answer is needed within seconds are poorly compatible with deep agent hierarchies.
A typical example from our practice: preparing a consolidated report on production deviations. One agent retrieves indicators from production systems, a second matches them against planned data in the ERP, and a third produces an explanation for the shift supervisor. The system became stable not after the model was replaced, but after the format of input and output data had been fixed for each agent and a completeness check had been added before handover to the next executor.
Author's Assessment and Conclusions
Based on deployment experience, I will formulate several propositions that I consider key.
A multi-agent design is an architectural decision, not a sign of maturity. A system consisting of one well-equipped agent is often more reliable and cheaper. The move to several agents should be a response to a specific constraint: context volume, the need for parallelism, or separation of privileges.
The quality of collaboration is determined by the quality of assignments. The greatest effect in our projects came not from changing models, but from clearly described roles, exchange formats, and criteria for completing work. This coincides with the researchers' conclusions [3].
Verification must be a separate function. The agent that performed the work must not be the only one that evaluates its quality. Independent verification, whether automated or human, is built into the architecture from the very beginning.
Standard protocols reduce vendor dependence. MCP for access to tools and A2A for agent interaction make it possible to replace individual components without rebuilding the entire system [5][6].
The economics should be calculated before development begins. A multiple-fold increase in resource consumption is a property of the approach, not a flaw of the implementation. A multi-agent system is justified for tasks where the result has high value.
Making agents collaborate is first and foremost an organizational task, solved by the same means as in human teams: clear roles, rules for handing over work, control of the result, and accountability for it.
References
- Anthropic. "Building Effective Agents." 2024. https://www.anthropic.com/engineering/building-effective-agents
- Anthropic. "How We Built Our Multi-Agent Research System." 2025. https://www.anthropic.com/engineering/multi-agent-research-system
- Cemri M., Pan M. Z., Yang S. et al. "Why Do Multi-Agent LLM Systems Fail?" arXiv:2503.13657, 2025. https://arxiv.org/abs/2503.13657
- Cognition. "Don't Build Multi-Agents." 2025. https://cognition.ai/blog/dont-build-multi-agents
- Model Context Protocol. Official documentation. https://modelcontextprotocol.io/
- Agent2Agent (A2A) Protocol. Official specification. https://a2a-protocol.org/latest/
- Wu Q., Bansal G., Zhang J. et al. "AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation." arXiv:2308.08155, 2023. https://arxiv.org/abs/2308.08155
- Gartner. "Gartner Predicts Over 40% of Agentic AI Projects Will Be Canceled by End of 2027." 2025. https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027