AI agents are having their Hadoop moment.
The pitch is compelling: autonomous agents that can reason, plan, use tools, and complete complex tasks with minimal human intervention. The demos are impressive. The potential is real.
And if history rhymes, most enterprise implementations will disappoint — not because the technology failed, but because organizations will make the same category of mistakes they made with every previous technology wave.
We've seen this movie. Multiple times. Let's talk about how it ends differently.
What's Actually Different This Time
First, the honest part: AI agents are genuinely different from the automation tools that preceded them. The ability to reason about ambiguous inputs, compose tools dynamically, and handle edge cases that weren't explicitly programmed — that's real and significant.
The failure mode isn't that agentic AI doesn't work. The failure mode is deploying it into processes that aren't ready for it.
The Three Enterprise Readiness Problems
Problem one: Process ambiguity at scale. Agents work well when the goal is clear and the constraints are defined. Most enterprise processes have neither. They've accumulated exceptions, workarounds, and tribal knowledge over decades. An agent encountering these processes doesn't fail gracefully — it hallucinates a path forward.
Before you build an agent, document the actual process as it runs today, not as it was designed. You'll find the real complexity lives in the exceptions, not the happy path.
Problem two: Data access without data quality. Agents need data. The moment you give an agent access to your actual operational data, every data quality problem you've been hiding becomes an active risk. A human analyst knows to be suspicious of certain data sources. An agent doesn't — it uses what it's given.
The organizations that will succeed with agents are the ones that have done the boring work of data quality, lineage, and access governance. Sound familiar?
Problem three: Accountability without observability. When a human makes a decision, there's a person you can ask to explain it. When an agent makes a decision through a chain of tool calls and intermediate reasoning, the audit trail is usually an afterthought. In regulated industries — banking, life sciences, healthcare — this isn't just a nice-to-have. It's a blocker.
Build observability before you build capability. Every agent action should be logged, explainable, and reviewable.
What Actually Works
The organizations seeing real returns on agentic AI share a few patterns:
They started with contained, high-value tasks. Document processing. Data validation. Alert triage. Tasks where the input is bounded, the success criteria are clear, and a human is still in the loop for exceptions. Not "build an agent that runs our supply chain."
They treated agents as team members, not autonomous systems. The most effective agentic implementations we've seen are collaborative — an agent that works with a human, surfaces information, drafts recommendations, and flags uncertainty. The human makes the call. The agent makes the human better at making calls.
They invested in the scaffolding. Tool design, prompt engineering, retrieval quality, evaluation frameworks. The agent is only as good as what you give it access to and how you've defined its working environment.
The Real Question
The question isn't "can we build an agent for this?" Almost certainly, you can. The question is: "Is this process ready to have an agent working in it?"
That's a harder question. It requires honest assessment of your data quality, your process documentation, your observability capabilities, and your risk tolerance.
We've watched enterprises ask the first question for thirty years and skip the second. It's why data warehouses became shelf-ware, data lakes became swamps, and MDM projects never finished.
The AI/agentic era is giving us a chance to do it differently. The technology is ready. The question is whether the organizations are.
In upcoming posts, we'll walk through specific patterns for agentic system design in regulated industries — what the architecture looks like, where the guardrails need to be, and how to think about human-in-the-loop at scale.