Your agents aren’t broken. But the infrastructure holding them together almost certainly is.
A fraud detection agent flags a suspicious transaction and then approves it, because it has no idea that bankruptcy papers were filed for that account 40 minutes earlier. An inventory agent places a large restocking order for a warehouse that went offline an hour ago. A customer service agent routes an urgent complaint to a team that just started a scheduled break.
These are not edge cases pulled from a cautionary whitepaper. They are the kinds of failures that enterprise architects describe, in private, when asked why their agentic AI deployments did not survive contact with production.
The agents themselves worked fine and as designed. Everything around them didn’t.
According to S&P Global Market Intelligence, 42% of businesses are now scrapping most of their AI initiatives — up sharply from 17% the year before, based on a survey of more than 1,000 respondents across North America and Europe. The RAND Corporation, citing industry-wide estimates in its 2024 analysis of AI project failures, notes that more than 80% of AI projects fail — roughly twice the failure rate of comparable non-AI technology projects. In nearly every post-mortem, the model is not the primary culprit. The culprit is what surrounds it: how data flows, how systems communicate, how agents coordinate when conditions shift.
Getting this right is the difference between AI that genuinely transforms operations and AI that generates impressive demos and expensive write-offs.
Agentic AI is architecturally different
Traditional AI systems are reactive. You send a query; the model returns a response. The interaction is bounded, synchronous, and human initiated. Most enterprise AI today — chatbots, classification pipelines, recommendation engines — fits this pattern, and the architecture that supports it is essentially the architecture enterprises already have — APIs, databases, and request-response integration.
Agentic AI breaks this model in four meaningful ways. Agents initiate actions proactively, responding to environmental signals rather than waiting for human prompts. They orchestrate multi-step workflows autonomously across complex processes. They adapt their behaviour based on changing conditions rather than executing fixed decision trees. And they coordinate with each other — not just with humans or APIs — to accomplish objectives that no single agent could complete alone.
The EY Technology Pulse Poll (April 2025), surveying more than 500 US technology leaders at organisations with 5,000 or more employees, found that 48% are already adopting or fully deploying agentic AI, with half expecting most of their AI to be autonomous within 24 months. The appetite is clearly there. The architectural readiness, in most cases, is not.
The numbers from Deloitte’s 2025 Emerging Technology Trends study — based on a survey of 500 US technology leaders — are even more revealing about the gap between intent and reality: while 38% of organisations are piloting agentic solutions, only 11% are actively using these systems in production. A further 35% have no formal agentic strategy at all. Enthusiasm is not the constraint. Infrastructure is.
The integration gap nobody discusses
Enterprise integration has been dominated by APIs for over a decade, and for good reason. APIs are well-understood, well-tooled, and excellent at what they do: exposing system functionality and data on demand. The problem is that ‘on demand’ is precisely the wrong model for autonomous agents.
Agentic systems need to know when something happens, not just retrieve data when asked. That gap — between point-in-time access and real-time awareness — is where most agentic deployments break down. Deloitte’s Tech Trends 2026 report identifies legacy system integration as the primary infrastructure obstacle, noting that most agents still rely on APIs and conventional data pipelines to access enterprise systems, which creates bottlenecks that limit their autonomous capabilities.
The polling problem
Without real-time event notifications, agents resort to polling: repeatedly querying APIs to detect changes. A fraud detection agent polling a transaction feed every few seconds is still operating on stale data. More fundamentally, polling locks agents into a reactive posture at the exact moment they need to be proactive.
Synchronous brittleness
When an agent’s workflow depends on sequential API calls, a single slow or unavailable service stalls everything downstream. This fragility is one reason why a Gartner survey found that, on average, only 48% of AI projects make it into production — and why the average journey from prototype to production takes eight months.
State fragmentation
Multiple agents calling different APIs at different moments will inevitably operate on different snapshots of reality. When agents make decisions based on inconsistent state, the results range from redundant actions to directly contradictory ones. In financial services, healthcare, and supply chain environments, this is not a theoretical concern.
APIs tell agents what exists. Events tell them when to act.
Events: the coordination layer agents need
Event-driven architecture (EDA) is not a new idea. Enterprises have used it for decades in domains where real-time responsiveness is non-negotiable: financial trading, logistics, telecommunications. What is new is its relevance to AI — specifically, its role as the coordination layer that autonomous agents need but API-only architectures cannot provide.
The core principle is straightforward. Rather than agents polling systems for updates, systems emit events when something meaningful happens. Agents subscribe to the events relevant to their function and act when those events arrive. The result is real-time awareness without the overhead of continuous polling, and asynchronous coordination without the brittleness of synchronous dependency chains.
Events address each of the integration problems outlined above. Real-time triggers tell an agent precisely when to act, rather than requiring it to guess through polling. Multiple agents can respond to the same event simultaneously, turning sequential processing into parallel coordination. Events can be persisted and replayed, so a temporarily unavailable system does not cause lost coordination. And new agents can join an ecosystem simply by subscribing to relevant event streams, without modifying existing integrations.
It is worth being explicit about one thing: EDA does not replace APIs. An event-driven agent still needs API access to retrieve data, execute transactions, and interact with external systems. The two patterns are complementary. APIs provide the ‘what’ — access to data and functionality. Events provide the ‘when’ — real-time triggers and coordination signals. Production agentic systems need both.
What production architecture requires
The gap between an agentic proof-of-concept and a production agentic system is largely an architectural gap. The components that close it share four characteristics.
An asynchronous communication backbone
An event streaming platform that decouples producers from consumers, provides reliable ordered message delivery, and handles speed mismatches between systems. This is what allows agents to scale independently without re-engineering the integration layer every time a new agent is added.
Intelligent orchestration
A layer that maintains awareness of which agents exist, what they are capable of, and which tasks they are authorised to handle. This decomposes incoming requests into discrete tasks, routes each to the appropriate agent, and manages sequencing across complex workflows. Emerging standards such as the Model Context Protocol (MCP) and the Agent-to-Agent Protocol (A2A) are beginning to formalise how agents connect to tools, data sources, and each other — a development Gartner predicts will push 40% of enterprise applications to include task-specific AI agents by end of 2026, up from less than 5% in 2025.
Selective data handling
One of the less obvious production principles is minimising what gets passed to language models. Pushing entire datasets into an LLM is expensive, slow, and increases hallucination risk. Well-designed systems perform retrieval, filtering, and transformation outside the model, sending only what is necessary for the reasoning task.
Observability from day one
Autonomous agents operating across critical business processes require the same infrastructure as any distributed system: structured logging, distributed tracing, retry logic, and failure handling. An unobserved agent failure in a payment workflow is not a monitoring gap. It is a business risk. Notably, Deloitte’s 2025 survey found that 93% of AI budgets go towards technology while only 7% fund training and governance readiness — a ratio that helps explain why observability is consistently the last capability enterprises build and the first one they regret not having.
A production AI system looks less like a chatbot, more like microservices.
A practical sequence for getting started
Architectural transformation does not happen in a single project. But there is a sequence that enterprise teams have found effective.
- Audit your current integration architecture. Identify where synchronous bottlenecks create real business risk. This surfaces the specific failure modes that event-driven patterns will address.
- Identify two or three high-value processes that are currently slow because they wait for approvals, data availability, and system responses. Real-time event awareness produces immediately measurable improvement here.
- Build the event-driven foundation before you build the agents. Most teams start with the AI. But agents built on polling-and-API architectures hit the same walls that stalled earlier initiatives. The foundation must come first.
- Design agents with narrow scope, clear input/output contracts, and explicit failure handling. Agents that do too much fail in opaque ways. The microservices discipline that has served distributed systems teams well applies directly here.
- Invest in observability before you need it. The enterprises scaling agentic AI successfully are not those with the most sophisticated models. They are those with the clearest visibility into what their agents are doing and why.
The stakes are higher than they appear
Gartner predicts that over 40% of agentic AI projects will be cancelled by the end of 2027 — not because the technology is immature, but because of escalating costs, unclear business value, and inadequate risk controls. That is a striking forecast for a technology enterprises are rushing to adopt.
Deloitte’s TMT 2025 Predictions report estimated that 25% of genAI users would launch agentic pilots or proofs-of-concept in 2025 growing to 50% by 2027. Yet Deloitte’s own Tech Trends 2026 study, published just months later, found that only 11% of organisations have agents running in production. The gap between those two numbers is the integration problem in statistical form.
The pattern is visible in India’s enterprise AI landscape. According to the EY–CII ‘AIdea of India: Outlook 2026’ report — a survey of 200 organisations across more than 20 industries — 47% of Indian enterprises now have multiple genAI use cases live in production, and 76% of business leaders believe AI will have significant business impact. Yet the same report found that more than 95% of those organisations allocate less than 20% of their IT budgets to AI. High adoption confidence, modest infrastructure investment: the integration gap is not a Western phenomenon. Nowhere is it more sharply illustrated than in India’s Global Capability Centre ecosystem, where the EY GCC Pulse Survey 2025 found 58% of centres are currently investing in agentic AI and another 29% are planning to within a year — yet BCG research on the same sector found just 5% of AI use cases reaching robust production deployment. The ambition is real. The architectural foundation to support it, in most cases, is still being built.
The AI models available today are genuinely capable. The constraint on enterprise agentic AI is not what they can do in isolation — it is whether the surrounding architecture can support them as they operate in coordination, at scale, in real time. As Deloitte’s Tech Trends team put it plainly: “If you just take your existing workflow and try to apply advanced AI to it, you’re going to weaponize inefficiency.”
Event-driven architecture is the most mature, most battle-tested answer to that infrastructure challenge currently available. The patterns are understood, the tooling has matured, and the enterprises that have deployed EDA in financial services, logistics, and telecommunications have been operating real-time, event-coordinated systems for years. The question is whether AI teams are having conversations with the integration architects who already know how to build this way.
The foundation determines the ceiling
The organisations that get agentic AI right do not treat it as a procurement decision. They treat it as an architectural commitment. APIs remain essential — but they are the right infrastructure for a world where AI waits to be asked. Agentic AI needs to know when to act, not just how.
Building that event-driven foundation is the work that separates enterprises who will scale autonomous intelligence from those who will spend the next three years re-platforming after their first generation of agents never reaches production. The foundation determines the ceiling. Build accordingly.
