Agent Substrate Joins CNCF: Kubernetes Now Has to Manage Agent Sessions
Agent Substrate 1.0 changes the unit of infrastructure from a short-lived container to a resumable agent session.
Last week I was looking at a very ordinary agent workflow: a coding task runs for a few seconds, waits for a model turn or an external API, then needs to continue with the same files and identity. Should a Kubernetes Pod keep its memory during the whole pause? For a web request the answer is usually no. For an agent, the pause is part of the job.
On November 5, Google Cloud announced that Agent Substrate, gVisor, and OpenRL had been donated to the CNCF. The same announcement says Agent Substrate 1.0 is generally available on GKE. The important detail is not the project naming. Agent Substrate separates the state of an agent session from the compute currently executing it. Idle sessions can be snapshotted to storage and restored when work resumes. Google describes restore times of under 500 milliseconds and a target of 10x container density.The announcement
The unit of work is no longer a busy container
The standard container mental model is simple: start a Pod for a task, let it finish, remove the Pod. An agent loop has more pauses:
request -> plan -> tool call -> wait for API -> wait for approval -> resume
Keeping one long-running Pod through every pause turns waiting time into a memory bill. Deleting it immediately loses context, temporary files, identity, or tool results. The useful abstraction is therefore a resumable session, not a container that happens to stay alive.
That raises a design question I would ask before looking at density numbers: what exactly belongs in a snapshot? Model context can often be reconstructed. A generated workspace may not be safe to reconstruct from memory. Credentials should not casually become snapshot data. The announcement describes the infrastructure capability; it does not classify your application state for you. I would document which state is durable, which state is disposable, and which state must be fetched again after resume.
gVisor is a separate boundary
Agents generate code, install packages, and run scripts that may originate in a repository or user input. A normal container still shares the host Linux kernel. A clean image is not the same thing as a strong execution boundary.
Google places gVisor at this layer. Its userspace application kernel isolates generated code while keeping a container-like operational model. That helps, but it does not make broad permissions acceptable. I would still use a dedicated service account, narrow egress, read-only base images, and an audit event for each tool call. The sandbox limits what an escaped process can do; IAM and network policy determine what the process can reach.
Those controls also matter when an agent resumes. A snapshot must not silently restore an expired credential as if nothing happened. A payment or deployment tool must be idempotent, because a retry after a timeout can repeat a side effect. Restore correctness includes business behavior, not only process memory.
I would test recovery before chasing density
Agent Substrate is GA on GKE, but that is not evidence that every Kubernetes installation has the same runtime, snapshot backend, or scheduler behavior. The public project repository and the CNCF project page are where I would check implementation and governance details.The Agent Substrate repository
My first test would pause during a tool call, terminate the execution worker, and then resume the session. I would check whether the workspace is correct, whether the identity has the expected lifetime, whether a duplicate tool call happened, and whether the audit trail makes the interruption visible. A session that resumes in 500 milliseconds but charges a customer twice is not a successful restore.
I would put those checks in business-level tests rather than relying only on Kubernetes events. A session can record a version when it enters paused, and the resumed tool call can carry an idempotency key. A cache may be disposable; a user-approved patch is not. That distinction is what lets an incident review separate “the process came back” from “the work happened exactly once.”
There is also a cost shift to measure. Snapshotting can reduce idle memory while increasing storage writes, snapshot retention, and burst CPU during restore. Saving too often creates write amplification; saving too rarely means replaying more tool results. I would start with small session state saved frequently, large workspaces in object storage, and a maximum replay window that the application can explain.
If resumption depends on an external queue, I would record the acknowledgement point as part of the session state. Otherwise an agent can return successfully and consume the same message as if it were new. That is the kind of small integration detail that decides whether a platform feature survives its first production incident.
This is a meaningful shift in Kubernetes thinking. We used to manage Pods and services. Agent platforms also need to manage an identity carrying state through pauses and failures. I would not rewrite a cluster for a headline density figure, but I would make suspend-and-resume a release test. The real production signal is not that an agent can call a tool; it is that the agent can stop and safely continue later.
