Google Donates Agent Substrate and gVisor to the CNCF to Secure AI Agents
Google donated Agent Substrate and gVisor to the CNCF, creating an open framework that restores paused autonomous AI agents in under 500 milliseconds.
By Dillip Chowdary • Nov 20, 2026 • Source: InfoQ

At a glance
- Donated technologies
- Agent Substrate, gVisor, OpenRL
- Governing foundation
- Cloud Native Computing Foundation
- Idle time estimate
- 90% to 95% of agent lifespan
- Resume latency
- Under 500 milliseconds
- Isolation options
- gVisor user-space kernel and Cloud Hypervisor microVMs
- Alternative ecosystems
- Kata Containers and Firecracker
In this post
Google has donated Agent Substrate and gVisor to the Cloud Native Computing Foundation to place two foundational pieces of its autonomous computing stack under vendor-neutral open-source governance. According to InfoQ's report, the open-source contribution also incorporates OpenRL, targeting isolated code execution, agent lifecycles, and large-scale reinforcement learning orchestration. The donation directly targets operational hurdles in running autonomous software, specifically sandboxing untrusted machine-generated code and eliminating compute waste during recurring execution pauses.
This report details how Google separates stateful agent sessions from Kubernetes worker infrastructure, enforces user-space isolation, and eliminates control plane saturation during high-volume evaluations. Cloud architects, platform engineering leads, and DevOps specialists managing distributed autonomous systems can use this analysis to evaluate open-source alternatives to proprietary agent runners.
01Idle agent state and control plane churn
Conventional cloud-native infrastructure was designed for predictable software services that initialize, accept traffic, and run persistently across dedicated containers. In contrast, autonomous agents exhibit fragmented execution patterns by invoking tools or generated code for brief intervals before halting to wait for model inference, external application programming interfaces, or human confirmation.
Google estimates that autonomous agents spend between 90 and 95 percent of their overall lifespan idle while continuously maintaining active runtime state. Persisting dedicated Pods for inactive agents squanders cluster resources, while terminating environments introduces latency when context must be reconstructed from scratch.
| Workload Type | Execution Pattern | Cluster Impact |
|---|---|---|
| Traditional Service | Continuous execution serving steady client requests | Stable resource usage in dedicated Pods |
| Autonomous Agent | Brief tool bursts followed by long inference pauses | Control plane overload from frequent churn |
Simultaneously, large evaluation suites running thousands of concurrent testing workflows can rapidly overwhelm the Kubernetes control plane through continuous container churning. Scheduling thousands of short-lived environments strains central apiserver resources whenever temporary execution instances are created, destroyed, and recreated across production clusters.
02Separate actors and prewarmed worker pools
Google engineered Agent Substrate to decouple state retention from physical execution compute by dividing workloads into actors and workers. Actors represent persistent agent sessions that encapsulate filesystem contents, working memory, and active execution context across multiple reasoning steps without demanding an active compute node.
Workers supply reusable, pre-warmed execution environments maintained inside shared Kubernetes resource pools ready to process execution tasks on demand. Whenever an agent requires code execution, Substrate routes the actor to an available worker, restores saved context, and later suspends the session once the task finishes.
- Assign worker Substrate assigns the resuming actor session to a pre-warmed worker selected from the shared Kubernetes cluster pool.
- Restore state The assigned worker recovers previous session memory, filesystem changes, and execution context without launching a brand new Pod.
- Release compute Substrate snapshots updated state and immediately returns the worker container to the shared pool when the agent transitions back to idle.
Advertisement
Tech Pulse Daily
Get tomorrow's pulse first
Join engineers who read Tech Pulse before stand-up. Free, weekday mornings.
03Rapid state restoration across shared workers
Decoupling actor state from underlying worker instances enables Agent Substrate to resume suspended agent sessions in under 500 milliseconds. This rapid transition avoids the overhead of instantiating new Kubernetes Pod structures for transient tool invocations, allowing agents to execute brief code snippets without perceptible launch lag.
This architectural separation significantly shields the Kubernetes control plane from API request flooding during intensive agent workloads. Because the platform avoids registering individual Pod objects for short-lived agent tasks, infrastructure operators maintain cluster stability even when managing thousands of intermittent agent workflows across enterprise clusters.
By standardizing lifecycle events independently of standard container primitives, Substrate offers predictable scheduling behavior during massive batch evaluations. Infrastructure teams avoid the classic trade-off between wasting idle compute capacity in persistent Pods and suffering cold-start latency from scaling inactive environments to zero.
04Kernel syscall interception and hardware microvms
Autonomous software agents frequently run arbitrary command-line strings, install external runtime dependencies, and communicate with external web tools. Treating this machine-generated logic as trusted software introduces major infrastructure vulnerabilities, especially when multiple autonomous agents execute concurrently across shared cluster nodes.
Google addresses this security boundary through gVisor, an open-source application kernel running in user space. Rather than allowing containerized agent processes to invoke host Linux kernel primitives directly, gVisor intercepts system calls and evaluates them within an isolated sandbox, maintaining container execution efficiency while protecting host operating systems.
For high-assurance environments that require hardware-level boundaries, Agent Substrate also integrates with Cloud Hypervisor microVMs. This design enables platform administrators to enforce strict hardware isolation for sensitive tasks without modifying the operational lifecycle or API semantics used by higher-level agent systems.
05Vendor-neutral governance across cloud ecosystems
The decision to donate Agent Substrate, gVisor, and OpenRL to the Cloud Native Computing Foundation establishes neutral open-source governance for foundational agent infrastructure. Google aims to standardize execution paradigms for autonomous software in the same way Kubernetes unified container orchestration across diverse enterprise hosting environments.
Other infrastructure developers are tackling similar execution challenges using isolation technologies such as Kata Containers, Firecracker microVMs, and specialized sandboxing engines. Google's contribution combines secure sandboxed runtimes with an agent-aware lifecycle architecture, providing a standardized foundation for community-driven cloud-native agent deployment.
As autonomous agents evolve beyond simple prompt pipelines into persistent, stateful software entities, they demand specialized operational systems designed for bursty lifecycles. Placing these tools into a vendor-neutral foundation ensures that development teams can build scalable, multi-tenant agent architectures on open standards.
Frequently asked questions
Why did Google donate Agent Substrate and gVisor to the CNCF?
Google donated the projects to establish vendor-neutral governance and open standards for securing and scaling autonomous AI agent infrastructure.
How does Agent Substrate reduce Kubernetes compute costs?
It separates persistent actor session state from worker compute, releasing shared cluster resources while agents remain idle and restoring them in under 500 milliseconds.
How does gVisor protect hosts running untrusted AI-generated code?
gVisor runs a user-space application kernel that intercepts system calls, preventing untrusted code from interacting directly with the host Linux kernel.
What alternative isolation mechanisms does Agent Substrate support?
In addition to gVisor container sandboxing, Agent Substrate supports Cloud Hypervisor microVMs for workloads requiring hardware-level virtualization.
Sources
Author
Dillip Chowdary
Writes Tech Bytes coverage of AI, engineering, and the tools that actually ship. Editor of Tech Pulse Daily.
Related on Tech Bytes
Advertisement