The hidden risk in Agentic AI

In technology, history has a habit of repeating itself. Think back to the early microservices boom. What was supposed to deliver agility and scalability often resulted in the opposite: brittle, complex systems where every service depended on another. Many organisations discovered, too late, that they hadn’t escaped their old monoliths, they’d simply distributed them.

 

Today, we’re seeing the same pattern emerge with Agentic AI.

 

Businesses are rushing to deploy intelligent, autonomous agents to automate decision-making, improve efficiency, and personalise customer experiences. Yet, in their haste, many are connecting these agents through the same tightly coupled, point-to-point integrations that caused so much trouble in the microservices era.

 

It’s a recipe for another distributed monolith — and unless we change course, Agentic AI could face the same scalability, reliability, and innovation bottlenecks that once plagued early microservices systems.

 

 

The microservices déjà vu

When microservices first appeared, the promise was clear: smaller, modular components that could evolve independently. But many early adopters connected their services using synchronous API calls: Service A talking directly to Service B, which talked to Service C.

 

On paper, these looked like independent services. In practice, they were tightly bound together. If one service slowed down or failed, the entire chain could collapse. Teams had to coordinate releases across dozens of interdependent services, and debugging a single issue could take days.

 

This “distributed monolith” problem taught us a vital lesson: true independence requires loose coupling.

 

The solution came in the form of event-driven architecture (EDA). Instead of communicating through direct requests, services began exchanging events, or real-time signals that something had happened. This allowed each component to operate asynchronously, react to relevant events, and evolve independently. The result was a far more resilient and scalable system.

 

 

Agentic AI is falling into the same trap

Fast-forward to today, and Agentic AI – systems composed of multiple autonomous agents – is making the same early mistakes.

 

Take a typical enterprise AI assistant. It may include a sentiment analysis agent, a knowledge retrieval agent, a reasoning agent, and a response generation agent. Too often, these are linked through direct, synchronous calls. One agent depends on another to finish before it can act, creating a complex web of hidden dependencies.

 

The illusion of modularity quickly collapses under real-world conditions. One delay or failure can ripple through the entire system. Scaling becomes difficult, and updates require delicate coordination across multiple teams.

 

McKinsey recently described the solution as a new architectural paradigm — the agentic AI mesh that is capable of integrating both custom-built and off-the-shelf agents. In practice, that mesh looks a lot like event-driven architecture.

 

 

Loosen up: Event-driven AI systems

Event-driven architecture decouples agents from one another using an event broker, a kind of digital message hub that passes information between agents without requiring direct connections.

 

Here’s how it works: when something happens (“customer inquiry received” or “analysis complete”), an agent publishes an event. Other agents subscribe to the types of events they care about and respond when ready.

 

This seemingly small shift has huge advantages: 

• Resilience: If one agent fails, its events queue up until it recovers, rather than crashing the entire system.
• Scalability: Need more capacity? Simply add more agents — they’ll automatically consume from the same event streams.
• Flexibility: Agents can evolve independently, developed by different teams using different technologies. 

In short, EDA lets Agentic AI systems “loosen up” and that’s exactly what’s needed to avoid the brittleness of the distributed monolith.

 

 

Designed for asynchronous reality

Agentic AI systems are inherently asynchronous. Large language model responses vary depending on model load and complexity. Some tasks complete in seconds, others in minutes. And when humans are in the loop — say, approving a transaction or reviewing a recommendation — timelines become even more unpredictable.

 

EDA is built for that world. Instead of blocking while waiting for responses, agents publish and subscribe to events as they happen. That means workflows can run in parallel, one agent analysing sentiment, another retrieving data, another drafting a response, without getting in each other’s way.

 

This asynchronous model isn’t just technically elegant; it’s essential for real-world scalability and user experience.

 

 

Dynamic, observable, and compliant

Event-driven systems also bring better visibility. Every interaction is captured as an event, complete with context and timestamps. That makes debugging easier and ensures full traceability, crucial for regulatory compliance and explainability.

 

Enterprises can literally see how an AI system works, how decisions are made, what data was accessed, and which agents were involved. That kind of transparency builds trust, both internally and with customers.

 

Moreover, EDA allows for dynamic adaptability. As new agents are added, say, a specialised model for legal document review, they simply register their capabilities. The orchestration logic adapts automatically, integrating them into workflows without code changes or redeployments. The system grows smarter and more capable with minimal friction.

 

 

Building AI that scales with your business

We can’t afford to repeat the mistakes of the microservices era.

 

Agentic AI promises enormous value, but only if it’s built on a foundation that supports independence, resilience, and scalability. Event-driven architecture provides that foundation, decoupling agents, supporting asynchronous operations, and ensuring the system can evolve over time without collapsing under its own complexity.

 

In other words, EDA helps enterprises unlock the full potential of Agentic AI, without falling back into the trap of the distributed monolith. Those who embrace this approach early will be best positioned to scale responsibly and innovate sustainably in the age of intelligent automation. 

 

---

 

Ali Pourshahid is Chief Engineering Officer at Solace

 

Main image courtesy of iStockPhoto.com and Vertigo3d