Agent Substrate tested: sleeping agents woke in 112 ms on a laptop
I ran the full Agent Substrate stack on one laptop. Sleeping agents woke in a median 112 ms, but idle agents hold slots and snapshots were not encrypted.
Head of Product at Sprouts.ai

Agent Substrate is a free, open-source (Apache-2.0) project started at Google for running huge numbers of AI agents on Kubernetes, the standard system for running software across many servers. Version 1.0.0 shipped on 5 November 2026, and Google announced it is donating the project to the CNCF, the foundation behind Kubernetes. Idle agents still cost you a running computer. Substrate lets you put them to sleep instead, by saving each one to a file and waking it on the next request.
I stood up the whole system and ran it. Through the real router on one laptop, a sleeping agent woke in a median (middle value) of 112 ms with its memory intact, well under Google's claim of 500 ms. I also found that idle agents keep their slots until something puts them to sleep, that snapshots were not encrypted in my setup, and that the machines hosting the sandboxes are loosely locked down.
Why would you put an agent to sleep?
Most of an agent's life is waiting for a model, a tool or a person. Google's launch post puts that at 90% to 95% of an interactive session. You can keep each agent running all day, which is fast but pays for an idle computer. Or you can shut it down and start from scratch, a "cold start", which Google says can take over 20 seconds.
Substrate takes a third route. An idle agent is frozen into a "snapshot", a file holding its memory and disk exactly as they were, and its machine is freed for another agent. When a new request arrives, the snapshot is loaded onto a free machine and the agent carries on where it paused. Substrate calls each agent session an "actor" and each warm machine slot a "worker". Many actors are meant to share a few workers, though in the demo each agent filled a whole worker.
Every actor runs in a sandbox, a sealed box that stops the agent's code from touching the computer around it. Substrate supports gVisor, Google's open-source layer between a program and the operating system, and microVMs, very small virtual machines.
What I tested
Version: Substrate's main branch at commit 4b57dfc, with gVisor release-20261102.0 (the build Substrate pins) on Kubernetes 1.37.
Setup: The complete system on a laptop, in a kind cluster (a one-computer Kubernetes that runs inside Docker). That includes Substrate's API server, database, the part that sends each request to the right agent (the router), the snapshot store and the outbound gateway. The agent was Substrate's own demo, a small "counter" that counts the requests it has served.
Task I ran: Put the agent to sleep, wait 10 seconds, send a request through the router, and time the answer. I did that 20 times, 10 more times waiting for the snapshot upload to finish, and 20 times on the microVM type. I also timed the first request of 20 new agents, woke more agents than the pool, the fixed set of worker slots, had room for, and checked what snapshots and the outbound gateway expose.
Time to first result: Median wake-up through the router was 112 ms. The p95, the time that 95% of wake-ups came in under, was 138 ms (from 20 runs, so treat it as rough).
What worked: Wake-ups were fast, and the agent's counters (in memory, in a file and on disk) never reset across 30 sleep-and-wake cycles on gVisor and 20 on microVM. Separately, all 72 requests in the four latency tests were answered, including the first requests of new agents. That count includes two warm-up requests, so it is not the cycle count.
What broke or surprised me: Agents beyond what the pool of worker slots could hold got an error. Snapshots were not encrypted. The worker pods run as root with wide permissions.
Limits: One node on one laptop, a Windows laptop with a Linux layer (WSL2) inside it, and I capped the kind node at 8 GiB of memory. The microVM test ran under nested virtualisation, a virtual machine inside that Linux layer, so its number is probably slower than on real servers. The demo agent is tiny, so the gVisor numbers are best-case. For credentials I only tested plain HTTP. I did not run Substrate's benchmark suite or its end-to-end test suite.

How fast is the wake-up, really?
Every time below is a median, the middle value. The wake-up number is the full trip: a local proxy, the router, the worker and the sandbox.
Wake after sleeping: 112 ms, with 138 ms at p95. After a sleep that waited for the snapshot to finish uploading to the object store (cloud file storage, such as GCS or S3), it was 128 ms.
Inside Substrate only: Restoring the snapshot took 61 ms inside Substrate's node service. The rest is my local proxy, the router and the worker.
Going to sleep: 72 ms to take the snapshot. Waiting for the upload to the object store added a median of 142 ms, with a p95 of 402 ms (from 11 runs).
A brand-new agent: The first request took 125 ms. This is not a true cold boot. Substrate takes one snapshot of the agent's template when you deploy it, and every new agent wakes from that snapshot.
microVM sandbox: 171 ms, with 192 ms at p95 (20 runs). This ran under nested virtualisation inside WSL2, on a Windows laptop, so the number is probably slower than on real servers.
The 500 ms claim held here, but a one-node laptop has no network hops between machines and the snapshot was already local. A production cluster will be slower for gVisor.
Earlier I ran the bare sleep-and-wake step on a separate Linux machine with the same gVisor build and no Substrate. It took a median of 39 ms over 45 wake-ups, but I had to put the agent's network address back by hand after every restore. In the full system I never did, and every wake-up was reachable on the first request.
Why did my agents get an error?
I woke agents one after another on the demo's pool of 3 workers. Agents 1, 2 and 3 woke in about 120 ms each. Agents 4 and 5 waited 5 seconds and then got an HTTP 503, which means "server busy", with the message "no worker has room for the actor".
Idle agents were not put to sleep to make room. A slot opened only after I put Agent 1 to sleep by hand, and then Agent 4 woke in 98 ms. Substrate's architecture doc says the user or a higher-level system asks for an idle agent to be suspended. So the saving only appears if your product decides when an agent is idle.

The limit comes from the demo's sizing. Its agent declares 1 CPU and 512 MiB, and each worker offers 1 CPU and 1 GiB, so one agent fills one worker. Substrate's docs say a worker can host many agents if sized that way. I did not test that.
The memory numbers show the gap between booked and used. With 12 workers, Kubernetes had booked 92% of the node's memory, 1 GiB per worker. The 12 awake agents used about 36 MiB each, roughly 0.46 GiB in total (13 sandbox processes added up to 469 MiB). When I woke 14 at once, 12 woke in 234 to 324 ms and 2 got the 503.
What did I find about snapshots?
I looked in two places. Substrate keeps a local copy of each snapshot on the machine. Its memory file held raw memory, and searching it for plain text found earlier answers from the demo agent in 12 snapshot files. The files themselves had open permissions, but the folders were root-only, so in practice only an admin could reach them.
In the object store, the files were compressed, not encrypted, and a text search still found one earlier answer in one of them.
Here is what the docs say. Substrate's security doc lists as a design principle that remote storage and the local snapshot cache are protected with encryption. But the status beside that line marks only plugin isolation and file checksums as done, and lists per-agent encryption as "Future". The threat model suggests encrypting snapshots, with no status. So I read the docs as describing a goal, and my setup did not match it. I used a local object store. I did not test Google Cloud Storage or S3, which the production path uses, so I can't say what protection they add.

Are the worker machines locked down?
Each sandbox sits inside a worker pod, the small package Kubernetes uses to run software. In my cluster the worker pod ran as root, the all-powerful admin user, with extra permissions: SYS_ADMIN (broad system control), NET_ADMIN (change network settings), NET_RAW (build raw network packets) and six more. It had no seccomp filter and no AppArmor profile, two Linux safety filters that limit what a program can ask the operating system to do. The worker also had a folder from the host machine mounted into it, /var/lib/ate, which is where the machine keeps its cached snapshots. Because the worker runs as root, I would check whether a compromised worker could read other agents' snapshots through it. I did not test that.
The security doc already says workers run as root with SYS_ADMIN and NET_ADMIN, marked "In Progress". It does not mention the missing filters. The threat model says a worker is not a wall between agents, so someone who breaks out of one sandbox reaches the other agents on it.
Does the gateway keep secrets out of the agent?
Substrate's design says agents should never hold real credentials. The outbound gateway adds the real token on the way out. I tested this over plain HTTP with a made-up token, FAKE-TOKEN, stored in Kubernetes' built-in place to keep a password.
It worked. The agent sent the word "placeholder" in a header, and the web server on the other end received "Bearer FAKE-TOKEN". The token did not appear in the gateway's log, or in the agent's snapshot when the server ignored the header. An agent with no outbound policy could not even look up a website's name, and a direct connection by address was reset.
There is one catch. Some debug pages, proxies and error pages send your request headers back in the reply. If the web server on the other end does that, the token lands in the agent's memory, and so in its snapshot. I saw 7 copies in one agent's snapshot after it called an echoing server, and 0 when the server did not echo. A second agent showed 6 copies from a single echoed reply, even though that request left the header out. The router adds a tracing header, an ID used to follow a request through the system, to every request on its own. The test agent passed that header along, the gateway swapped the token into it (because my test used that tracing header to carry the token), and the echoing server sent it back. So a secret can end up in a snapshot even though the agent never held it. I did not test a fix.

How do you try it?
I installed Docker Engine in Ubuntu on WSL2 (the Linux layer inside Windows), plus Go and kubectl (the Kubernetes command-line tool). Then, from a clone of the repo, I ran the README's quickstart:
hack/create-kind-cluster.sh
go run ./cmd/ate-setup deploy ate-system ...
go run ./cmd/ate-setup deploy demo counter
The README gives the full second command. The cluster took 2 minutes, Substrate itself 13 minutes 45 seconds, and the counter demo 1 minute 14 seconds. That is about 17 minutes, mostly building Substrate's images. I did not time installing Docker.
What does it cost?
The software is free. You pay for the worker machines, the actor database and the snapshot storage.
What this means for product and GTM teams
If each user of your product gets their own agent, such as a coding environment or a research assistant that keeps working files, idle time is where the money goes. In my earlier bare run, a sleeping agent was no process at all, and in the full system waking it took about a tenth of a second. A big document or loaded model means a bigger snapshot than my tiny demo.
Three decisions come out of my run. First, wake-up time: 112 ms is a best case on one machine, and Google's own target for a full cluster is 100 ms at p95. Plan for slower, but it is far from a 20-second cold start. Second, an idle policy: Substrate will not put idle agents to sleep for you, so someone has to decide when an agent counts as idle. Third, a busy answer: when slots run out, a user gets an error after 5 seconds, so size the pool or queue requests.
For GTM, the security story needs care. "Your keys never enter the agent's sandbox" held in my test over plain HTTP, apart from the echo case. I would not claim encrypted snapshots until Substrate ships per-agent encryption, because in my setup anyone who could read the snapshot storage could read what the agent had in memory. I would not call the workers hardened either.
I would not pick this for a small team, which can usually keep a few agents running all the time in a simpler sandbox such as bashkit, which I tested, or NVIDIA OpenShell. Substrate makes sense once you have thousands of mostly idle agents and a platform team to run Kubernetes.
Frequently asked questions
What is Agent Substrate?
An open-source system for running very large numbers of AI agents on Kubernetes. It saves idle agents as snapshots and wakes them on a free machine when a request arrives, each inside a gVisor or microVM sandbox.
How fast does a sleeping agent wake up?
In my full-system run on one laptop, the median was 112 ms through the router (138 ms at p95), and 171 ms on the microVM type (which ran under nested virtualisation). Google claims under 500 ms. A bigger cluster with real cloud storage will be slower than my best case for gVisor.
How many agents fit on one machine?
It depends on how you size the workers. In the demo, each agent filled a whole worker, and extra agents got an error after 5 seconds because idle agents are not put to sleep automatically.
Are snapshots encrypted?
Not in my setup. The local copies held raw memory, and the object store files were compressed but not encrypted. The docs list per-agent encryption as future work. I did not test Google Cloud Storage or S3.
Do I need Kubernetes, and is it free?
Yes to Kubernetes, and yes it is free (Apache-2.0). On Google Cloud it needs a GKE (Google's hosted Kubernetes) Standard cluster on version 1.37 or later. Autopilot is not supported.
Sources
Agent Substrate repo and README (quickstart): https://github.com/agent-substrate/substrate
Architecture doc (actors, workers, suspend requests, north star metrics): https://github.com/agent-substrate/substrate/blob/main/docs/concepts/architecture.md
Security doc (status of each control): https://github.com/agent-substrate/substrate/blob/main/docs/security/security.md
Threat model: https://github.com/agent-substrate/substrate/blob/main/docs/security/threat-model.md
API guide (worker capacity): https://github.com/agent-substrate/substrate/blob/main/docs/reference/api-guide.md
Request parking (the 5 second budget and the 503): https://github.com/agent-substrate/substrate/blob/main/docs/concepts/request-parking.md
Counter demo pool and template: https://github.com/agent-substrate/substrate/tree/main/demos/counter
Releases (v1.0.0): https://github.com/agent-substrate/substrate/releases
Maintainers: https://github.com/agent-substrate/substrate/blob/main/MAINTAINERS.md
Google Open Source Blog launch post: https://opensource.googleblog.com/2026/11/sandboxing-untrusted-ai-agents-at-scale.html
GKE install requirements: https://docs.cloud.google.com/kubernetes-engine/ai-ml/install-overview-substrate
gVisor: https://gvisor.dev/

Kartikay Dhar
Head of Product at Sprouts.ai, where he leads One Platform, Sprouts Data Universe and the Sprouts MCP. On Instagram he shares one free GitHub repo a day.


