When electricity first reached factories, most owners did the obvious thing. They pulled the steam engine out and dropped in a single electric dynamo, wired into the same shafts and belts, on the same floor layout built decades earlier for steam. It was faster and cheaper than rebuilding. On paper, it looked like progress. Productivity barely moved. It took roughly a generation before anyone asked the real question: not how to power the old floor differently, but what the floor should look like if it were built around a hundred small motors instead of one big one. That question, not the dynamo, is what actually changed manufacturing.

I bring this up because I think we're making the same mistake again, only faster this time. Every conversation I walk into is about AI agents. Which model should we use? Which framework should we standardize on? How quickly can we move from pilot to production? Fewer people stop to ask whether the enterprise underneath that agent is actually ready for the way it will operate. It usually isn't, and the reason has less to do with budget or ambition than with a much quieter problem: the agent conversation and the infrastructure conversation run on two different clocks, and they rarely meet before launch day.

Infrastructure Finds Out When It's Already in Production

Every rollout I've watched gets a kickoff meeting. Model, use case, owner, timeline, all agreed before anyone leaves the room. What almost never gets a meeting of its own is the environment the agent is about to run inside. It's treated as background, already handled, someone else's problem.

I've seen how that catches up with a team. The demo works, everyone's pleased, and the agent moves to production. A few weeks in, something behaves strangely, an action gets taken on stale information, or access ends up somewhere it shouldn't. That's usually the first time infrastructure hears about the project at all, not because anyone hid it, but because nobody thought to include them earlier.

By then, the enterprise has already been asked three questions it was never built to answer.

Does anyone know what's happening right now?

Most enterprise monitoring was built for a person checking a dashboard, not software acting on its own. Alerts batch. Thresholds get tuned so nobody's paged at 2 a.m. over a small blip. That matched how the business actually worked, with a person reading a signal before anything happened because of it.

A retail inventory agent set up to reorder stock the moment a warehouse feed shows a shortage runs into this directly. If that feed only refreshes every fifteen minutes, the agent decides on information that's already stale, sometimes reordering against a shortage that resolved itself twelve minutes earlier. The model usually takes the blame when this goes wrong. It was working exactly with what the enterprise gave it.

Does anyone know what it's actually allowed to touch?

Enterprise identity assumes a role stays put. A finance analyst has finance-analyst access, reviewed on a schedule, left alone in between reviews.

An agent doesn't hold still that way. The same one might need read access to a ticket queue in the morning and write access to a deployment pipeline by afternoon, depending on what task it's handed. Nobody designs permissions around an identity that moves like that in a single day, so most teams end up making one of two mistakes: over-provisioning the agent until it can touch nearly anything, or locking it down so tightly it can barely function. Either way, they usually don't find out which mistake they made until the agent's already been running unsupervised for weeks.

Does anyone agree on what's actually true?

The third gap shows up the moment an agent has to make a real call, flag a risky customer, route an incident, recommend a fix. Its first problem isn't intelligence. It's context scattered across systems that never agreed on a shared definition of anything. A CRM says one thing, a decade-old database says another, and a ticketing tool's idea of "status" matches neither.

People fill that gap with tribal knowledge nobody wrote down, the kind where everyone quietly knows which dashboard to trust and which field went stale years ago. An agent has none of that. It reasons over whatever it's handed, and when the output is wrong, the reasoning underneath it was usually fine. What was incomplete was the picture it was reasoning over.

The Same Infrastructure Gaps, Under Agent-Level Pressure

Stale monitoring. Static permissions. Fragmented data. These gaps have existed inside enterprise environments for years, tolerated because nothing was testing them continuously.

They weren't infrastructure failures. They were sensible engineering decisions for a world where humans were always the slowest part of the system. Everything else could afford to be a little slower, because people naturally compensated for the gaps.

That single assumption quietly shaped everything that followed:

• Data would eventually become consistent enough.
• Permissions could be reviewed on a calendar instead of in real time.
• Monitoring every few minutes was close enough to "now."
• Someone would always catch what the system missed.

AI agents are the first enterprise workloads that invalidate all four assumptions at the same time. They don't pause when something looks unusual. They simply keep operating with whatever reality the enterprise presents to them.

I've stopped expecting the next model release to fix this, and I'd encourage other leaders to do the same. Better reasoning, fewer hallucinations, more context held in memory, all of it is coming, and none of it touches the actual problem. A sharper model reading a fifteen-minute-old number is still reading a fifteen-minute-old number.

Intelligence doesn't fix a floor plan.

Time to Change Our Approach to Infrastructure at Its Root

I don't think anyone fully knows what agent-ready infrastructure looks like five years from now. What I'm more confident about is that many enterprises are still asking the wrong question. Usually it's some version of, "What do we need to buy?"

None of the underlying capabilities are especially new. Most enterprises already have some version of them. Streaming telemetry exists. Dynamic, scoped identity exists. Integration layers between legacy and cloud exist too, although they're often fragmented across teams and platforms.

What's changed isn't the technology. It's the workload. AI agents are the first enterprise workload that expects all three to work together continuously, even though most organizations still manage them as separate initiatives owned by different teams.

Very few organizations have actually planned for that redesign. Not a new tool. A different relationship between systems that were each built to solve one problem in isolation, for an operator who could tolerate them staying that way.

Infrastructure has traditionally been judged by uptime. Increasingly, it'll be judged by whether autonomous systems can trust it enough to make decisions. That shift is still early, but I don't think it stays quiet for long.

My guess for the next year or so: some of the loudest AI agent failures we'll hear about publicly won't be model failures at all. They'll be infrastructure failures wearing a model's name, because that's the easier story for a headline to tell. Meanwhile, a much smaller group of enterprises will quietly spend that same period rebuilding the floor instead of admiring the motor. Those will be the ones still running their agents in production three years from now.

Rebuild the Floor, Not the Motor

Historians don't remember electrification because factories replaced a steam engine with a dynamo. They remember it because factories eventually redesigned themselves around what electricity made possible, not around what steam had required.

I think the same test will apply here. AI agents won't be remembered because enterprises deployed them. They'll be remembered because deploying them forced organizations to rethink infrastructure that had been considered good enough for years.

Maybe the better question isn't whether your enterprise is ready for AI agents. It's whether the infrastructure underneath them was ever designed for software that can observe, decide, and act without waiting for a person in the middle.

That's the question I'd actually sit with before the next rollout meeting, not the one about which model to pick.

So here's where I'd leave this: we may eventually stop talking about AI agents altogether, just as nobody talks about electrified factories anymore. They'll simply become another part of how enterprises operate. When that day comes, competitive advantage won't belong to the organizations that adopted agents first. It'll belong to the ones that did the unglamorous work of rebuilding the floor underneath them, before anyone was watching.