Agent Substrate: A New Way to Run Stateful AI Agents

Google announced on November 5, 2026, that it was donating Agent Substrate and gVisor to the Cloud Native Computing Foundation (CNCF), where both will enter Sandbox status. The project targets a specific Kubernetes problem: AI agents need isolated environments that can pause while waiting and resume with their state intact.

That makes Agent Substrate worth watching if you’re building coding agents, SRE assistants, or large-scale agent evaluations. The announcement describes the architecture and its goals, but doesn’t include installation instructions or a public code repository, so this is an architectural spotlight rather than a copy-and-paste deployment guide.

#What is Agent Substrate?

Agent Substrate is an orchestrator for stateful AI agents, built on Kubernetes. It separates an agent’s persistent state from the compute that runs it, allowing the agent to be suspended while idle and restored when it needs to take another step.

That distinction matters because agents often spend most of a session waiting for model output, an external API, or a human review. According to Google’s announcement, an interactive session may spend 90% to 95% of its time waiting. Keeping a dedicated Pod running preserves the session, but consumes resources while the agent is idle. Shutting it down saves compute, but restoring its environment can mean rebuilding files, runtimes, and other state.

This is a different workload shape from the long-running services Kubernetes was designed to manage. For a related perspective on choosing between these compute models, see Serverless vs. containerized microservices: pick the right model for cost and performance.

#Key features

• Actors hold agent state. An Actor represents an agent session, including its filesystem, environment variables, memory state, and network rules.
• Workers supply shared compute. A Worker is a pre-warmed Kubernetes Pod. Workers run in pools, so suspended Actors can use available capacity instead of keeping a Pod active for each session.
• Suspended sessions can resume quickly. Google says Agent Substrate restores an Actor’s memory and disk state in under 500 milliseconds.
• Agent operations avoid a Pod per session. The control plane can activate and suspend Actors without creating a new Kubernetes Pod object for each one.
• gVisor isolates untrusted code. Its user-space application kernel intercepts system calls instead of letting sandboxed workloads interact directly with the host kernel.
• MicroVMs are another isolation option. Agent Substrate also supports Cloud Hypervisor microVMs for workloads that need hardware virtualization or custom kernel modules.
• The project has reached version 1.0. Google says the community has been building core capabilities and stabilizing APIs ahead of that release.

The reported resume time is a project claim, not an independently verified benchmark in the announcement. Treat it as a target to test against your own workloads, storage, and cluster configuration.

#Quick start

The November 5 announcement doesn’t provide an installation command, repository URL, Kubernetes manifests, or a runnable example. That means there isn’t enough published setup information in the source to give you a truthful Agent Substrate install. Avoid treating a made-up YAML file or command as a working deployment.

You can still do a quick preflight on a Kubernetes cluster to understand the environment where an agent runtime would need to operate. These commands inspect the current context and available nodes; they do not install Agent Substrate.

kubectl config current-context
kubectl get nodes
kubectl get pods -A

Before evaluating the project, write down what an agent session must retain across a pause: for example, its working directory, in-memory process state, tool sessions, and network permissions. Then check whether the official project provides an install path and examples for your Kubernetes setup. The announcement describes the architecture, but doesn’t specify storage configuration, supported Kubernetes versions, or a deployment procedure.

That gap matters. A sub-second restore is useful only if the state your application depends on can be checkpointed and restored correctly. And isolation needs to match the risk of the code agents can execute.

#How it compares

This is a comparison of the approaches described in Google’s announcement, not a general performance study. In particular, actual startup time depends on workload and infrastructure details the post doesn’t specify.

#When to use it (and when not to)

Agent Substrate is worth evaluating when your agents execute untrusted code, need to retain state between turns, and spend substantial time waiting. It also fits a different pressure point: training and evaluation systems that need to start and stop many isolated tasks without creating a Kubernetes Pod for each one.

The design may be a poor fit for workloads that don’t need persistent session state, don’t execute untrusted code, or already run efficiently as stable services. You’ll also need to wait for implementation details before planning a production rollout: the announcement doesn’t state installation steps, API documentation, supported versions, or operational requirements.

If you’re thinking about how agent workflows change software development, From IDE to Agentic Development Environment: The Future of Building Software provides useful context.

#License and community

Google says it is donating Agent Substrate and gVisor to the CNCF in Sandbox status. The announcement describes CNCF donation as a way to build a vendor-independent foundation for agent infrastructure across conformant Kubernetes clusters.

The post does not specify Agent Substrate’s license or provide a repository link. It describes gVisor as open source and written in Go, but doesn’t state its license in this announcement. Check the project’s official materials for licensing, contribution guidance, and current APIs before adopting either component.

#Key takeaways