Ants don’t follow orders; they follow signals.
With no central command, they coordinate through simple rules and real-time feedback. They build tunnels, defend their territory, and find food. It’s messy, efficient, and remarkably adaptive. In AI terms, it’s not far off from what we call swarm intelligence.
Contact centers aren’t quite colonies, but they face a similar challenge: complex work, distributed across agents, often under pressure. And today, the job is too big for one AI agent to handle alone. A single AI agent might manage small talk or surface-level queries. But, can it handle identity checks, tiered troubleshooting, or nuanced upsells in the same breath?
That’s why in the near future, customer experience (CX) automation isn’t a smarter agent. It’s a smarter system.
Multi-agent systems (MAS) break the task apart: they delegate subtasks to specialized AI agents, each trained for a different function. One handles authentication. Another handles pricing logic. A third escalates edge cases.
Together, they respond faster, adapt better, and fail (if at all) more gracefully.
Monolithic AI agents weren’t built for collaboration
Most enterprise CX systems today still rely on what you might call “monolithic” AI agents, or single-agent systems designed to manage entire conversations on their own. But as customer expectations grow and workflows get more complex, this model is beginning to show its cracks.
| Limitation | What we’re seeing |
| Handling multi-step tasks | Typically, single-agent models can only focus on one task at a time. That’s a problem in real-world CX, where multitasking, clarifying intent, and adapting mid-conversation are often the norm. Multi-hop agents consistently outperform static ones in these kinds of scenarios. |
| Memory across sessions | Most monolithic AI agents forget everything once the session ends. That means repeating yourself, losing context, and missing the chance to personalize. LLMs don’t retain long-term memory by default—they need external memory systems to track anything beyond the current interaction. |
| Balancing multiple goals | Monolithic agents are often built to do one thing well, like responding fast. But CX requires more than that. You need agents that can weigh things like speed vs. compliance or cost vs. satisfaction. That’s where utility-based or multi-agent systems do better. |
1. They struggle with multi-step reasoning and dynamic task handling
Even with LLMs, most single-agent systems still think in straight lines. They handle one step at a time, which works fine for simple requests. But compound tasks (the kind that require holding context, switching goals, or asking follow-up questions) tend to break them.
These systems are brittle by design: without a way to reason across steps or delegate internally, they either stall or escalate. Not because the task is too hard, but because they’re not built to unpack it, i.e., deconstruct or recompose it in real time.
2. They lack persistent memory, which limits continuity and personalization
Most monolithic agents are session-bound. Once a call or chat ends, so does the context. There’s no long-term memory of past interactions, preferences, or outcomes.
And while LLMs can hold short-term context in a window, that doesn’t translate to customer-level recall across sessions—unless you bolt on external memory systems. The results, as you can guess, equate to disjointed experiences, redundant steps, and missed opportunities for tailored support.
3. They’re not built to balance competing objectives
Typically, single-agent systems are optimized for one goal, like minimizing handle time. But real-world CX rarely has a single objective. Agents need to weigh speed against regulatory compliance, customer satisfaction against cost, or upsell opportunity against call resolution.
Generalist agents don’t natively evaluate those trade-offs. Without a utility-based architecture or multi-objective decision framework, they fall short in edge cases and escalate unnecessarily.
Specialized AI agents work better when they work together
One agent can’t do it all, and it shouldn’t have to.
MAS are built around the idea of delegation. Instead of stretching a single AI agent across every use case, you assign different agents to handle specific tasks. That means better performance where it counts.
Let’s say you need to verify identity while troubleshooting an issue and handling a billing query. MAS lets those requests run in parallel, with each agent focused on what it does best. This specialization improves accuracy, and fault tolerance means that if one agent drops the ball or hits a dead end, the workflow doesn’t end. The task can still be redirected to a different agent.
Essentially, there’s no single point of failure. And then, there’s also personalization. You can route interactions based on a customer’s preferences or personality, assigning the agent best suited to respond in a way that resonates.
But here’s the challenge: coordination
When you have multiple agents in play, switching between them can easily break the flow. The experience starts to feel fractured, as the wrong agent might jump in at the wrong time, or take on something it’s not equipped to handle.
In other words, when it’s done right, MAS can unlock flexibility and growth. But without strong conversation management, it can feel more like a chorus of voices than a single, coherent conversation. It’s also not optional because the agent might mistakenly re-route the task at the wrong stage, which can impact the entire experience.
That’s why the orchestration layer matters. You need tight control over who speaks when, how handoffs happen, and how context is preserved in the background.
What it takes to build an intelligent MAS
Behind the scenes of every MAS lies an architectural decision that shapes how agents communicate, collaborate, or sometimes compete. These choices define how well your system scales, adapts, and holds up under pressure.
Centralized, decentralized, and hybrid structures
At a high level, MAS architectures can be organized in different ways, each with its own tradeoffs:
- Centralized: One agent (or controller) calls the shots. This simplifies coordination and ensures consistency, but it also potentially creates bottlenecks.
- Hierarchical (a structured version of centralization): Agents are layered, i.e., strategic agents up top, tactical agents below. This divide-and-conquer model offers structure and specialization, but risks latency and rigidity as coordination grows more complex—for now, until technology evolves.
Decentralized: Agents make decisions independently, based on local context and peer communication. You get scalability and resilience, but at the cost of global alignment.
What this looks like in practice
Take call center orchestration. A hierarchical MAS might use a routing agent up top with a fleet of domain-specific agents underneath, like for claims, billing, or cancellations. This aligns well with real-world workflows, but as one study found, communication complexity balloons quickly as you scale systems. On the flip side, a decentralized peer-to-peer setup was faster to adapt and easier to scale, even if both models hit the same service-level benchmarks.
Another example: In multi-robot coordination, researchers recently showed that decentralization can still match the performance of a centralized system—if agents are trained using game-theoretic strategies that let them make smart decisions independently. It’s a reminder that architecture doesn’t just affect structure—it influences learning, speed, and robustness, too.
Image source: Overview of the Hierarchical System architecture
Cooperation, competition, or something in between?
The other layer to consider is how agents relate to each other:
- Cooperative systems work toward a shared goal (think: better CSAT).
- Competitive systems have conflicting goals (like simulated adversaries in testing environments).
- Mixed-motive setups fall somewhere in between.
For contact center automation, you’re usually working in a cooperative setting: agents share context and collaborate to complete a task (similar to Theory of Mind). But there’s growing interest in self-competitive models too, where agents simulate adversarial inputs or user behavior to strengthen their own performance.
This is where simulation agents can act as internal challengers, helping refine behavior before it hits production.
Soon, CX will belong to systems, not silos
It’s clear that advanced CX systems are starting to look more like cognitive architectures than traditional automations. On the surface, you’ve got a fast, fluent model like GPT-4.1 leading the conversation. Underneath, slower, task-focused agents like o3 handle logic, retrieval, and execution.
This “system 1 meets system 2” setup is already effective. OpenAI’s benchmarks show that models do better when strong instruction-following is paired with structured tool use. In other words, whether it’s one agent or many, the systems that win will be the ones doing the right things at the right time.
The next generation of CX systems won’t be stitched together from isolated tools and single-purpose agents. It’ll be powered by AI agents that can actually work together to coordinate, adapt, and share context across the entire customer journey.
And over time, that becomes the baseline for delivering enterprise-grade experiences that feel seamless to customers, and scalable for the business.
