The Multi-Agent Reality Check
Part 1 of 7 in the series "The Agent Coordination Gap"
Why Enterprises Are Deploying Dozens of Agents and None of Them Talk to Each Other
The Islands
A large financial services company deployed Microsoft Copilot across its productivity suite in early 2025. Six months later, its customer operations team rolled out Salesforce Agentforce to handle service inquiries. By the end of the year, IT had built custom agents on AWS Bedrock for fraud detection, and the supply chain group was piloting ServiceNow's agentic workflows for procurement approvals.
Each deployment followed its own business case. Each had executive sponsorship, a budget, and a measurable objective. And each operated in complete isolation from the others.
The Copilot agents could not see what Agentforce was doing with the same customers. The fraud detection agents had no way to share signals with the procurement agents, even when the same transaction triggered both. The ServiceNow workflows ran on different data, different models, and different governance rules than anything in the Microsoft or Salesforce environments. Four agent platforms, four sets of policies, four islands of automation with no bridges between them.
This is not a failure story. By conventional measures, each deployment was a success. But the company's AI strategy had produced something it never intended: a fragmented agent estate that replicated, in a more dangerous form, the integration problems the industry spent two decades trying to solve with enterprise service buses and API management platforms.
The difference is that these are not passive applications waiting for API calls. These are autonomous agents making decisions, taking actions, and generating commitments on behalf of the organization, with no coordination layer to ensure they are working toward the same objectives.
The Scale of the Problem
The financial services example is not unusual. It is the norm.
Salesforce's 2026 Connectivity Benchmark, surveying 1,050 IT leaders in partnership with Vanson Bourne and Deloitte Digital, found that the average enterprise now runs 12 distinct AI agents across its operations. That number is expected to reach 20 within two years. But the more consequential finding is what sits underneath: the average organization manages 957 applications, and only 27% of them are integrated. The agents sit on top of an application estate that was already fragmented. They inherit the fragmentation and add a new dimension to it, because unlike applications, agents act.
The agent count understates the problem. It measures only the agents that IT knows about. Airia's 2026 analysis of enterprise AI tool sprawl, drawing on data from Salesforce, Gartner, Netskope, and Cisco, found that the average large enterprise with more than 5,000 employees is running over 700 distinct AI-powered applications. Approximately 65 to 75% of those tools are unsanctioned by IT or security teams. The average enterprise employee uses 9.4 distinct AI tools in a given month, across personal accounts, employer-provided tools, and embedded AI features in existing software. The gap between what IT governs and what actually runs is not a rounding error. It is a structural condition.
OutSystems' 2026 State of AI Development report, surveying nearly 1,900 global IT leaders, confirms the anxiety this creates. 96% of organizations are already using AI agents in some capacity. 94% report concern that AI sprawl is increasing complexity, technical debt, and security risk. 38% are mixing custom-built and pre-built agents, creating stacks that are difficult to standardize and secure. And only a small fraction have established a centralized approach to agentic AI governance.
The pattern is consistent across the data: adoption is running well ahead of coordination. Organizations have agents. They do not have an agent strategy.
Why This Is Harder Than the Last Integration Problem
Enterprise integration is a problem the industry has been working on for decades. Service-oriented architecture, enterprise service buses, API management platforms, iPaaS: each generation of technology addressed some dimension of the challenge. The agent coordination problem borrows from all of them and adds complications that none of them were designed to handle.
The first complication is autonomy. Traditional integration connects applications that respond to requests. An API call goes out, a response comes back, and the calling system decides what to do next. Agents do not wait for requests. They observe, reason, and act on their own initiative within defined parameters. A customer service agent that detects frustration in a conversation may escalate the case, offer a discount, or route the customer to a specialist, all without a human or another system telling it to do so. When multiple agents operate this way simultaneously, across different platforms and with different objectives, the potential for conflicting actions grows with every additional agent.
The second complication is opacity. When two applications exchange data through an API, the interaction is logged, traceable, and deterministic. The same input produces the same output. Agent behavior is probabilistic. The same input may produce different outputs depending on context, model state, and the agent's reasoning chain. When an agent takes an action that conflicts with another agent's action, diagnosing why requires understanding not just what happened but how each agent reasoned about the situation. Traditional monitoring and observability tools were not built for this.
The third complication is commitment. Applications process transactions. Agents make commitments. A sales agent that promises a delivery date, a customer service agent that offers a refund, a procurement agent that approves a purchase order: these are not data transformations. They are business commitments that bind the organization. When agents from different platforms make conflicting commitments (a sales agent promises delivery by Friday, a supply chain agent has already allocated the inventory elsewhere) the result is not a data inconsistency. It is a broken promise to a customer.
The fourth complication is cross-vendor trust. Traditional integration operates within a trust boundary. The systems being connected belong to the same organization, run on the same infrastructure, and are governed by the same policies. Multi-vendor agent ecosystems cross trust boundaries by design. A Microsoft Copilot agent operating in one security context needs to coordinate with a Salesforce Agentforce agent operating in a different security context, with different data access policies, different model governance rules, and different audit requirements. The trust infrastructure for this does not exist.
The Vendor Interoperability Illusion
Every major platform vendor claims to support agent interoperability. The claims are technically accurate and strategically misleading.
Microsoft's Agent 365 positions itself as the enterprise AI control plane, offering governance and security across agent deployments. But the control plane works best, and in some cases only works, with agents that run within the Microsoft ecosystem. Salesforce's Agentforce 360 includes Multi-Agent Orchestration capabilities, but orchestration within the Salesforce platform is a different problem than orchestration across Salesforce, Microsoft, and ServiceNow simultaneously. AWS Bedrock AgentCore is framework-agnostic by design, but being framework-agnostic at the infrastructure layer does not solve the coordination problem at the application layer. ServiceNow's AI Control Tower governs agents within ServiceNow's platform boundary. SAP's Joule Studio offers agent-to-agent integration with Microsoft 365 Copilot, which is a step toward cross-vendor coordination, but one bilateral partnership is not an ecosystem.
The interoperability story is further complicated by the vendors' commercial incentives. Each platform vendor benefits when agents stay within its ecosystem. Cross-vendor coordination reduces switching costs, weakens platform lock-in, and makes it easier for customers to substitute one vendor's agents for another's. The incentive structure does not reward solving the coordination problem. It rewards appearing to solve it while keeping agents as close to the platform as possible.
Two open protocols have emerged to address this: the Model Context Protocol (MCP) for agent-to-tool connectivity, and Google's Agent-to-Agent Protocol (A2A) for agent-to-agent communication. Both have significant momentum. MCP has reached 97 million monthly SDK downloads and more than 9,400 public servers. A2A counts more than 150 organizations as supporters and sits under Linux Foundation governance. IBM's Agent Communication Protocol (ACP) merged into A2A in 2025, consolidating the standards landscape.
But protocol availability is not the same as enterprise readiness. MCP's OAuth 2.1 security layer is still being finalized. A2A's production deployment track record is thin relative to its organizational support. And neither protocol addresses the harder questions: What happens when agents from different vendors disagree? Who arbitrates? How is accountability assigned when an agent chain that spans three platforms produces a harmful outcome? The protocols provide the plumbing. The coordination logic, the governance framework, and the organizational design required to make multi-agent systems work at enterprise scale are problems the protocols do not solve and were never designed to solve.
The Coordination Tax
The absence of a coordination layer is not a theoretical concern. It has measurable costs.
BCG's 2026 research found that only about 6% of companies are capturing meaningful financial value from AI at scale. The remaining 94% are spending on AI but not generating proportional returns. One of the primary reasons, documented across BCG, McKinsey, and IBM research analyzed in the Arion Research AI Operating Model Gap series, is that AI investments are fragmented across functions, with no cross-functional integration to capture the value that sits at the boundaries between business units.
The agent coordination gap is the next iteration of this problem. An organization running 12 agents across four platforms is paying the coordination tax in several ways. First, in duplicate effort: agents in different platforms solving the same problem independently, each consuming compute, model inference costs, and engineering time without awareness that the work is already being done elsewhere. Second, in conflicting actions: agents making commitments or taking actions that other agents then need to correct, creating rework that would not exist if the agents could coordinate. Third, in governance overhead: each platform requiring its own governance framework, its own monitoring, its own audit trail, with no consolidated view of what the aggregate agent estate is doing. Fourth, in missed opportunities: value that can only be captured when agents share context across platform boundaries, which they cannot do without a coordination layer.
Gartner's projection that more than 40% of agentic AI projects will be canceled by the end of 2027 is, in part, a coordination story. The projects that get canceled will not fail because the agents did not work. They will fail because the agents worked in isolation, delivering point solutions that could not justify their cost without the cross-functional integration that was never built. Gartner analyst Anushree Verma put it directly: most agentic AI projects right now are early-stage experiments or proofs of concept that are mostly driven by hype and are often misapplied.
More than four in five IT leaders surveyed in the Salesforce Connectivity Benchmark believe that AI agents will create more complexity than value because of integration challenges and silos. 96% believe AI agent success depends on unified integration across systems. The enterprise knows the coordination problem exists. It has not yet built the infrastructure to solve it.
What the Coordination Layer Requires
The agent coordination problem is not a technology problem that technology alone can solve. It is an organizational problem that requires technology, governance, and organizational design working together.
On the technology side, the coordination layer needs five capabilities, described in the Arion Research Orchestration series as the Agent Service Bus framework. Capability Discovery allows agents to find each other and understand what each can do. Intent Resolution translates business requests into coordinated multi-agent actions. Contract Negotiation establishes the terms under which agents will collaborate, including data sharing, action boundaries, and escalation rules. Conflict Arbitration resolves disagreements when agents from different platforms recommend or take contradictory actions. And Routing and Orchestration directs work to the right agent or combination of agents based on capability, cost, and context.
On the governance side, the coordination layer needs decision authority frameworks that extend across agent boundaries. The Arion Research AI Operating Model Gap series introduced a three-tier decision authority model: Tier 1 (agent acts freely within defined parameters), Tier 2 (AI recommends, human decides), and Tier 3 (human only). In a multi-agent environment, the decision authority framework must also address which agent has authority when multiple agents from different platforms could act on the same business event. Without explicit cross-agent decision rights, the default is chaos: whichever agent acts first wins, regardless of whether it was the right agent for the situation.
On the organizational side, the coordination layer needs what the Operating Model Gap series calls cross-functional organizational design. Agent coordination does not happen in a single business function. It happens at the boundaries between functions, where a customer interaction triggers a sales action, a supply chain response, a financial transaction, and a compliance check, potentially involving agents from four different platforms. The organizational structure must support coordination at these boundaries, not just within functions.
This series will examine each of these dimensions across six subsequent articles: the standards landscape and what the protocols actually do (and do not do), the Agent Service Bus in practice, the agent conflict and arbitration problem, multi-agent governance at scale, the platform lock-in trap, and a practical roadmap for building the coordination capability.
The Three-Year Window
The agent coordination gap is widening, not narrowing. Every quarter that enterprises deploy additional agents without a coordination layer adds to the integration debt they will eventually need to retire. The organizations that build the coordination capability now, spanning technology, governance, and organizational design, will have a structural advantage that compounds in the same way the operating model advantages documented in the AI Operating Model Gap series compound: better coordination produces better outcomes, which builds organizational confidence, which justifies further investment in coordination, which produces better outcomes.
The organizations that wait for vendors to solve the coordination problem will wait a long time. The vendors are not going to solve it, because solving it is against their commercial interests. The coordination layer must be enterprise-owned. It must span platforms. And it must be treated as infrastructure, not as a project.
The multi-agent reality check is this: the first wave of agentic AI produced islands of automation. The second wave will be defined by whether organizations can connect those islands into a coherent system, or whether they remain stranded with dozens of agents that cannot talk to each other, making promises the organization cannot keep.
Strategy Playbook
1. Agent Estate Inventory. Before you can coordinate agents, you need to know what you have. Conduct a comprehensive inventory of every AI agent and AI-powered tool in the organization, including sanctioned deployments, shadow AI, and embedded AI features in existing applications. The Airia and Salesforce data suggest the true count is three to five times what IT currently tracks. Map each agent to its platform, its business function, its data access, its decision authority, and its governance framework. This inventory is the foundation for every subsequent coordination initiative.
2. Coordination Gap Assessment. For every pair of agents that could act on the same business event (customer inquiry, supply chain disruption, financial transaction), document whether a coordination mechanism exists. If one agent can make a commitment that another agent might contradict, that is a coordination gap. Prioritize the gaps by business impact: a conflict between a sales agent and a supply chain agent that results in a broken customer promise is higher priority than a redundancy between two internal reporting agents.
3. Cross-Platform Decision Authority Framework. Extend the three-tier decision authority model (Tier 1: agent acts freely, Tier 2: AI recommends and human decides, Tier 3: human only) to include cross-platform scenarios. For each business process that spans multiple agent platforms, define which agent has primary authority, under what conditions authority transfers, and what escalation path exists when agents disagree. This is an organizational design exercise, not a technology exercise. The people who own the business process must define the authority framework. Technology enforces it.
4. Coordination Layer Pilot. Select one cross-functional business process where agents from at least two different platforms need to coordinate (order-to-cash, customer onboarding, and incident response are common starting points). Build or deploy the minimum coordination infrastructure needed: shared context between agents, conflict detection, and an escalation mechanism. Measure the reduction in conflicting actions, duplicate effort, and governance overhead compared to the uncoordinated baseline. Use the pilot results to build the business case for enterprise-wide coordination infrastructure.
Arion Research advises enterprise leaders on AI strategy and the shift to a digital workforce.
