Agent execution runtime engineered to run millions of sandboxes Google has introduced Agent Substrate, a secure-by-default agent execution runtime that runs millions of sandboxes at 10x higher density than standard container runtimes, delivering sub-500ms resume operations at over 500 suspend/resume activations per second. The runtime maps a larger set of "actors" onto a smaller pool of ready "workers" and supports microVMs and gVisor with native zero-trust kernel and network isolation, with a demo multiplexing roughly 250 stateful actors across 8 physical pods for 30x+ oversubscription. Google notes Agent Substrate is not an officially supported Google product and is not eligible for the Google Open Source Software Vulnerability Rewards Program. NOTE: This is not an officially supported Google product. This project is not eligible for the Google Open Source Software Vulnerability Rewards Program https://bughunters.google.com/open-source-security . Agent Substrate is a secure-by-default agent execution runtime engineered to run millions of sandboxes with 10x higher density than standard container runtimes. Purpose-built for the era of autonomous agents, Substrate delivers sub-500ms resume operations at over 500 suspend/resume activations per second with native zero-trust kernel and network isolation. It supports multiple sandbox technologies including microVMs and gVisor, enabling consistent lifecycle operations for all sandbox types. At its core, Agent Substrate maps a larger set of “actors” applications such as agents onto a smaller set of ready “workers”, relying on the fact that agent-like applications tend to be idle most of the time to achieve heavy multiplexing. It provides functionality to manage an actor’s lifecycle e.g. create/destroy, suspend/resume , to assign actors to workers in real time, and to route incoming traffic to them. Agent Substrate is intended to be a low-opinion system. The workloads it manages don't have to be literal AI agents, but those are the best example of the kind of applications it is designed for. It is not an SDK for building agents, but rather a system for running them at scale. Agent Substrate leverages Kubernetes for the infrastructure provisioning and worker lifecycle management Kubernetes Pods . It builds on top of Kubernetes features like Pods and Pod autoscaling, while Agent Substrate provides agent-specific scheduling and control to achieve lower latency. Using Kubernetes as the underlying system enables consistent infrastructure management across all workloads types that are required for end to end agentic deployments and allows holistic infrastructure optimizations for RL scenarios that span agentic, inference and training cycles. Watch the Agent Substrate cluster multiplex ~250 stateful actors across just 8 physical pods. This demo highlights the core developer experience and "Agentic Infrastructure" capabilities of Substrate: 1. Actor Teleport: High-performance suspend and resume of actors onto any available worker in the pool with sub-second activation. 2. State Persistence: Persistent working memory volatile RAM and filesystem state preserved perfectly across hibernation cycles via full-state snapshots. 3. Agent Multiplexing: Demonstrates 30x+ oversubscription by "juggling" a large registry of stateful actors onto a small pool of shared physical pods. To reproduce this demo in your own cluster, please refer to the detailed walkthrough in the Counter Demo https://github.com/agent-substrate/substrate/blob/main/demos/counter/README.md . For more videos and walkthroughs, visit our YouTube channel: agent-substrate https://www.youtube.com/channel/UCN9PPqlTtVxlcpbQ-NWpfZQ . Agent Substrate is designed to be framework and agent harness agnostic . Because it manages standard OCI containers at the kernel level via gVisor , it can host agents built on any stack. - Agent Development Kit ADK : Support for ADK agents with session state preservation across invocations as actor state. Ideal for all types of agents and stateful tool or subagent calls. - LangChain: Ideal execution environment for LangChain agents and tool calls. - Claude Code, CodeX, and Antigravity: Support for high-density, stateful coding environments that preserve system state and filesystem state across sessions. - Model Context Protocol MCP : Support for deploying secure, sandboxed MCP servers as Substrate Actors to provide durable tools for any model. - Agent Executor https://github.com/google/ax : A distributed agent runtime that demonstrates building a secure, hyper-scalable agent harness on Agent Substrate see the announcement blog https://cloud.google.com/blog/products/ai-machine-learning/agent-executor-googles-distributed-agent-runtime and integration guide https://github.com/google/ax/blob/main/manifests/README.md . - kagent https://github.com/kagent-dev/kagent : A CNCF Sandbox project and Kubernetes-native framework for building, deploying, and managing AI agents that uses Agent Substrate to run sandboxed, stateful agent workloads see the announcement blog https://kagent.dev/blog/the-future-of-kagent . Agent Substrate is currently in early development. It is not ready for production use, and the APIs are almost guaranteed to change. We are not making any guarantees about backward compatibility at this stage, and everything in this project may be changed. Currently we aim to support the latest stable release https://kubernetes.io/releases/ of Kubernetes, and the previous minor release. For announcements, technical discussions, and community support, please join the ate-dev https://groups.google.com/g/ate-dev Google Group. We host a weekly community meeting every Thursday from 10:00am - 11:00am PST. - Video call link: https://meet.google.com/uhq-cxvn-dhy https://meet.google.com/uhq-cxvn-dhy - Or dial: US +1 253-289-6971 PIN: 787 664 574 59 - More phone numbers: https://tel.meet/uhq-cxvn-dhy?pin=9044088223662 https://tel.meet/uhq-cxvn-dhy?pin=9044088223662 - Meeting notes https://docs.google.com/document/d/1obSIvfcafLNniLYTQCcT2eCgxHqa2AQ3Ga7YTsju49s for the weekly sync meeting - Recordings and transcripts https://drive.google.com/corp/drive/u/0/folders/1rX1S6vPxPrR8dA1lEBuBEXkGKjHtG-mL of all community meetings We also have channels in the CNCF slack; request an invite here https://slack.cncf.io/ if you don't have access. - substrate-users https://cloud-native.slack.com/archives/C0B6RCAJULW to discuss using substrate. - substrate-dev https://cloud-native.slack.com/archives/C0B6M3E2J3D to discuss developing substrate. Please see CONTRIBUTING.md https://github.com/agent-substrate/substrate/blob/main/CONTRIBUTING.md for guidelines on contributing to the project. We welcome contributions of all kinds, but the project is VERY young. Our immediate focus is on building out the core system and demos, so we may not be able to review or merge contributions that don't align with those goals in the near term. To quickly set up the complete environment: 1. Make sure you have Go https://go.dev/doc/install , kubectl https://kubernetes.io/docs/tasks/tools/ , and docker https://www.docker.com/ installed and configured on your dev machine. We will automatically manage other dependencies via Go, including kind https://kind.sigs.k8s.io/ . 2. Run the following steps: create cluster and local registry IPv4; IP FAMILY=dual|ipv6 overrides hack/create-kind-cluster.sh install ate, PostgreSQL, rustfs hack/install-ate-kind.sh --deploy-ate-system install counter demo hack/install-ate-kind.sh --deploy-demo-counter install kubectl-ate go install ./cmd/kubectl-ate create a counter actor in the demo's atespace --template names the actor template, resolved in the actor's atespace kubectl ate create actor my-counter-1 -a ate-demo-counter --template counter port-forward the network router to bind to local port 8000 kubectl port-forward -n ate-system svc/atenet-router 8000:80 1. In a separate terminal , send an HTTP request to increment the counter: curl -X POST \ -H "ate-target-actor: ate-demo-counter/my-counter-1" \ -i http://localhost:8000/ Worker capacity is versioned: the dataplane the atelet DaemonSet and the worker pods schedules only on nodes that carry the ate.dev/substrate-version label, and the install stamps it on every node that exists when it runs. A node added later hosts no workers until you label it with the installed version kubectl label node