The Foundation Was Already Poured

Cloud native keeps turning up wherever the industry goes next. It absorbed serverless. It reached out to the edge. It made room for Wasm when Wasm was the future for a season. None of those waves replaced it. They landed on it, and it held.

Now AI has landed on it too. Techstrong’s fall Experts Exchange is built around exactly that idea — Cloud Native: The AI Stack — and a few weeks later, KubeCon in Salt Lake City will spend four days proving the title right.

I made this argument at length in a whitepaper earlier this year, so I’ll give you the short version. Cloud native didn’t get replaced by AI. It got inherited by it.

Nobody writing Kubernetes in 2014 was thinking about large language models. They were thinking about the pager going off at 2 a.m. because another container fell over. But fixing that meant working out scheduling, identity, discovery, policy, observability and governance at real scale. A decade later, enterprise AI walked in the door needing every one of those things. 

It moved into a house that was already furnished. The truth is that the house actually sits on older ground than most people remember. I wrote about this in my upcoming book, “The Indispensability Trap.” The cloud native stack rose on top of the cloud stack. The cloud stack rose on top of the fiber optic frenzy of the dot-com years. All that bandwidth the market wrote off as a bubble the moment the money ran out. That fiber became the road the cloud drove on. The cloud became the road cloud native drove on. Cloud native is the road AI is driving on right now.

Nobody pulling fiber in 1999 was picturing a large language model. Each generation just paved its stretch and moved on. When AI arrived, the road was already laid and paved.

The numbers say the same thing my gut does, which doesn’t happen every day. CNCF counts nearly 20 million cloud native developers worldwide — roughly four out of ten people writing software anywhere. Among developers building AI specifically, 41% already identify as cloud native, and that figure keeps climbing. Those aren’t two communities finding common ground. That’s one community that hasn’t gotten around to updating its name tag.

Salt Lake City is where you’ll see it in person, November 9 through 12. The early signals point to AI on Kubernetes as the theme of the year. GPU scheduling. Model serving. A new generation of Kubernetes-native AI infrastructure filling the biggest rooms in the building.

Watch what isn’t happening, though, because that’s the real confirmation. Supply chain security didn’t get bumped to make space. Sigstore, SLSA and signed provenance will pack rooms this year like they pack rooms every year. The AI crowd didn’t rent a hall across the street. They walked into the conference that already existed, because underneath the new workload it’s the same floor.

So the stack is settled. What worries me is the strategy sitting on top of it. Somewhere in the last two years, “AI strategy” became shorthand for “which model did we license.” That’s calling the engine the car. A model reasons, drafts, classifies and that’s all it does. Everything that makes those outputs safe to ship inside a real company lives outside the model. Deployment. Identity. Cost controls. Guardrails. Audit trails. The stack does that work, and the stack is where most of the engineering difficulty actually lives.

I’ll grant the counterargument its one good sentence. AI workloads are more autonomous, more expensive and more unpredictable than anything we’ve run before, so maybe they deserve an operational stack built from a clean sheet.

Every team I’ve seen try it learns the same lesson. They end up rebuilding Kubernetes’ own primitives like scheduling, identity, policy, except with fewer scars, fewer hardened tools and a thinner bench of people who’ve watched the failure modes up close. We ran this experiment already. It was called MLOps. Models lived in notebooks for years, off in their own world, until they got pulled into the same containerized, observable, version-controlled discipline the rest of production already followed. The gap never closed by inventing a new universe. It closed when everyone admitted the old one worked.

Agents are the honest exception. One model answering questions is a workload. A million autonomous agents calling tools, calling each other and spending real money is a different animal entirely. That world needs things we haven’t finished building like agent identity, agent discovery, agent governance at a density nobody has operated before. But those are extensions of the foundation, not replacements for it. New on-ramps. Same road.

None of this stays theoretical for the people running these platforms. It’s the platform engineer sitting across from a security auditor, explaining which agent touched which customer record and on whose authority. It’s the SRE whose 3 a.m. page used to mean a crashed pod and now means a model that talked itself into a bad API call. Budgets are flat. Headcount is flatter. No one is hiring extra platform engineers because the workload got smarter.

Which brings up the bill collectors. Organizations that skipped platform engineering discipline the first time around are going to pay twice — once for the microservices they never governed, and again for the AI they bolted onto that same mess. The teams moving fastest on AI right now aren’t the ones with the flashiest model. They’re the ones who recognized this list of problems as a rerun and reached for the operating model they’d already spent a decade paying down.

One prediction before I let you go. The phrase “AI native” has a shelf life, and it’s shorter than the conference banners suggest. We used to say “internet-enabled” about software, and then every piece of software was, and the words fell off. When intelligence in software becomes an assumption instead of a headline, the adjective goes the same way. It’ll just be software again, running where software runs.

And where software runs was decided a long time ago, by people who had no idea what they were deciding. Fiber, then cloud, then cloud native, then whatever we’re calling this year’s arrival. We kept giving the road new names. It was the same road the whole way — and we’d finished paving it before AI ever asked for directions.