Agentic AI repeats same old enterprise adoption cycle

The pitch sounded perfect. A large regional distributor needed to build a new sales transaction management system. The goal was straightforward: automate parts of order intake, discount approvals, exception handling, customer communications, and inventory checks. It was not a trivial system, but it was also something the industry had built before.

Then the vendor presentations began. Every software provider seemed to have a new agentic AI story. Their platforms had agents that could make decisions, orchestrate workflows, interpret customer intent, route exceptions, and learn from business context. One vendor described its offering as a common LLM brain that could make decisions as if the company had hired 10,000 experts, except those experts were not on the payroll. That line was from an actual sales pitch, and it landed well in the boardroom.

The company decided to go agentic. The architecture would use AI agents to manage decision flows, invoke tools, check policies, interact with enterprise systems, and escalate only when needed. It looked modern. It looked strategic. It looked like the future. Then reality arrived.

Building the system required far more integration work than expected. Each agent needed access to clean data, governed APIs, business rules, security controls, observability, exception handling, and human override mechanisms. The team had to build guardrails around decisions, logging around reasoning, test harnesses for unpredictable outcomes, and new operational processes for things traditional systems handled more predictably.

Costs ballooned. Security reviews took longer. Operational complexity increased. The project ultimately ran fine once in production, but six months later, the company realized the uncomfortable truth: the system cost roughly 20 times more than a traditional architecture would have cost when all supporting complexity was included, and it delivered about the same ROI.

I am hearing versions of this story once or twice a week from clients, colleagues, and friends. Agentic AI is powerful. It is also being pushed into places where simpler technology would deliver the same business value for far less money.

Doomed to repeat history

None of this is new. The names change, the diagrams change, the conference sessions change, but the pattern is familiar. A technology or architectural approach emerges. It solves a real problem. Early adopters show impressive results. Vendors package it. Analysts name it. Thought leaders explain it. Conferences celebrate it. Then, almost overnight, every enterprise architecture discussion starts with the trend instead of the business problem.

We saw this with cloud-native. We saw it with microservices. We saw it with service-oriented architecture. We saw it with distributed objects, CORBA, and other approaches that promised flexible, reusable, distributed systems.

Each of these patterns had value, and each solved real problems. Each also caused expensive failures when adopted as a default answer rather than as a fit-for-purpose architecture.

SOA sold us reuse and flexibility

Service-oriented architecture was a good idea. Break capabilities into services. Expose them through contracts. Reuse business functions across applications. Reduce duplication. Create an architecture that could evolve.

The plus side was real. SOA gave enterprises a language for service reuse and integration. It pushed teams away from tightly coupled monoliths and point-to-point chaos. It helped organizations think in terms of business capabilities rather than just applications.

The minus side was also real. SOA became expensive and complex very quickly. Enterprise service buses turned into central chokepoints. Governance became heavyweight. Teams spent more time debating service contracts, standards, registries, and middleware than delivering business features. In many companies, SOA became an architecture tax.

It fell short because the cost of doing it “properly” often exceeded the value of the reuse it promised. We do not talk about SOA as much today because much of it was absorbed into APIs, integration platforms, and service-based design. The label faded after too many projects became too large, too slow, and too expensive.

Microservices promised speed

Microservices arrived as the antidote to large, slow systems. Smaller services. Independent teams. Independent deployment. Better scalability. Faster change.

Again, the pluses were real. For organizations with strong devops practices, mature automation, disciplined domain boundaries, and high-scale needs, microservices worked well. They allowed teams to move independently and scale parts of systems without scaling everything.

The minuses were predictable. Many companies took ordinary applications and shattered them into dozens or hundreds of services. They traded code complexity for network complexity. They created distributed failure modes, data

[…]
Content was trimmed to protect the source. Please visit the original article for the full text.

This article has been indexed from InfoWorld