Source: agent-substrate/substrate (Apache-2.0, Go, about 7k GitHub stars in November 2026). Surfaced by Charly Wargnier on LinkedIn, who describes it as contributed by Google to the CNCF; the repo itself points to a GKE install guide, Google's Agent Executor as a reference harness, and CNCF Slack channels for the community.
What it is
Agent Substrate is a runtime on standard Kubernetes for very large numbers of sandboxed, mostly idle agents. Its premise: an agent spends most of its life waiting on a model, a tool or a human, yet a sandboxed single-tenant Pod keeps holding CPU, memory and a Pod slot the whole time. Substrate separates the actor (the stateful agent instance) from the worker (a pre-started sandbox Pod). Idle actors are snapshotted out of memory; when a request arrives, the router resumes the actor onto any free worker. The project calls this "actor teleport" and claims 10x to 30x oversubscription, resume under 500 ms, and more than 500 activations a second (the demo multiplexes about 250 actors onto 8 Pods). Its stated north-star targets are 100 ms p95 activation, 1 billion actors per cluster and 1,000 wakeups a second.
It is deliberately a low-opinion runtime, not an agent SDK. Workloads are ordinary OCI images; the README lists ADK, LangChain, Claude Code, Codex, Antigravity and MCP servers as tenants, and kagent 1.0 uses it as its execution layer. It reached 1.0 with a public-API compatibility promise.
Architecture
Sandboxes only. Every actor runs in gVisor (runsc) or a Cloud Hypervisor microVM. Plain containers are not supported. Both technologies support suspend and resume, which the whole design depends on.
Focused control plane.
ate-api-serverhandles the high-rate, low-latency lifecycle calls (create, suspend, resume, assign) that the Kubernetes API server is not built for. It authenticates with mTLS and OIDC and authorizes each RPC per atespace (Substrate's namespace) using an embedded OpenFGA model. Kubernetes still provisions Pods;atecontrollerreconcilesWorkerPoolCRDs into Deployments. Actor templates live in the Substrate API, not as Kubernetes objects.Agent-aware routing.
atenet-routeris the only inbound path. It inspects traffic, triggers resume, and can park requests until a worker frees up instead of returning 503.Snapshot storage. The node agent (
atelet) keeps a local copy of an actor's latest snapshot for fast re-resume on the same node and uploads it to durable object storage in the background. RAM and filesystem state both survive suspend.Identity. Each active actor gets a short-lived SPIFFE X.509 certificate; the egress gateway can mint per-actor JWTs on demand.
Credentials outside the sandbox. Actors never hold API keys, cloud tokens or even their own identity credentials. The egress gateway (
atenet-egress) injects credentials into approved outbound requests, so a snapshot contains no secrets and a prompt-injected agent has nothing to exfiltrate. Networking is default-deny: no lateral actor-to-actor or control-plane access, and outbound traffic passes the gateway, which is a replaceable policy enforcement point for authorization, DLP or injection scanning.Observability. OpenTelemetry metrics, structured logs and lifecycle events per actor and per pool.
Tradeoffs
Density for a data problem. Freeing idle compute means storing and moving state for millions of actors that change often. Local snapshot copies are ephemeral; if a node fails before the background upload completes, the latest state can be lost.
Resume latency is now on the request path. Sub-second resume is fine for chat turns and tool calls, but a cold resume from object storage onto a new node is slower than hitting a warm Pod, and oversubscribed pools queue requests under burst.
A second control plane. You run and secure Substrate's API server, router, gateway and node agents next to Kubernetes, with their own authorization model.
Sandbox constraints. gVisor syscall compatibility and microVM overhead apply to every workload; anything that needs plain containers or host features is out.
Young project. The README says contributions outside the core roadmap may wait, and large hosts need kernel neighbor-table tuning beyond about a thousand sandboxes.
Failure modes to plan for
In-flight external effects at suspend time: a tool call that is mid-request, an open socket or a timer inside the sandbox does not survive the same way memory does. Design actors to be idempotent across resume.
Lost or stale snapshot after a node failure before upload, so the actor resumes from an older state.
Credential scoping errors at the gateway: since policy lives outside the sandbox, a too-broad egress rule grants every actor in the atespace that access.
Thundering-herd resumes (for example a scheduled event that wakes thousands of actors at once) exceeding the warm pool and the activation rate.
Snapshots holding sensitive working data (documents, user content) even when they hold no credentials.
Review checklist
Are agents idle most of the time? If they are compute-bound, multiplexing buys little.
What is the p95 resume budget per interaction, measured on cold resume from object storage, not just warm local resume?
Which outbound hosts and credentials does each atespace get, and who reviews egress policy changes?
Are tool calls idempotent and safe to retry after a suspend or a node loss?
How are snapshots encrypted, retained and deleted, and do they fall under the same data rules as the agent's inputs?
How big is the warm pool relative to peak concurrent activations, and what does request parking do to user-visible latency?
Does every harness you plan to host run correctly under gVisor or the chosen microVM?
Related entries
R093 kagent 1.0: one sandbox per conversation, built on this substrate.
R030 OpenShell: kernel-enforced sandboxes with a supervisor that injects credentials only for approved endpoints, the same keys-outside-the-agent pattern.
R061 Pydantic Agent Sandboxes: the opposite end of the spectrum, an interpreter instead of a VM.
R035 Durable execution for long-running agents: waits that hold no compute, solved at the workflow layer instead of the sandbox layer.