The first time I had to run code from an AI agent in production, we did what everyone does: we dropped it into a container, added a network policy, and hoped for the best. That was fine until the agent started making unexpected syscalls, probing the filesystem in ways our AppArmor profile did not anticipate, and once, memorably, trying to escalate privileges through a kernel bug we had not patched. Twenty years of building cloud infrastructure taught me that “it’s just a container” is never actually just a container when untrusted code is in the picture.
That tension, secure isolation vs. the density and speed that multi-agent platforms actually need, has been the central unsolved problem of the agentic AI wave. This week at KubeCon North America in Salt Lake City, Google answered it in a way that matters: they donated Agent Substrate 1.0 and gVisor to the Cloud Native Computing Foundation, both accepted into CNCF Sandbox status. gVisor is already on a path toward CNCF Incubation. This is not a minor project announcement. This is Google handing the community the production-grade agent runtime layer that every serious multi-agent platform is going to need.
Why Running AI Agents on Raw Kubernetes Falls Short
If you have read our coverage of AI code execution sandboxing with E2B, Vercel Sandbox, and Daytona, you know that the managed sandbox services solve the isolation problem well. The tradeoff is that you are calling an external API, paying per execution, and accepting the latency of a cold start on every request. For simple, stateless tool calls, that is a reasonable bargain. For complex, stateful agents that maintain a filesystem, hold open connections, and need to pause while waiting for a human in the loop, it falls apart.
The alternative, running agents directly in Kubernetes pods with a gVisor or Kata runtime class, gets you better isolation than a vanilla container but misses the lifecycle management layer entirely. A pod is a process host. It does not understand the concept of an agent that idles for ten minutes while waiting for user input and then needs to resume in under a second. You end up paying for that idle CPU and memory the whole time, which is the cost cliff that makes high-concurrency agent platforms economically broken at scale.
Agent Substrate attacks both problems simultaneously. It is a Kubernetes-native runtime that understands agent lifecycle: agents are suspended when idle and resumed on a small pool of warm worker pods when a request arrives. The isolation layer is gVisor, which intercepts syscalls in user space and isolates the guest kernel from the host. The result, according to Google’s project documentation and benchmarks they published at the time of the GKE Agent Sandbox GA in May 2026, is that you can pack far more concurrent agents onto a node than a pod-per-agent model allows, while maintaining strong security boundaries.

What Agent Substrate Actually Is
Agent Substrate is not a wrapper around Kubernetes. It is a set of CRDs and controllers that live alongside the Kubernetes control plane and manage a new abstraction: the warm worker pool. Here is the core model.
A WorkerPool is a CRD that defines a fleet of Kubernetes pods pre-loaded with the gVisor sandbox environment (or a Cloud Hypervisor microVM, as an alternative isolation boundary). These pods stay warm and ready to receive agents. The WorkerPool controller watches these pods and maintains the declared replica count, handling evictions and node failures the way a Deployment controller handles normal pod replicas.
A SandboxConfig (the cluster-scoped CRD) describes the runtime assets for a sandbox class: the base image, the filesystem mounts, the network policy, the resource limits. When an agent needs to run, it is assigned to an idle worker in the pool and the sandbox is configured from the SandboxConfig. When the agent suspends, its memory state is checkpointed, the worker is returned to the pool, and another agent can be assigned to it. When the agent needs to resume, Substrate loads the checkpoint onto a warm worker and signals the agent harness to continue from where it stopped.
The agent harness itself is a sidecar that runs alongside the agent process inside the gVisor sandbox. It manages the suspend and resume protocol: signaling the agent to reach a checkpoint boundary, coordinating the checkpoint write to object storage (typically GCS or S3), and handling the handshake when a worker is reclaimed and the agent needs to know its context was safely preserved. The AgentHarness CRD controls this behavior declaratively.
This is meaningfully different from the pod-based model, where “suspend” means writing application state to an external database and “resume” means booting a new pod and replaying that state through application code. Substrate does the suspend and resume at the kernel level, below the application, which means arbitrary agent code gets the benefit without any changes to the agent itself.
gVisor: The Right Isolation Layer for Untrusted Agent Code
If you need a primer on gVisor’s internals, our article on Kubernetes sandbox isolation with gVisor and Kata Containers covers the syscall interception model in depth. The short version is that gVisor implements a guest OS kernel in user space (written in Go, running as runsc). Every syscall from the guest process is intercepted and handled by this user-space kernel before it can reach the host kernel. A container escape that relies on a host kernel vulnerability has no path to work in gVisor because the syscall never reaches the host kernel in the first place.
For AI agents, specifically for coding agents that execute arbitrary code, run shell commands, install packages, and manipulate the filesystem, that isolation model is exactly what you want. The threat is not a sophisticated attacker crafting a kernel exploit. The threat is an agent that makes an unexpected filesystem traversal, a prompt injection that causes the agent to try to read /etc/shadow, or a runaway subprocess that starts scanning the network. gVisor catches all of that at the syscall boundary without requiring any changes to the agent code.
The tradeoff has historically been performance. gVisor adds latency on every syscall because they all go through the user-space kernel. For heavy I/O workloads, that overhead was noticeable enough that teams would choose Kata Containers (which runs a full microVM) or accept weaker isolation for performance-sensitive paths. What Google has done over the past two years is aggressively optimize gVisor’s I/O paths, specifically to reduce overhead for the network and filesystem operations that AI agents do most. The CNCF donation is partly motivated by getting these optimizations upstreamed so the whole community benefits from them rather than just GKE customers.
There is also Cloud Hypervisor as an alternative isolation boundary. If your agent workload needs to run something that genuinely cannot work inside gVisor’s syscall interception model, say a workload that uses hardware virtualization extensions or a database that requires specific kernel modules, Substrate can use a Cloud Hypervisor microVM instead of gVisor. The lifecycle management layer, the suspend/resume protocol, the warm worker pool, all of that stays the same. You are just swapping the isolation boundary below.
For teams that have already deployed Firecracker microVMs for serverless isolation, the mental model maps reasonably well: Firecracker and Cloud Hypervisor are both KVM-based microVM runtimes, and the isolation guarantees are similar. The difference is that Substrate is managing the lifecycle across a pool of these microVMs as a first-class Kubernetes resource, rather than treating each invocation as a cold-start event.

The Density Argument
Here is the economic case for Substrate. A typical long-horizon coding agent, the kind that handles a software ticket end to end, spends most of its wall clock time waiting: waiting for the LLM to respond, waiting for a CI pipeline, waiting for a human to review output. During those waits, the agent is not executing code. It is just holding state.
In a naive pod-per-agent model, you are paying for the CPU and memory of a full pod during all of that idle time. On a large multi-tenant platform, say a company running hundreds of concurrent agent sessions for internal engineering teams, the idle cost dominates the actual compute cost. I have seen teams burning more money on idle agent pods than on the LLM API calls driving the agents.
Substrate’s warm worker pool breaks that coupling. Idle agents are suspended to object storage. Active agents run on a pool of warm workers sized to your concurrency SLA, not to your total agent count. The project documentation (at the time of the November 2026 CNCF announcement) describes the goal as running far more concurrent agents per node than a pod-per-agent approach, with sub-second resume latency. Google’s own GKE Agent Sandbox documentation attributes density improvements in internal testing to the pool model and the checkpoint-resume design. I would treat the specific density multiples cited in some community posts as aspirational: they depend heavily on agent idle fraction and checkpoint size. Measure your own workload.
The resume latency target is more universally useful. If your platform is building something like a user-facing assistant where an agent needs to wake from a suspend when a user sends a message, the latency between “user sends message” and “agent resumes execution” determines your perceived responsiveness. Sub-second resume, which Google says is achievable with a warm worker pool and gVisor’s snapshot support, is the threshold that keeps that transition invisible to users.
GKE Agent Sandbox: The Managed Product
Agent Substrate is the open-source runtime layer. GKE Agent Sandbox is Google’s managed productization of it on GKE, which reached general availability in May 2026. For teams already running GKE, Agent Sandbox is probably the fastest path to production. You enable it on a node pool, it runs gVisor on those nodes by default, and GKE manages the WorkerPool lifecycle, monitoring, and autoscaling integration.
On GKE Autopilot, gVisor sandboxing is now the default for pods without an explicit RuntimeClass. This is a meaningful shift: the most opinionated managed Kubernetes mode has decided that gVisor isolation is the right default for general workloads. That is a signal worth paying attention to even if you are not running on GKE, because it reflects how Google’s production engineering teams have weighted the performance tradeoff after years of running gVisor at scale.
For GKE Standard clusters, you need to explicitly create a node pool with a gVisor-enabled runtime and configure the WorkerPool CRD against it. The GKE documentation has the exact node pool configuration, and it is straightforward. The more interesting question is sizing your WorkerPool: too few warm workers and you get resume latency spikes; too many and you are paying for idle workers instead of idle agents.
What the CNCF Donation Actually Changes
Google has donated open-source projects to external foundations before, and sometimes it has not changed the governance reality much. The CNCF donation of Agent Substrate and gVisor is different for a few reasons.
First, gVisor already has production usage outside Google. Anthropic, OpenAI, and others have used gVisor as an isolation layer. Moving it to CNCF neutral governance makes it easier for those organizations to contribute upstream rather than patching their own forks. The kernel optimization work that Google has been doing specifically for AI agent workloads can now be a collaborative upstream effort rather than a proprietary advantage.
Second, the timing matters. This donation happened at KubeCon North America 2026, with Agent Substrate at 1.0. That is a production-ready release with a clear governance home, not an early-stage research project. Teams evaluating whether to build on Substrate now have the same confidence signal they have with other CNCF Graduated or Incubating projects.
Third, the companion donation of OpenRL (Google’s reinforcement learning framework for training agents with real-world feedback) alongside Substrate and gVisor suggests Google is trying to establish a coherent CNCF-native agent infrastructure stack. Whether that vision coheres into a de facto standard is something the community will decide, but the intent is there.
The practical implication for most teams: the CNCF Sandbox designation means the project has passed CNCF due diligence, has a neutral governance structure, and is on a defined path toward broader adoption. It does not mean it is production-ready on its own, GKE Agent Sandbox being GA is the stronger production-readiness signal for teams wanting managed support. But for teams running self-managed Kubernetes who want to build on Substrate directly, the CNCF home gives you a stable upstream to contribute to and depend on.

How This Fits Into Your Existing Agent Infrastructure
If you are already building multi-agent systems using the frameworks and infrastructure patterns we have covered, like agentic AI production scaling and AI coding agent infrastructure, Substrate fits into the runtime layer below your agent framework. It does not change how you write agents, what tool libraries you use, or how you manage agent state at the application level. It changes how agents are scheduled onto compute, isolated from each other, and managed through their lifecycle.
The integration story is roughly this: your agent framework (LangGraph, CrewAI, a custom harness) deploys agents to a Kubernetes cluster where Agent Substrate WorkerPools are running. The AgentHarness CRD is configured to match your framework’s checkpoint protocol. When an agent idles, Substrate handles the suspend. When a request arrives, Substrate handles the resume. Your orchestration layer sees a simple request/response interface.
What Substrate does not solve is the security of the agent’s interactions with external systems: prompt injection via tool outputs, credential theft through tool misuse, data exfiltration through network calls. We covered those attack surfaces in detail in securing AI agents in production. The network egress control in Substrate (via the atenet-egress component, which injects credentials into approved outbound requests outside the sandbox) addresses one piece of that, but you still need a full guardrails strategy on top.
When to Use This vs. Alternatives
For teams evaluating agent isolation options, here is the honest decision tree.
Use Agent Substrate (via GKE Agent Sandbox or directly) when: you are running on Kubernetes already, you are building a platform that hosts many concurrent long-horizon agents (not simple stateless tool calls), you need strong isolation between agents without VM-per-agent cost, and you want to stay close to the cloud-native ecosystem rather than depending on a managed sandbox service.
Use managed sandbox services like E2B when: you are running simple, short-lived code execution tasks, you are not on Kubernetes (or do not want the operational overhead), or you need a simpler integration path with a pay-per-execution pricing model.
Use Kata Containers or Cloud Hypervisor microVMs directly when: you have workloads that cannot run under gVisor’s syscall coverage (there are edge cases, though fewer than there used to be), or you need hardware-level isolation guarantees beyond what a user-space kernel can provide.
The case where none of these is right is simpler stateless agentic workloads where container isolation is sufficient. If your agents are calling read-only tools, hitting APIs you control, and not running arbitrary untrusted code, the gVisor overhead may not be worth the complexity.
What to Watch Next
The CNCF Sandbox acceptance is the starting line, not the finish line. Watch for gVisor’s progression toward CNCF Incubation over the next year: that is when you will see broader vendor support for it outside Google. Watch for Agent Substrate adopters outside the Google ecosystem, specifically on EKS and AKS, where the managed product equivalent of GKE Agent Sandbox does not yet exist. That gap is either an opportunity for AWS and Azure to build managed products on top of the CNCF project, or for the community to build a vendor-neutral managed layer.
The OpenRL donation is worth tracking separately. Reinforcement learning for agents, specifically training agents using real-world tool interactions as feedback, is an active research area that has not yet made the jump to production infrastructure standards. If OpenRL follows Substrate’s path from internal Google project to CNCF-endorsed production runtime, it could become a third pillar of the cloud-native agent stack alongside the scheduling and isolation layers.
For teams building on Kubernetes today, the practical near-term action is straightforward: evaluate GKE Agent Sandbox if you are on GKE, or deploy Substrate directly on your clusters and test whether the suspend/resume model matches your agent workload’s idle patterns. The checkpoint size and resume latency for your specific agents (which depends on memory footprint, open file handles, and network state) will tell you whether the density gains are real for your use case or theoretical.
Twenty years ago, the security and isolation problems we needed to solve for multi-tenant compute were solved by the hypervisor: a small, privileged piece of software that every cloud provider standardized on and the community hardened over time. The agent sandboxing layer is at a similar inflection point, and the CNCF donation suggests the community has picked a direction. Getting ahead of that now, before your agent density problems become urgent, is the right call.
For related context on the broader Kubernetes security model that Agent Substrate builds on, see our guide to Kubernetes pod scheduling and isolation patterns.
Get Cloud Architecture Insights
Practical deep dives on infrastructure, security, and scaling. No spam, no fluff.
By subscribing, you agree to receive emails. Unsubscribe anytime.
