$ ctrlaltroot
Analysis

Kubernetes in 2015, agents in 2026: the same graph, new nouns

The adoption curve for agentic AI is tracking the cloud-native curve almost exactly — including the part where everyone deploys something nobody can operate.

In 2015 the room was full of people who had deployed Kubernetes because they could, not because they’d worked out what operating it would cost them. By 2017 the same people were rewriting deployments, arguing about ingress, and hiring platform engineers to make the thing survivable.

Watching agentic AI in 2026 feels like watching a re-run with the names changed.

The stages, and where we are

Stage 1 — the demo. Someone gets a container to run / an agent to complete a task. Enormous energy, no operational thinking. Everyone is a believer for about two weeks.

Stage 2 — the first production scar. The thing that worked gets traffic / gets a real user. It exposes everything the demo hid: no observability, no way to roll back, no idea what “normal” looks like, cost that scales in a direction nobody modelled. For containers this was the half-finished ingress controller and the mystery OOM kill. For agents it’s the infinite tool loop, the silent context overflow, and a token bill that looks like an incident.

Stage 3 — the platform forms. The scar produces a discipline. Someone builds the boring layer: declarative config, standard runtime, gates, telemetry, a paved road that makes the safe path the easy one. This is where the actual decade of value gets created, and it is unglamorous.

Most enterprises are in stage 1 and 2 with agents right now. The ones moving to stage 3 are not doing it because they’re smarter; they’re doing it because they had a scar.

What transfers directly

The operational instincts transfer almost one-to-one, and this is where a decade of infrastructure work stops being “unrelated experience”:

  • Declarative over imperative. Define the desired state of an agent — model version, tools, prompts, guardrails, eval threshold — in a file under version control. Not in a UI someone clicked.
  • Everything is a diff. If a prompt change or model bump can’t be reviewed, diffed and reverted like a deployment manifest, it isn’t engineering yet.
  • Observability before scale. Traces of every run, not logs of the ones that crashed. For containers this was distributed tracing; for agents it’s per-run spans of input, context, tool calls, tokens, cost and verdict.
  • The gate. A pipeline that refuses to promote a build whose eval score dropped. That’s just CI that tests the right thing.

What doesn’t transfer

Two honest differences, because the analogy is doing work and it deserves to be tested:

Non-determinism is real. Two identical container deploys are the same system. Two identical agent runs are not. Everything from testing to incident review has to be built around probabilities rather than assertions — which is why the scoring discipline matters more, not less.

The cost curve is inverted. In cloud-native, the expensive resource was roughly proportional to traffic. With agents, cost tracks reasoning depth — a single request can quietly consume a thousand times the tokens of another. Nobody budgets for that, and the first surprise invoice is usually what triggers stage 3.

The boring conclusion

The organisations that win at agents over the next three years will not be the ones with the most impressive demos. They’ll be the ones that built the platform layer early: versioned configuration, observability, replay, and a release gate that measures quality instead of asserting it.

Which is exactly what happened with Kubernetes — and it remains the single most reliable pattern I know for spotting where the work will actually be.

← all notes · subscribe via RSS