Agent Substrate

NOTE: This is not an officially supported Google product. This project is not eligible for the Google Open Source Software Vulnerability Rewards Program.

What is Agent Substrate?

Agent substrate is a system built on top of Kubernetes which manages agent-like workloads to achieve higher scale and efficiency than Kubernetes alone can offer, with lower latency. It builds on top of Kubernetes features like Pods and Pod autoscaling, but takes the Kubernetes control-plane out of the critical path to achieve lower latency.

It can run on any Kubernetes cluster and does not inhibit “regular” use of Kubernetes in any way. Kubernetes provides the infrastructure provisioning and management for all types of workloads, while Agent Substrate provides agent-specific scheduling and control.

At its core, Agent Substrate maps a larger set of “actors” (applications such as agents) onto a smaller set of ready “workers” (Kubernetes Pods), 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.

Demo

Watch the Agent Substrate cluster multiplex ~250 stateful actor sessions across just 8 physical pods.

This demo highlights the core developer experience and "Agentic Infrastructure" capabilities of Substrate:

1. Instant Session 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 Swarm 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 walkthroughs in the Counter Demo and Secret Agent Demo.

For more videos and walkthroughs, visit our YouTube channel: agent-substrate.

Framework Agnostic & Compatibility

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): Native support for ADK-compatible session identity and persistent working memory.
• LangChain: Ideal execution environment for long-running, stateful LangChain agents and sandboxed tool-calling.
• Claude Code & CodeX: Support for high-density, stateful coding environments that preserve terminal and filesystem state across sessions.
• Model Context Protocol (MCP): Deploy secure, sandboxed MCP servers as Substrate Actors to provide durable tools for any LLM.

Status and compatibility

Agent Substrate is currently in VERY 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.

Community

For announcements, technical discussions, and community support, please join the ate-dev Google Group.

Developing

Please see 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.

Quickstart (Development)

To quickly set up the complete environment:

1. Make sure you have kind, kubectl, and docker installed and configured on your dev machine.

2. Run the following steps:

# create cluster and local registry
hack/create-kind-cluster.sh

# install ate, valkey, 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 and demo it
kubectl ate create actor my-counter-1 --template ate-demo-counter/counter
kubectl port-forward -n ate-system svc/atenet-router 8000:80 &
curl -X POST -H "Host: my-counter-1.actors.resources.substrate.ate.dev" -i http://localhost:8000/

GKE Quickstart (Development)

1. Create and configure your environment file: ```bash cp hack/ate-dev-env.sh.example .ate-dev-env.sh

# Edit .ate-dev-env.sh to match your project and preferences, then source it: source .ate-dev-env.sh ```

1. Enable application-default credentials for gcloud: bash gcloud auth application-default login --project=${PROJECT_ID}

2. Provision the required GCP resources (GKE cluster, Redis, GCS, and IAM bindings): bash go run ./cmd/setup --all

3. Deploy the Agent Substrate system to your cluster (remember to navigate back to root directory of this repo before running the following commands): bash ./hack/install-ate.sh --deploy-ate-system

4. You can then deploy the sample applications. See demos/counter/README.md or demos/sandbox/README.md for detailed walkthroughs. bash ./hack/install-ate.sh --deploy-demo-counter

Custom Setup and Deployment

You can run individual setup steps to create GCP resources as needed. See go run ./cmd/setup --help for available options. For example:

go run ./cmd/setup --create-cluster
go run ./cmd/setup --create-gvisor-node-pool

Similarly, you can deploy or cleanup specific Agent Substrate components using the installation script. See ./hack/install-ate.sh --help for all options.

# Re-deploy only ate-apiserver of the ATE system
./hack/install-ate-kind.sh --deploy-ate-apiserver

# Delete everything (core system and all demos)
./hack/install-ate-kind.sh --delete-all

Tearing down resources

If you need to delete the resources created by the setup script, you can use the provided script hack/teardown.sh. This script will delete resources in the reverse order of creation and handles partial failures gracefully.

./hack/teardown.sh --all

Or run individual teardown steps as needed (see ./hack/teardown.sh for available options).

Demos

We provide several sample applications demonstrating Agent Substrate's capabilities:

1. Counter Demo: A stateful Go HTTP server demonstrating state preservation across suspends/resumes, and dynamic CRD routing.
2. Sandbox Demo (Jetski): A secure, sandboxed execution environment (running Alpine Linux) that allows arbitrary shell execution while preserving filesystem state across sessions.
3. Claude Code Multiplex: Demonstrates oversubscribing physical hardware by multiplexing multiple Claude Code agents onto a limited pool of workers.
4. Secret Agent: Highlights Substrate's "Zero-Idle" self-suspension and re-animation of volatile process memory.

Documentation & Guides

• API Configuration Guide: Detailed reference for configuring WorkerPools, ActorTemplates, Secrets, and Volumes.
• Full CLI Documentation: Installation and usage for kubectl-ate.
• Observability Guide: Guide to actor logging, metrics, and distributed tracing.

Tour

Commands

• cmd/servers/ateapi:
• cmd/servers/atelet:
• cmd/servers/podcertcontroller: A "polyfill" that provides Pod Certificate signers that will eventually ship in upstream Kubernetes (with different names).
• cmd/kubectl-ate: A CLI tool for managing Agent Substrate resources. See its README.
• demos/: Sample applications demonstrating Agent Substrate capabilities.