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 consistency problems, monitoring challenges, testing headaches, and operational overhead they were not prepared to manage.
Microservices were often sold as a path to agility. In many enterprises, they became a path to higher cloud bills, more meetings, and slower troubleshooting. The industry learned painfully that microservices are not a maturity shortcut. They require maturity first.
Cloud-native sold us modernization
Cloud-native architecture, containers, and Kubernetes brought another wave of enthusiasm. The idea was compelling: portable workloads, declarative deployment, elastic scaling, automated recovery, and a modern operating model.
The plus side is still strong. Containers are useful. Kubernetes is powerful. Cloud-native patterns can support resilience, portability, and rapid deployment. For high-scale digital businesses, platform teams, and applications requiring elastic operations, the value is obvious.
The minus side is cost and complexity. Many enterprises moved systems into containers and Kubernetes without a clear reason. They added clusters, service meshes, observability stacks, platform engineering teams, security layers, and specialized skills. In many cases, the architecture nearly doubled the cost of running systems that did not need that level of abstraction.
Cloud-native is often excellent architecture, but it is not universally applicable. That distinction got lost when every vendor, every consulting firm, and every internal technology strategy suddenly had to be cloud-native.
Agentic AI is next
Agentic AI is now moving through the same cycle. The potential is real. Agents can automate complex workflows, reason across data, interact with tools, and support tasks that were difficult to automate a few years ago.
The danger is that enterprises will assume agentic AI belongs everywhere. It does not.
Agentic systems add costs that traditional systems often avoid. They require model access, prompt management, tool orchestration, evaluation frameworks, security controls, audit trails, human-in-the-loop design, data governance, and new operational skills. They introduce nondeterministic behavior into processes that may require deterministic outcomes. They can make simple automation much more expensive than it needs to be. In some cases, the value will justify the cost. In many cases, it will not.
Value comes first
Enterprises should start with value, not architecture. If agentic AI reduces labor, improves customer experience, handles exceptions better, or enables a capability that traditional systems cannot deliver economically, then it deserves serious consideration. But the value must be measurable. Vague promises of automation are not enough. If a traditional workflow engine, rules platform, API integration, or conventional application can deliver the same result at one-tenth the cost, that matters.
Agentic AI works best where the problem requires interpretation, adaptation, and semi-autonomous action. It is less compelling when the process is stable, rules-based, highly regulated, or easily expressed through traditional logic. Enterprises need to separate impressive demos from practical use cases. A system that looks intelligent in a conference demo may be expensive, fragile, and hard to govern in production.
Use cases matter. Skepticism is healthy.
Every architecture has positives and negatives. The mistake is pretending otherwise. SOA gave us value and complexity. Microservices gave us agility and operational burden. Cloud-native delivered scalability and cost expansion. Agentic AI will have automation benefits along with governance, security, and operations challenges.
The job of enterprise architects is not to follow the trend. It is to understand the trend, test it against business value, and apply it only where it fits. Otherwise, we are destined to make the same mistakes over and over again.
