
Google is donating Agent Substrate and gVisor to the Cloud Native Computing Foundation, a move that places two core pieces of its AI agent infrastructure under vendor-neutral open-source governance. The company says the projects are meant to solve two of the hardest problems in running autonomous agents at scale: safely executing untrusted, AI-generated code and reducing the compute overhead caused by agents that pause and resume frequently.
Google’s bet on AI agent infrastructure
The announcement arrives as more teams move from experimenting with AI assistants to deploying agentic systems that can take actions, call tools, and manage longer-running tasks. Google says those systems behave very differently from conventional cloud applications, which are usually expected to start, serve requests, and continue running steadily.
AI agents, by contrast, may do a small burst of work and then wait for model inference, an external API response, or even human approval. In Google’s view, that creates a new kind of infrastructure problem: the agent remains logically active, but its compute resources may sit idle most of the time while still needing to preserve important state such as memory, files, repositories, and session context.
Alongside Agent Substrate and gVisor, Google also announced OpenRL, its open-source reinforcement learning orchestration project. Together, the three projects target different layers of the agent stack, from isolated execution to lifecycle management and large-scale training coordination.
Why Kubernetes alone is not a perfect fit
Google’s argument is that traditional Kubernetes workloads and AI agents have different execution patterns. Kubernetes is optimized for containers and services that can be scheduled, scaled, and managed as relatively stable units. AI agents, however, tend to be far more intermittent.
According to the company, agents can spend 90-95% of their time idle while still holding state that must not be lost. Keeping each agent in a dedicated Pod would waste resources. Scaling everything down to zero would save capacity, but it would also introduce delay when an environment has to be recreated and restored.
At larger scales, the problem can go beyond inefficiency. Google says large-scale agent evaluations can also put pressure on Kubernetes control planes if thousands of short-lived execution environments are constantly created and torn down. The company is positioning Agent Substrate as a way to make those patterns manageable without forcing each agent to map one-to-one with a Pod.
What Agent Substrate is designed to do
Google developed Agent Substrate to separate agent state from the compute resources used to run it. In the model described by the company, actors represent individual agent sessions and retain state such as filesystem contents, memory, and execution context. Workers are reusable, pre-warmed execution environments that come from shared Kubernetes pools.
When an agent needs to continue, Substrate assigns the actor to an available worker and restores the saved state. When the agent becomes idle again, the state can be preserved while the worker is released back to the pool. Google says this approach allows agents to resume in under 500 milliseconds without requiring a new Kubernetes Pod for every execution.
The architecture also aims to reduce the burden on the Kubernetes control plane by managing agent lifecycles separately from individual Pod objects. For teams trying to run many concurrent agents, that separation could be important because it treats the agent session as the primary unit of work rather than the container instance itself.
Stateful execution without constant pod churn
One of the most notable aspects of the design is that it acknowledges the statefulness of modern AI workflows. A coding agent may open repositories, edit files, run tests, and then wait for a response before continuing. A customer-facing agent may need to keep track of conversation history, tool outputs, and task progress over time.
Instead of reconstructing the environment every time the agent wakes up, Agent Substrate is built to preserve that state and reconnect the session to reusable compute. That makes it closer to an agent-aware runtime than a conventional container orchestration pattern.
gVisor and the security problem
The other major issue Google is addressing is security. AI agents frequently execute generated shell commands, install packages, and interact with external tools. That flexibility is useful, but it also creates risk if the generated code is wrong, malicious, or unexpectedly destructive.
Google’s answer here is gVisor, which it is also donating to the CNCF. gVisor adds a user-space application kernel that sits between containerized applications and the host Linux kernel. Rather than letting the workload interact directly with the host kernel, gVisor intercepts system calls and handles them in its own isolated environment.
The result is an additional isolation boundary that reduces exposure of the host system while still keeping much of the efficiency of container-based execution. For AI agent workloads, that matters because the code being run may be generated on the fly and may be far less predictable than a standard application binary.
Additional isolation options for harder workloads
Google says Agent Substrate also supports Cloud Hypervisor microVMs for workloads that need hardware-level virtualization. That gives platform teams a choice of isolation boundaries without changing the overall lifecycle model for the agent.
In practice, that means operators can select the security level they need based on the workload. A lighter-weight sandbox may be enough for some tasks, while more sensitive executions may require stronger isolation through microVMs.
Why the CNCF move matters
By contributing these projects to the CNCF, Google is putting them under open governance rather than keeping them solely within its own stack. That is significant in cloud-native infrastructure, where widely adopted open projects often become the basis for common patterns across vendors and platforms.
The company is clearly drawing a parallel to Kubernetes, which standardized container orchestration for a previous generation of cloud workloads. Google’s broader message is that AI agents may need their own foundational layer of infrastructure: secure, stateful, and built for environments that are created, suspended, restored, and isolated far more often than traditional services.
The announcement also fits into a wider industry trend. Other providers are working on related challenges with technologies such as Kata Containers, Firecracker, and dedicated sandboxing platforms. Google’s contribution combines secure execution with an agent-aware orchestration model and places the work into an open ecosystem.
What this means for teams building agents
For developers and platform teams, the practical implication is that AI agents are increasingly being treated as a distinct class of workload. They are not just applications with a chatbot front end; they are systems that need lifecycle management, persistent state, and stronger isolation than many conventional services.
In that sense, Agent Substrate and gVisor address two halves of the same problem. One helps manage the cost and complexity of keeping agent sessions alive across pauses. The other helps contain the risk of running code that an AI system produced on the fly.
Google’s donation does not by itself solve every deployment challenge around agentic systems, but it does signal where the cloud-native conversation is heading. As autonomous agents move into more production environments, the infrastructure beneath them will likely matter just as much as the models that power them.
Source: Original report
Was this helpful?
Explore more: DevOps Services More Cloud & DevOps Tech News
Last Modified: November 20, 2026 at 10:33 pm
0 views
