Google's Agent Substrate Gives Platform Teams a Testable Sandbox Stack for Untrusted AI Agents
Google donated Agent Substrate 1.0 and gVisor to the CNCF. Here is what the Actor/Worker isolation model does and what platform teams can test today.
Google announced on November 5 that it is donating Agent Substrate, gVisor, and OpenRL to the Cloud Native Computing Foundation—not as vaporware, but as software already accepted into the CNCF Sandbox last month and versioned at 1.0. The question for platform and data teams is whether this is a governance headline or something they can actually run.
The short answer: the code is public, the architecture is specific, and there is a concrete isolation model worth understanding. But the project carries a Sandbox maturity label for a reason.
Why Standard Kubernetes Fails Here
The Google Open Source Blog post, authored by developer relations engineer Mofi Rahman and product manager Brandon Royal, frames the problem precisely. A Kubernetes Pod was designed for a process that boots, serves traffic, and runs until stopped. AI agents do none of that reliably.
According to Google's post, an agent in a typical interactive session spends 90 to 95 percent of its time waiting—for model inference, an external API call, or a human reviewing a pull request. During that wait it consumes no CPU. But you cannot kill the container, because it holds live state: active language runtimes, local Git repositories, uncommitted file edits, and open tool sessions.
That creates two bad options with standard Kubernetes. Keep a dedicated Pod running: the agent is warm, but at ten thousand active users cluster costs become unsustainable. Scale to zero with serverless containers: costs drop, but cold restores force the container to reclone repositories, reinstall packages, and rebuild memory, pushing wakeup latency past 20 seconds and breaking the interactive experience.
The inverse problem appears in training workloads. Reinforcement learning loops and benchmark suites need thousands of untrusted sandboxes simultaneously. If each requires a full Pod, the kube-apiserver saturates, etcd struggles, and subnet IP addresses run out. Kubernetes was designed for stable application topologies, not microsecond sandbox allocation.
The Actor/Worker Model
Agent Substrate's answer is an actor-based control and data plane layered on top of Kubernetes. The CNCF sandbox application filed on September 8, 2026 describes it concisely: Actors hold state; Workers provide compute.
- Actor: represents one agent session, with its own filesystem, environment variables, memory state, and network rules.
- Worker: a pre-warmed Kubernetes Pod running in a shared pool (WorkerPool), equipped with container runtimes and sandbox boundaries.
The lifecycle of a single agent turn works as follows, per Google's documentation:
- An incoming request hits the
atenet-routerL7 proxy. If the target Actor is suspended, the proxy holds the request in memory and alerts the Substrate controller. - The controller assigns the Actor to an available slot in the warm Worker pool.
- The Actor's memory and disk state restore from tiered storage, the process wakes up, and the proxy delivers the request. Google claims sub-500-millisecond restore.
- When the turn finishes, Substrate snapshots the Actor's state to tiered storage and frees the Worker slot.
Because Substrate manages Actor state directly, thousands of agents can activate, suspend, and resume per second without creating new Pod objects or stressing etcd. The CNCF application describes an ambition to scale to O(100M) agents on the same cluster infrastructure—compared to Kubernetes' practical ceiling around O(100K) distinct workloads—though no independent benchmark of those numbers is available yet.
The Isolation Stack: What gVisor Actually Does Here
gVisor has been open source since 2018 and already runs in Google Cloud. Its CNCF donation (announced separately on October 2, with trademark transfer included) is what makes the isolation claim meaningful.
gVisor (runsc) is an application kernel written in Go. Instead of allowing a container to issue system calls directly to the host Linux kernel, gVisor intercepts those calls in user space and services them through its own kernel emulation layer, called Sentry. This prevents an exploited process inside the sandbox from reaching host kernel interfaces.
Agent Substrate uses gVisor as its default sandbox runtime. Critically, because gVisor virtualizes its own memory and process tables, Substrate can freeze a live gVisor-sandboxed environment, write memory pages to storage, and restore them on another node—all while preserving the full in-memory state of the agent. That checkpoint/restore mechanism is what enables sub-500ms wakeups without a container cold start.
For workloads requiring hardware virtualization or custom kernel modules, Substrate also supports Cloud Hypervisor microVMs through the same unified API. The CNCF application lists Kata Containers as a supported path as well.
The three-layer isolation stack as Google defines it:
| Layer | Component | Role |
|---|---|---|
| 1 | gVisor (runsc) | User-space kernel; intercepts syscalls; enables memory checkpointing |
| 2 | Agent Substrate | Actor/Worker multiplexing; sub-second wakeup; lifecycle management |
| 3 | OpenRL | Kubernetes-native reinforcement learning loops and evaluation sandboxes |
What the Architecture Exposes
The CNCF sandbox application details the internal components:
- ateapi: gRPC control plane
- atelet: node supervisor DaemonSet
- ateom: interior sandbox agent (gRPC lifecycle interface for sandboxes)
- atenet: Envoy-based proxy and DNS controller for location-transparent routing and on-demand Actor reactivation
All components communicate over mutual TLS. Networking defaults to zero-trust: default-deny isolation, Envoy ext_proc ingress routing, and transparent credential injection via proxy to avoid exposing bearer tokens to the untrusted sandbox itself. That last point matters specifically for data-adjacent agents: a tool-using agent that can query a database should not hold the database credentials in its own process memory where a prompt injection could exfiltrate them.
The CRDs exposed to Kubernetes operators are WorkerPool, ActorTemplate, and SandboxConfig. These integrate with standard Kubernetes RBAC, node scheduling, and HPA autoscaling.
Framework and Tool Support
The sandbox application lists first-class framework connectors on the roadmap: Agent Development Kit (ADK), LangChain remote tool execution, Model Context Protocol (MCP) server hosting, and stateful coding environments for Claude Code and CodeX. MCP server hosting is directly relevant to teams building database-querying agents, since MCP is becoming a common protocol for tool calls that reach production data stores.
Framework-agnostic support is described as a current capability; the named integrations are on the roadmap, so production-quality connectors are not necessarily available yet.
Governance: Why the CNCF Transfer Matters
The CNCF sandbox application is explicit about the governance rationale: single-company stewardship deters major industry peers and cloud providers from adopting and contributing. By moving trademark ownership and roadmap planning to the CNCF, Google is signaling that Agent Substrate is intended as an industry standard rather than a GKE feature.
The application notes contributors from Microsoft and NVIDIA alongside Google engineers, and lists Solo.io as a collaborating ISV. The CNCF project page shows 853 total contributors and 156 contributing organizations as of the November listing—numbers that jumped dramatically from near zero because the project was only publicly committed on May 13, 2026, per the first-commit date on the CNCF page.
With 6,155 GitHub stars and 682 forks already, adoption interest is real, though the Sandbox maturity label means the CNCF has not yet evaluated the project for production readiness. Projects typically spend one to two years in Sandbox before applying for Incubating status.
What Platform Teams Can Actually Do Today
The Google blog post is direct: "Agent Substrate is open source and ready for testing today."
- Documentation: ate.dev
- Code: github.com/agent-substrate/substrate
- Community:
#substrate-devand#substrate-useron the CNCF Slack
The CNCF sandbox application notes the runtime is designed to run on any conformant Kubernetes cluster, including local kind clusters, on-premises Kubernetes, or any cloud-managed offering. That means a platform team can spin up a local test cluster without touching GKE.
A minimal test deployment would involve:
# Example SandboxConfig using gVisor runtime
apiVersion: substrate.ate.dev/v1
kind: SandboxConfig
metadata:
name: gvisor-sandbox
spec:
runtime: runsc # gVisor
---
apiVersion: substrate.ate.dev/v1
kind: WorkerPool
metadata:
name: agent-pool
spec:
replicas: 5
sandboxConfig: gvisor-sandbox
Note: Exact API field names should be verified against the current substrate repository before deployment, as the project is at 1.0 and CRD schemas may differ from illustrative examples.
KubeCon North America runs November 9–12 in Salt Lake City. Google has scheduled a full-day ATEcon co-located event on November 9, a hands-on workshop on November 11 (Schedule ID: 1247804) covering warm worker pools and snapshot restore testing, and an expo demo at Booth #122. The hands-on workshop is the most practical near-term access point for teams that want guided deployment experience before running it internally.
Limitations and Honest Gaps
Several claims in the announcement remain unverified by independent parties:
- The 90–95% idle-time figure comes from Google's own characterization, not a cited study.
- The sub-500ms restore claim is stated by Google but no third-party benchmark exists yet.
- The O(100M) agent scale target is explicitly aspirational in the roadmap, not a demonstrated result.
- The ADOPTERS.md file does not yet exist; adoption is described as formalizing.
- Several integration repos under the
agent-substrateGitHub organization remain private.
The project is Sandbox-stage at the CNCF. That classification means it is accepted for incubation and community development, not that it has passed CNCF's security audit process or graduated to production endorsement. Teams treating this as production infrastructure today are early adopters accepting that tradeoff explicitly.
What is real and testable today: gVisor-backed sandbox isolation, the Actor/Worker multiplexing model, the atenet proxy for on-demand wakeup, and the declarative CRD interface. For database-adjacent or tool-using agents, the transparent credential injection via proxy is the most immediately practical security boundary—it separates the agent process from the credentials it needs to operate, without requiring changes to the agent code itself.
Comments ()