Resident Bear, Paddington
Paddy O'Cybear is Paddington's resident bear — equal parts platform engineer and marmalade enthusiast. He writes about durable agentic systems, open-source app substrates, and the engineering it takes to own your cloud. Please look after this stack.
Yesterday I bragged that a single claude -p prompt built and shipped kanban42 while I made a sandwich. Then I looked at the namespace: zero pods. Here's the post-mortem — why headless agents die politely in the background — and the seven optimizations (an agent definition, blocking verbs, proof-of-done) that made the second shot land for real.
Paddington.io now runs three regions — Canada (ca-central, the original instance), USA (us-east), and EU (eu-west). Each region is an independent Miniscaler instance: its own cluster, its own data plane, the same canonical kilter stack, and your data stays where you put it. And because sovereignty is the point, the regions are only the beginning of the answer to 'where can my apps live?' — there's also on-prem kilter, any Miniscaler in the network, and your own existing Kubernetes via kilter package's operator-free ArgoCD bundles.
claude -p "build a kilter based kanban42 app and deploy it in one shot" — and then I went and made a sandwich. The agent created the cluster, provisioned the services, spawned its own background watchers, and committed to verifying the UI before deploying. Interactive sessions were the training wheels; the -p flag is the delegation. And it only works because the substrate underneath is verifiable — an agent will happily work unattended exactly to the degree that the platform lets it check its own work. (Part 1 of 2 — the sequel is the post-mortem of this very run.)
IaaS, PaaS, and SaaS were never really technology layers — they were labor layers. Each one priced a different amount of *someone else operating things for you*: raw metering when the labor was yours, a convenience markup when they ran the middle, per-seat rent when they ran the whole application. k8gentic engineering — agents operating canonical Kubernetes and open-source applications — collapses the labor that separated the layers. What's left to price when the operating expertise is an agent? Resources, plus a thin, published margin. That's the singularity, and it's why our pricing looks the way it does.
Your CEO vibe-coded a dashboard this morning. Then nine more. His marketing manager made him another. Where do they go? Not 'can we build it' — nobody asks that anymore. Where does it run, with auth, without leaking the revenue data it displays, without becoming ten unpatched liabilities? The industry keeps shipping developer tools — better models, harnesses, loops — but every one of those is now abundant. The scarce thing is a governed place for the output to live. THIS is the agentic revolution: infrastructure tools, not developer tools. We prove it at two scales — inside a single application (Squall, where the workflow engine is the product and the UI is AI-generated exhaust) and at the platform level, where Kilter lets you develop against the deployment and runtime infrastructure itself.
A HIPAA-aligned publishing platform — per-post PHI sensitivity, a two-stage clinical/compliance approval, an immutable six-year audit trail, and AI reviewers — stood up in under an hour. The speed isn't the story. The story is that almost none of the compliance lives in the application. Kilter made the *right* architecture as cheap to reach as the convenient one, so the compliance surface moved off the app and into infrastructure primitives you can read: Postgres RLS, statement-level immutability triggers, Temporal workflows, Ory. And once your controls are canonical, inspectable infrastructure instead of application if-statements, a tool can walk them into the dance. That tool is Chaperone.
Enterprises don't have one software loop — they have two. A governed outer loop for the high-risk systems facing the outside world, and a vast, fast, transient inner loop: departmental tools, harness engineering, coordination portals, per-PR previews. Source-code management was built for the code. The inner-enterprise loop is bottlenecked on something else entirely — the orchestration and configuration of *running* software. That's the artifact that now matters, and it's where Kilter lives. `kilter package` is the seam that lets the inner loop feed the outer one without either compromising the other.
Kubernetes never needed to be made easy — it needed to be simple, and it quietly became so. Easy is about you: how little you must learn before something works today. It's what PaaS sells, and the bill arrives later, as leaks and ceilings. Simple is about the system: few, coherent, composable primitives — which is what the modern substrate actually became. And agents don't need easy; effort is the one thing they have in infinite supply. They need simple, because coherence is what a read-edit-verify loop runs on. That's the k8gentic revolution: not another abstraction for the same human operator — a new operator for the real thing.
Every platform team asks the same thing when a new deploy tool arrives — does it replace my GitOps, or feed it? Most tools answer wrong; they want to be the control plane. Kilter answers the other way. GitOps is the control plane; Kilter is an authoring tier that feeds it. Coming in late Q3, kilter apps promote seamlessly from a kilter-provisioned middle environment into pure-Kubernetes production reconciled by your ArgoCD — through your PRs, your RBAC, your audit. Same image, same chart, declared not injected.
I mapped every Kubernetes artifact that touches one production app — an agentic ITSM platform I run — and all of its dependencies. I expected sprawl. The whole declared app is three files and about ten concepts. The elegance is real. The smallness is 'almost,' because the last mile — namespace, identity, credentials against every shared service — is synthesized at runtime by an operator, not committed to git. Two control planes, git as the handoff. A trade, not a bug — and the path to actually small is clear.
Bold claim: there is a category — the application infrastructure platform for the agentic era — and it has no occupant. Not because we missed someone, but because the economics guarantee one. Capital flows to the agent runtime, which has a clean wedge and one buyer; the infrastructure layer has the opposite — a diffuse buyer and free, agent-friendly primitives. Nobody can monetize it. That's exactly why it can be owned without a product rival.
Internal Developer Platforms — Backstage, Port, Cortex — were the hottest infrastructure investment of the last five years: unify the sprawl behind one portal. Then agents arrived. Run an IDP through the agent-native test and every capability either fails read-edit-verify or becomes a second, drifting copy of the truth. The portal optimized the one surface neither human nor agent wants.
Kilter wasn't designed for agents — it was designed for Vercel-grade human developer experience. The surprise is that those turn out to be the same shape. Everything that makes a dev loop great for a human is, point for point, an agent-native property. Two audiences, one design — and the real reason a text-addressable platform ages better than a hosted console.
A platform can run agents and still not be built for them. The difference is one design test, not a feature checklist: can an agent read a capability, edit it, and prove the edit worked — through text files and composable commands? Six principles fall out of that constraint, and they describe a product that looks nothing like a hosted console.
For a decade the pitch was "we hide Kubernetes so you don't have to learn it." That trade made sense when developers were the operators. It stops making sense when an agent is the operator — because the Kubernetes stack converged into something canonical an agent can drive directly. That's the whole bet.
A practical build guide for the layer underneath your agents — the durable spine, event backbone, memory, safety envelope, and audit log that every agent should inherit instead of reinventing. From an empty cluster to an agent-ready substrate, one composed service at a time.
The fastest way to ship a useful agent isn't a greenfield app — it's wrapping a mature open-source system like Outline, Twenty, Penpot, or Nextcloud in durable workflows, event-driven extensions, and an immutable audit log. Here's the three-layer model we use.
The SaaSocalypse said AI would eat the apps you buy. The PaaSocalypse is the bill that follows — every agent-built app stranded on its own platform, its own login, its own lock-in. Here's the reckoning, and the way out.
What it actually feels like to build agentic applications the k8gentic way — a tight local loop on real Kubernetes, services you compose instead of wire, and an agent that drives the whole thing.
Agents are long-running, stateful, and failure-prone — exactly the workload Kubernetes spent a decade learning to run. A "Lambda and a prayer" doesn't cut it.
One CLI, one command, and your app is running on real Kubernetes — database, auth, and TLS wired up for you. No YAML, no lock-in, no platform tax.