Every few years, our industry discovers a new abstraction and briefly forgets all previous abstractions.
In 2023, everything was a chatbot.
In 2024, everything was RAG.
In 2025, everything became an AI Agent.
By 2026, I suspect my toaster will claim to be an autonomous reasoning system capable of multi-step planning.
The hype cycle is easy to mock, but unlike many technology trends, AI agents are actually useful. They represent a meaningful shift in how we think about software.
Traditional software asks:
“Tell me the steps.”
Agents ask:
“Tell me the outcome.”
Need to summarize a document? Write an email? Investigate a customer issue? Plan a trip? The agent figures out the path rather than having every decision explicitly encoded.
That’s genuinely new.
It’s also where things get interesting.
Because after spending the last year watching companies rush to build agents, I’ve noticed something curious:
Most successful production agents aren’t really autonomous.
They’re workflows wearing a fake mustache.
The Spectrum Nobody Talks About
When people discuss agents, they often imagine something close to a digital employee.
You give it a goal.
It thinks.
It plans.
It acts.
It adapts.
It succeeds.
The reality is usually much less cinematic.
Most production systems exist somewhere on a spectrum.
On one end, you have traditional workflows.
On the other end, fully autonomous agents.
The funny thing is that nearly every successful system drifts toward the middle.
A team starts with an ambitious vision.
“We’ll build an autonomous customer support agent.”
A few incidents later, they add approval checks.
Then validation.
Then retries.
Then budget limits.
Then escalation rules.
Then monitoring.
Then human review.
Then rollback mechanisms.
Six months later they have:
A workflow.
With an LLM in the middle.
The mustache remains. The workflow underneath becomes increasingly difficult to ignore.
The Day Agents Meet Production
I’ve spent most of my career building orchestration systems.
The funny thing about orchestration is that nobody thinks about it until something breaks.
Nobody gets promoted because a workflow completed successfully for the billionth time.
People get promoted because the billion-and-first execution failed in a way nobody expected, and the system recovered anyway.
That’s the difference between a demo and a platform.
In demos, intelligence is the star.
In production, recovery is the star.
When I first started paying attention to the agent ecosystem, I noticed a familiar pattern. Teams would begin with a simple idea:
“We’ll let the model figure it out.”
A few months later they would discover:
- The model occasionally times out.
- APIs fail.
- Context windows fill up.
- Humans provide incomplete instructions.
- Downstream systems return nonsense.
- External tools change behavior.
Eventually someone asks a dangerous question:
“What happens if this fails halfway through?”
At that moment, congratulations.
You’re no longer building an agent.
You’re building a distributed system.
And distributed systems have a way of humbling all of us.
The vocabulary changes surprisingly quickly.
Suddenly conversations aren’t about reasoning anymore.
They’re about retries.
Checkpointing.
Durability.
Compensation.
State recovery.
Auditability.
The agent is still there, but now it’s surrounded by the same engineering concerns we’ve been dealing with for decades.
The more valuable the task becomes, the more structure accumulates around the intelligence.
Like a pearl forming around a grain of sand.
Or perhaps more accurately, like enterprise software forming around a promising demo.
Businesses Don’t Pay for Intelligence
They Pay for Predictability
This is the fundamental tension.
Engineers love intelligence.
Businesses love reliability.
A travel planning agent hallucinating a restaurant is mildly annoying.
A customer support agent refunding the wrong customer is expensive.
A procurement agent ordering ten thousand keyboards because it misunderstood a spreadsheet is career-limiting.
The moment agents start performing real actions, organizations begin asking uncomfortable questions:
- What exactly happened?
- Why did it make that decision?
- Can we replay it?
- Can we audit it?
- Can we stop it?
- Can we recover from failure?
Those questions have existed long before LLMs.
Workflow engines were invented precisely because distributed systems are messy.
Tasks fail.
Networks fail.
Humans fail.
Services fail.
And once enough money is involved, eventually everything fails.
The industry spent twenty years building systems to manage this reality.
Then AI arrived and collectively convinced us we could replace all of it with vibes and prompt engineering.
Reality, as usual, had other plans.
The Architecture Convergence
The most interesting trend in AI isn’t the rise of agents.
It’s the convergence of agents and orchestration.
The more important a task becomes, the more structure gets wrapped around the intelligence.
The workflow provides reliability.
The model provides adaptability.
Neither replaces the other.
In fact, they’re becoming complements.
This is why many of the most practical AI architectures don’t resemble science fiction.
They resemble state machines with occasional bursts of intelligence.
The LLM becomes a decision-making component inside a larger system rather than the system itself.
One Final Prediction
Ten years from now, we’ll look at the architecture diagrams of successful AI systems and notice something amusing.
Most of them will contain:
- A state machine
- Some queues
- A database
- A workflow engine
- Monitoring dashboards
- Human approval steps
- And one very expensive model sitting in the middle making occasional decisions
In other words, the future may be less like hiring a genius employee and more like giving a really smart intern access to a well-organized bureaucracy.
Which, if we’re being honest, is probably how most companies already operate.
The only difference is that now the intern can process ten thousand pages per minute and occasionally explain quantum physics.
The paperwork remains surprisingly unchanged.
Author’s note:
I’ve spent years building orchestration systems that execute billions of workflows. Perhaps that’s why every time someone shows me an autonomous agent, I instinctively start looking for the state machine hiding underneath.
So far, I’ve never been disappointed.