Part 2 in the Multi-Agent Orchestration series
In Part 1 of this series , we made the case that multi-agent orchestration amplifies integration complexities rather than solving them. If your systems lack the APIs, data quality, and real-time synchronization that AI agents require, adding more agents won’t fix those gaps.
Now on to what integration-ready actually looks like.
Integration work should be treated as a prerequisite to agent-to-agent orchestration. Otherwise, an AI deployment may surface issues that are difficult to address (and that could have been avoided). Galileo warns of sophisticated hallucinations, for example:
- Contract review tool generating summaries with case law citations that don’t exist
- Procurement bots generating detailed vendor contracts for phantom suppliers
- Telco ops agents triggering response to non-existent “critical nationwide outages”
Avoiding these outcomes starts with the integration layer.
4 Requirements for Multi-Agent Orchestration
These were introduced in Part 1. Here’s greater detail on what each requirement looks like at the implementation level.
Unified Customer Identity
This means a single customer record accessible across voice, chat, CRM, billing, and support history (not matching by email in one system, phone number in another, and account ID in a third). AI agents need to resolve “who is this customer” before they can coordinate on “what does this customer need.” If your systems disagree on customer identity, orchestration breaks down at the first handoff.
API-First Architecture
Systems need to expose data through documented, versioned APIs that AI agents can query programmatically. Screen scraping, manual exports, and batch file transfers don’t qualify. The MCP that enables AI agents to access enterprise systems requires programmatic access. If your billing system can only be queried through a legacy terminal interface, no amount of protocol standardization helps.
Data Governance
for AI Agent Access This means clear policies on what data AI agents can access, what actions they can take, and what requires human approval. It’s almost always a mistake to give AI agents the same permissions as human agents by default.[RH2.1] When multiple agents coordinate, you need to know which agent authorized what action. Audit trails become essential. A single AI agent making a questionable decision is traceable. Multiple agents passing context to each other without clear governance is not, and the problem may well compound (fast).
Real-Time Data Synchronization
Changes in one system need to be reflected in others within seconds. Delays, overnight batch jobs, and manual reconciliation processes introduce drift. Real-time sync solves a central problem: if your CRM shows a different balance than your billing system, which one does the Payment Agent trust? In single-agent automation, a human can resolve the discrepancy. In multi-agent orchestration, that discrepancy propagates across every agent in the workflow.
Where Integration Gaps Surface
Integration gaps don’t announce themselves during planning. They surface during deployment, often in predictable patterns.
Authentication Handoff: An AI agent authenticates a customer through voice biometrics. But the authentication context doesn’t transfer to the next system in the workflow. The customer has to re-verify. Trust erodes before the interaction even begins.
The Data Discrepancy: A customer upgraded their service plan an hour ago. The billing system reflects it, but the support agent’s CRM still shows the old tier. The AI agent denies a feature request the customer already paid for.
The Missing History: An AI agent can access the current support ticket but not the three previous interactions that explain why the customer is frustrated. Without that context, the agent treats a repeat issue as a new one. The customer feels unheard.
The Permission Gap: An AI agent determines that a refund is warranted. It can see the transaction, verify the discrepancy, and identify the resolution. But it can’t process the refund because the integration wasn’t built with write access. Escalation required. The automation promise breaks.
These patterns share a common thread: the integration was built for human workflows, not AI agent workflows. Humans can work around gaps. They can check another system, ask a clarifying question, or escalate with context. AI agents operating autonomously need the integration to be complete.
A Practical Assessment
Where does your contact center stand? A quick diagnostic:
Foundation Missing
- Customer identity is fragmented across systems
- Key systems lack API access
- No formal data governance exists for AI agent access
- Data synchronization is batch-based or manual
Implication: Single-agent automation will struggle with data access. Multi-agent orchestration is not viable until these fundamentals are addressed. Start here.
Foundation Partial
- Customer identity is unified in some channels but not all
- Some systems are API-accessible; others require workarounds
- Data governance exists but wasn’t designed with AI agents in mind
- Real-time sync works for some data, batch for others
Implication: Single-agent automation is possible for contained use cases. Integration gaps will surface quickly and will need to be addressed before expanding scope.
Foundation Solid
- Unified customer identity exists across all channels
- Core systems follow API-first architecture
- Data governance policies account for AI agent access and auditability
- Real-time synchronization is in place across systems
Implication: Ready to scale single-agent automation and prepare for orchestration. Focus shifts to trust-building, analytics instrumentation, and monitoring A2A/MCP developments.
Most contact centers fall into the “Foundation Partial” category. Some integration work has been done, often for previous initiatives like omnichannel deployment or CRM consolidation. But gaps remain, and those gaps become visible when AI agents start operating.
The Integration Roadmap
For organizations still building their integration foundation, here’s a practical sequence. Timelines are directional and vary based on starting point and complexity.
Phase 1: Audit and Prioritize
Get a clear picture of what exists, what’s missing, and what matters most for your initial AI deployment, such as:
- Mapping which systems AI agents will need to access for target use cases
- Identifying which systems have API access and which don’t
- Documenting how customer identity is resolved across systems
- Flagging data governance gaps
Phase 2: Close Critical Gaps
Not everything needs to be solved at once. Prioritize based on your target use cases, for example:
- Building or exposing APIs for systems that lack them
- Evaluating whether middleware or replacement makes sense
- Implementing a customer identity resolution layer if one doesn’t exist
- Establishing data governance policies for AI agent access
- Addressing real-time sync requirements for the data your AI agents will need.
Phase 3: Validate with Single-Agent Deployment
This is the approach we outlined in Part 1’s crawl-walk-run framework. The goal isn’t just to automate a workflow. It’s to validate that your integration foundation works. Measure where issues surface. Iterate on infrastructure before scaling.
For example, deploy single-agent automation for a contained use case such as pre-call screening or appointment confirmations. Something with high volume and clear success criteria.
Phase 4: Prepare for Orchestration
By the time orchestration capabilities reach production, your infrastructure should be ready to use them. During this phase, you may need to:
- Add instrumentation for multi-agent handoffs
- Build audit trail capabilities that track context as it passes between agents
- Test A2A and MCP compatibility as vendor features ship
The Path Forward
The protocols are standardizing. Vendor capabilities are shipping. The question is whether your infrastructure will be ready to use them. With orchestration capabilities shipping in early 2026, organizations with solid foundations will be positioned to act while others are still closing integration gaps.
That work starts now, while there’s enough time to do it right.
Bucher + Suter helps contact centers build the integration foundation that makes AI agent deployments work. If you’re evaluating where to start, let’s talk.
