Nov 17, live webinar: ECS to EKS without freezing the roadmap for a quarter

Google Donated Agent Substrate to the CNCF: What It Takes to Get the Same Agent Density and Fast Resume on Your Own Kubernetes Cluster

Google donated Agent Substrate and gVisor to the CNCF Sandbox in November 2026, claiming sub-500 ms resume and 10x density for sandboxed agents. Here is what those numbers depend on, which building blocks you can run on your own Kubernetes cluster today, and the trade-offs between gVisor, Kata, Nitro Sandboxes and snapshot-based multiplexing.

Alessandro Carrano
Head of Product
NOV 18, 2026 · 17 MIN
Google Donated Agent Substrate to the CNCF: What It Takes to Get the Same Agent Density and Fast Resume on Your Own Kubernetes Cluster

Key points:

  • The donation is real. On 5 November 2026 Google announced it is donating Agent Substrate and gVisor to the CNCF in Sandbox status, alongside OpenRL, at KubeCon North America in Salt Lake City (Google Open Source Blog). Agent Substrate is Apache 2.0 and reached 1.0 before the donation (GitHub).
  • The numbers are Google's. Google says Substrate resumes a suspended agent "in under 500 milliseconds", runs "more than 500 activations per second" and gets "10x higher density than standard containers". No independent benchmark existed when I wrote this on 18 November 2026.
  • gVisor is not a microVM. Substrate runs every agent in either a gVisor (runsc) sandbox, which is a user-space application kernel, or a Cloud Hypervisor microVM. The sub-500 ms snapshot-and-restore path Google describes relies on gVisor.
  • The density comes from multiplexing. Substrate maps many suspended "actors" onto a small pool of warm "worker" pods and snapshots idle agents out of memory. A gVisor or Kata RuntimeClass alone gives you isolation at roughly one pod per agent.
  • You can build most of this today, with three caveats: Substrate supports only the latest stable Kubernetes release and the previous minor (1.37 and 1.36 today), memory snapshots outside Substrate are mostly GKE-only, and open TCP connections do not survive a restore.
  • Qovery sits next to the sandbox. Qovery deploys the agent platform and the apps agents ship to, in your own cloud account, with policy-scoped tokens and an audit log. It does not isolate agent processes.

Qovery · Infrastructure control plane
Build with Claude Code, Deploy with Qovery
Learn more

Google's pitch for Agent Substrate rests on one observation I agree with completely: agents spend most of their life waiting. Google puts it at "90% to 95% of its time waiting for model inference, external APIs, or human reviews" in a typical interactive session (Google Open Source Blog). A pod per agent pays for that waiting around the clock.

I spend my days helping teams run agent workloads in their own AWS, GCP and Azure accounts, so the question I got the morning after the announcement was predictable: can we get this on our cluster, and what breaks if we try? This post answers it with primary sources only. Every performance number below is a vendor claim unless I say otherwise.

What exactly did Google donate to the CNCF, and what does "under 500 milliseconds" cover?

Google donated two projects to the CNCF as Sandbox projects in November 2026: Agent Substrate, an actor-based runtime that suspends and resumes sandboxed agents on Kubernetes, and gVisor, the user-space kernel it uses for isolation. The sub-500 ms figure is Google's claim for restoring a suspended agent's memory and disk state onto an already-warm worker pod.

The facts, as published:

  • Announcement: "This week at KubeCon North America in Salt Lake City, Google Cloud is donating Agent Substrate and gVisor to the Cloud Native Computing Foundation (CNCF) in Sandbox status, alongside OpenRL" (Mofi Rahman and Brandon Royal, Google Open Source Blog, 5 November 2026).
  • History: Google first introduced Agent Substrate in May 2026, next to Agent Sandbox on GKE (Google Cloud blog).
  • License and status: Apache 2.0. "Agent Substrate has reached 1.0. We are committed to compatibility and stability of the public API, CLI, and configuration formats" (README).
  • Kubernetes support: "the latest stable release of Kubernetes, and the previous minor release" (same README). The latest stable release on 18 November 2026 is v1.37.2 (Kubernetes releases).

Google's published performance claims:

ClaimExact wordingSource
Resume latency"The agent resumes in under 500 milliseconds right where it paused"Google Open Source Blog
Activation rate"more than 500 activations per second"README
Density"10x higher density than standard containers"README
Oversubscription10x to 30x more stateful actors than warm worker podsREADME
Demo scale"~250 stateful actors across just 8 physical pods"README
Baseline it beatsscale-to-zero wakeup "climbs past 20 seconds"Google Open Source Blog

Several launch summaries describe "gVisor microVMs", and that is wrong. gVisor's Sentry intercepts system calls in user space and never passes them through to the host kernel (gVisor docs). Substrate offers gVisor or a Cloud Hypervisor microVM per actor, and Google reserves the microVM option "for workloads requiring hardware virtualization or custom kernel modules". The memory-snapshot trick behind the 500 ms number is described in gVisor terms: "Because gVisor virtualizes its own memory and process tables, Substrate can freeze a running environment, write memory pages to storage, and restore them on another node in under 500 milliseconds."

How does Agent Substrate get 10x density out of the same nodes?

Agent Substrate gets its density by decoupling the agent's state from the compute that runs it. An "actor" holds one agent session's filesystem, memory and network rules; a "worker" is a pre-warmed pod in a shared WorkerPool. Idle actors are snapshotted to storage and their worker slot goes to another actor, so you pay for workers sized to concurrent activity rather than to total sessions.

Google describes one agent turn in four steps (Google Open Source Blog):

  1. Request parking. A call hits the atenet-router L7 proxy. If the actor is suspended, the proxy holds the request in memory.
  2. Placement. The controller assigns the actor to a free slot in the warm worker pool.
  3. Restore. Memory and disk state come back from tiered storage, the process wakes, the proxy delivers the request.
  4. Suspend on idle. When the turn finishes, Substrate snapshots the actor and frees the slot.

For big clusters, the second half of the design matters as much. Actors activate and suspend "without creating new Pod objects or stressing etcd". Google's other complaint about pod-per-sandbox is control plane load, where thousands of short-lived pods per minute overwhelm etcd and the kube-apiserver and exhaust subnet IPs.

Here is how the four ways to hold an agent session compare:

ModelWhat an idle agent costsWake-up pathControl plane loadWhere you find it
Pod per agent, always onFull CPU and memory requests, all dayNone, already warmOne pod per sessionAny cluster
Scale to zero, rebuild on demandNothingClone repo, reinstall, rebuild state; Google says 20 s or moreOne pod create per wakeKnative, KEDA, serverless containers
Warm pool, fresh sandbox per claimPool size onlyClaim a pre-started pod; no prior memory stateOne pod per claimkubernetes-sigs agent-sandbox, GKE Agent Sandbox
Snapshot and multiplexSnapshot storage onlyRestore memory and disk onto a warm worker; Google claims under 500 msNo pod churn per sessionAgent Substrate; GKE Pod Snapshots for single pods

A quick back-of-the-envelope shows why the last row wins on cost. The arithmetic is mine and nobody has benchmarked it. Take 1,000 interactive agent sessions, each needing 2 GiB of memory while it runs. Pod-per-agent reserves about 2,000 GiB. If agents really are idle 90% to 95% of the time, as Google reports, roughly 50 to 100 sessions are active at any moment, and a worker pool sized for 100 concurrent actors plus headroom needs a few hundred GiB. The rest of the cost moves to snapshot storage and restore bandwidth. That lands in the same range as Google's "10x" claim, and it collapses if your agents are busy most of the time, because then there is nothing to multiplex.

Which building blocks can you run on your own Kubernetes cluster today?

Today you can assemble isolation from a sandboxed RuntimeClass (gVisor, Kata Containers, AKS Pod Sandboxing or AWS Nitro Sandboxes), fast allocation from the kubernetes-sigs agent-sandbox warm pools, and suspend/resume either from Agent Substrate itself or, on GKE only, from Pod Snapshots. Nothing else on the list multiplexes many suspended sessions onto a few pods the way Substrate does.

Building blockIsolationSuspend and resume with memoryWarm poolMain requirementMaturity (Nov 2026)
gVisor RuntimeClass (runsc)User-space kernel, syscalls never reach the host kernelrunsc checkpoint / restore, but you build the orchestrationNocontainerd shim on the nodeProduction; now CNCF Sandbox
Kata ContainersmicroVM per pod (Firecracker, Cloud Hypervisor, QEMU)Not as a Kubernetes primitiveNoBare metal or nested virtualizationProduction
AKS Pod SandboxingKata microVM per podNo; v2 preview clones pods from a paused template VMTemplate VM per node (preview)Azure Linux node poolkata-vm-isolation GA, -v2 preview
AWS Nitro Sandboxes on EKSFirecracker on the Nitro hypervisor, one VM per podNo snapshot or live migration at launchNoKubernetes 1.36+, sandbox-enabled nodesLaunched 9 Nov 2026
kubernetes-sigs agent-sandboxDelegates to gVisor or Kata via RuntimeClassPause and resume of the Sandbox; memory snapshots via GKE onlySandboxWarmPool + SandboxClaimAny cluster for the core CRDsv1.0.2, v1beta1 API
GKE Agent Sandbox + Pod SnapshotsgVisor (GKE Sandbox)Yes, full Pod memory and filesystem to Cloud StorageYesGKE, gVisor node poolManaged GKE feature
Agent SubstrategVisor or Cloud Hypervisor microVM per actorYes, actors multiplexed onto workersWorkerPoolKubernetes 1.36 or 1.371.0; CNCF Sandbox

Sources: gVisor, Kata on EKS, AKS, EKS, agent-sandbox, GKE Pod Snapshots, Agent Substrate.

kubernetes-sigs agent-sandbox is the closest thing to a portable standard below Substrate. It gives you a Sandbox CRD with "stable hostname and network identity" and "persistent storage that survives restarts", plus SandboxTemplate, SandboxClaim and SandboxWarmPool (GitHub). It "delegates low-level container isolation" to gVisor or Kata through RuntimeClass. Its memory snapshot feature is narrower than the name suggests: the snapshot guide "requires a GKE Autopilot cluster with a gVisor node pool", uses GKE's podsnapshot.gke.io resources, and "Snapshot/suspend/resume support is Python-only for now" (agent-sandbox docs).

GKE's warm pools are the allocation benchmark to beat. Google reports allocating "300 sandboxes per second, per cluster, at sub second latency, with 90% of allocations completing in 200 milliseconds" (Google Cloud blog). That number covers allocating a fresh sandbox, with no session state restored.

My earlier comparison of AWS Nitro Sandboxes against Daytona, E2B and Modal covers the hosted side, and the ranked list of ephemeral code execution environments covers cold starts and pricing units. I will not repeat them here.

Should agents run under gVisor or a microVM on your cluster?

Pick gVisor when you want the highest density and memory snapshots, and you can accept syscall compatibility gaps and some I/O overhead. Pick a microVM (Kata, Nitro Sandboxes, Substrate's Cloud Hypervisor mode) when the agent needs a real Linux kernel, kernel modules or hardware virtualization, and you can pay roughly 130 MiB and a quarter CPU of overhead per pod.

Turning on gVisor is two small pieces of configuration. The containerd runtime entry on the node, from the gVisor quick start:

TOML
[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runsc]
  runtime_type = "io.containerd.runsc.v1"

And the RuntimeClass, then runtimeClassName: gvisor on the agent pod:

YAML
apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
  name: gvisor
handler: runsc

RuntimeClass is stable since Kubernetes 1.20, so this works on any cluster where you control the node image. The cost is documented by the gVisor project itself: "gVisor imposes runtime costs over native containers," in the form of "additional cycles and memory usage, which may manifest as increased latency, reduced throughput or density, or not at all" (gVisor performance guide). Network-heavy and file-heavy agents feel it most; agents that mostly wait on an LLM barely notice.

The microVM path costs more per pod and more per node:

  • Per-pod overhead. AWS's Kata reference uses a Firecracker RuntimeClass with an overhead of 130Mi memory and 250m CPU (AWS Containers blog). Declare it with Pod Overhead or the scheduler will overpack nodes. At 100 agents per node, that is about 13 GiB and 25 vCPUs of overhead before the agents do anything.
  • Node type. That AWS post used bare metal because "standard EC2 instances don't allow nested virtualization". This changed in 2026: AWS added nested virtualization on virtual C8i, M8i and R8i instances in February (AWS) and extended it to more Intel families, including C7i, M7i and R7i, in June (AWS). On Azure, Pod Sandboxing needs "a generation 2 VM size that supports nested virtualization" on Azure Linux (Microsoft Learn).
  • Boot time. Firecracker itself boots "to application code in less than 125ms" with "memory overhead of less than 5MB" per microVM in the original paper (Agache et al., NSDI 2020). The Kubernetes path adds image pulls, the shim and a guest agent on top.

AKS's kata-vm-isolation-v2 preview is the most interesting microVM development for density. It "creates new sandboxed pods by cloning from a paused, preinitialized template VM instead of cold-booting each pod VM", with a fixed "2 GiB, 2 vCPU guest regardless of pod limits" in the current preview (Microsoft Learn). That speeds up creation without restoring any specific session.

Run the agent platform in your own cloud account.
Qovery deploys your agent services, sandbox controllers and the apps they touch on Kubernetes in your own AWS, GCP, Azure or Scaleway account, or your existing cluster, with scoped agent tokens and a full audit log.

What breaks when you suspend and resume an agent?

Memory and filesystem state survive a snapshot; live network connections do not. gVisor documents that sockets "connected at checkpoint time return ECONNRESET" after a restore (gVisor checkpoint/restore), and GKE Pod Snapshots close "active external connections" on restore. Any agent you plan to suspend must reconnect to its model API, its MCP servers and its database after every wake.

The restore constraints worth designing for:

  • Connections. Treat every resume as a network partition. Wrap model, MCP and database clients in reconnect-on-error logic, and make tool calls idempotent so a call interrupted at snapshot time can be retried safely.
  • Credentials. A snapshot captures memory, so any token in memory is captured too and may be stale on resume. Substrate keeps credentials outside the sandbox entirely: "Actors never hold actor identity JWTs/certs, API keys, or cloud tokens," and an egress gateway injects them into approved requests (README). Copy that pattern even if you never run Substrate.
  • Hardware compatibility. GKE whole-pod snapshots require that "the node where the Pod is restored must have the same machine series, CPU vendor, and CPU features as the node where the snapshot was taken," and do not support the E2 series (GKE docs). Keep worker pools homogeneous.
  • GPUs. gVisor can checkpoint GPU containers "by leveraging cuda-checkpoint", but "GPU checkpoint/restore is not supported on the arm64 architecture" (gVisor). Most agent sandboxes do not need a GPU, since the model runs elsewhere. Keep it that way.
  • Snapshot storage. GKE stores Pod Snapshots in Cloud Storage buckets; Substrate uses "tiered storage". Size the bucket for every suspended session's memory footprint and put a retention policy on it, because a snapshot of an agent's memory can contain source code, prompts and customer data.

If your agent framework holds a long-lived WebSocket to the model provider and never expects it to drop, fix that first. Otherwise the 500 ms restore turns into a multi-second reconnect and a confused agent.

What would it take to get Substrate-level density and isolation on your own cluster today?

It takes a recent cluster you control, a sandboxed RuntimeClass on a dedicated node pool, a suspend/resume layer, and the security pieces Substrate bakes in: default-deny networking, credentials outside the sandbox and per-agent identity. You have three realistic paths, depending on your Kubernetes version and cloud.

Path 1: run Agent Substrate itself. This is the only open-source option with multiplexed snapshot and restore today.

  • Kubernetes 1.36 or 1.37, per the README's "latest stable release and the previous minor release" policy.
  • Nodes where you can install runsc, or nested virtualization or bare metal for the Cloud Hypervisor mode.
  • Large hosts need tuning: "A Linux host that will run more than about a thousand sandboxes also needs a larger kernel neighbor table" (README).
  • Expect a young project. The maintainers write that "the project is VERY young" and may not review contributions outside their current focus.

Path 2: agent-sandbox with warm pools on gVisor or Kata. Fresh, isolated sandboxes claimed from a pre-started warm pool, on any cluster. You give up memory snapshots outside GKE, so a resumed session rebuilds its state from a persistent volume. Density stays near one pod per active-or-idle session unless you delete idle sandboxes and recreate them.

Path 3: per-pod VM isolation from your cloud. AWS Nitro Sandboxes on EKS 1.36+ or AKS Pod Sandboxing. Strongest isolation story, lowest operational effort for the boundary itself, no snapshot or multiplexing. Good for CI-style, short-lived agent jobs.

Path 1: Agent SubstratePath 2: agent-sandbox + RuntimeClassPath 3: Nitro Sandboxes / AKS Pod Sandboxing
Density for mostly-idle agentsHighest; Google claims 10xMedium, pool-sizedLowest, one VM per pod
Resume with memory stateYes, Google claims under 500 msGKE onlyNo
IsolationgVisor or microVMgVisor or KataHardware VM per pod
Minimum Kubernetes1.36Any supported versionEKS 1.36+; AKS per Azure docs
Ops burdenHigh: new control plane, router, egress gateway, snapshot storageMediumLow to medium
Portable across cloudsYes, any conformant clusterYesNo, one cloud each

Whichever path you pick, these are non-negotiable on day one:

  1. A dedicated, tainted node pool for sandboxes, so a sandbox escape lands next to other sandboxes, never next to your API servers.
  2. Default-deny NetworkPolicy for the sandbox namespace, with egress open only to the model provider, your Git host and the APIs the agent is allowed to call. GKE Agent Sandbox supports "default-deny Kubernetes network policy" for the same reason (Google Cloud blog).
  3. No cloud credentials inside the sandbox. Broker them from outside, the way Substrate's egress gateway and Google's Agent Compute Engine design do. I covered that pattern in per-agent isolation without Google's Agent Compute Engine.
  4. A per-agent identity in every log line, so you can answer "which agent did this" after an incident.

Where does Qovery fit, and where doesn't it?

Qovery governs what agents deploy and leaves process isolation to the sandbox layer. Agents call the Qovery API, CLI or MCP Server instead of holding a kubeconfig or cloud keys, each agent can get its own policy-scoped token, and every action lands in the Qovery audit log. The apps, the sandbox controller and the cluster all stay in your own cloud account.

Qovery is an Agentic DevOps platform with a control plane run by Qovery and a data plane in your own AWS, GCP, Azure or Scaleway account, or on any existing Kubernetes cluster (BYOK docs). It does not host your applications and it does not isolate agent processes. Run untrusted agent code in Substrate, a RuntimeClass sandbox or a hosted sandbox.

Here is how the pieces divide in a real setup:

  • The sandbox layer runs your agents' code. Agent Substrate, agent-sandbox or Nitro Sandboxes, on a cluster you control.
  • Qovery deploys the platform around it. Your agent orchestrator, the services that create sandboxes (with a ServiceAccount scoped to one namespace through the security.service_account_name advanced setting), a Helm service for the sandbox controller, and the product the agents work on.
  • Agents ship through Qovery instead of kubectl. API Policy Tokens evaluate an OPA/Rego policy on every request, so an agent token can redeploy staging and nothing else (design write-up). Actions made with it appear in the audit log as policy:<token-id>:<token-name>.
  • Agents get disposable targets. A preview environment per pull request and environment cloning give an agent somewhere real to deploy that is not production.

There is one limit today. Substrate needs Kubernetes 1.36 or 1.37, and Qovery-managed EKS clusters currently run up to 1.35. To run Substrate today, use a cluster that is already on 1.36 or later and connect it to Qovery through Bring Your Own Kubernetes, so Qovery deploys your services onto it while you own the cluster version. The same reasoning applies to Nitro Sandboxes, which also need 1.36.

This split mirrors what I wrote about NVIDIA's OpenShell donation: sandbox projects answer "what can this process touch while it runs", and deployment governance answers "what is this agent allowed to change in my cloud". You need both, and the CNCF now hosts open options for the first one.

How do I set this up with Qovery from Claude Code or Cursor?

Install the Qovery Agent Skills, then connect the MCP Server read-only, and ask your agent in plain language to deploy the services around your sandbox layer.

BASH|1. Agent Skills: one install for Claude Code, Cursor, Codex, OpenCode, Gemini CLI
curl -fsSL https://skill.qovery.com/install.sh | bash

# 2. Or scoped to the current project only
curl -fsSL https://skill.qovery.com/install.sh | bash -s -- --project

# 3. MCP Server for Claude Code over OAuth, read-only by default
claude mcp add --transport http qovery https://mcp.qovery.com/mcp --callback-port 4242

# 4. Write access, only when you explicitly want it (also enable write access in the Qovery Console)
claude mcp add --transport http qovery "https://mcp.qovery.com/mcp?read_write=true" --callback-port 4242

Your agent asks you to approve each install command, and the MCP Server opens an OAuth login in your browser, acting with your own user permissions. The skills deploy (qovery-onboard, qovery-deploy, qovery-preview, qovery-terraform and others); the MCP Server operates what already exists. Then ask, for example: "deploy our agent orchestrator to my existing EKS cluster with Qovery and give it a service account limited to the sandboxes namespace". Start from the AI agent quickstart or the Claude Code integration.

Frequently asked questions
Did Google really donate Agent Substrate to the CNCF?

Yes. Google announced on 5 November 2026 that it is donating Agent Substrate and gVisor to the CNCF in Sandbox status, alongside OpenRL, during KubeCon North America in Salt Lake City. Agent Substrate is Apache 2.0 licensed, reached 1.0 before the donation, and lives at github.com/agent-substrate/substrate. CNCF Sandbox is the entry level for CNCF projects, so expect fast change.

Does Agent Substrate really resume agent sessions in under 500 milliseconds?

That is Google's claim, published in its announcement and the project README, together with more than 500 activations per second and 10x density over standard containers. It describes restoring a suspended agent's memory and disk state onto an already-warm worker pod using gVisor. No independent benchmark was public as of 18 November 2026, so measure it on your own workloads, including the time to reconnect network clients after restore.

Is gVisor a microVM?

No. gVisor is a user-space application kernel written in Go: it intercepts the sandboxed program's system calls and handles them itself instead of passing them to the host kernel. Kata Containers, Firecracker, Cloud Hypervisor and AWS Nitro Sandboxes are microVM approaches with their own guest kernel. Agent Substrate supports both gVisor and Cloud Hypervisor microVMs, and its fast snapshot path is described in gVisor terms.

What would it take to get the same agent density and isolation on my own Kubernetes cluster today?

You need a Kubernetes 1.36 or 1.37 cluster to run Agent Substrate itself, a dedicated node pool with gVisor (or nested virtualization for microVMs), snapshot storage, default-deny networking and credentials brokered outside the sandbox. Without Substrate, kubernetes-sigs agent-sandbox with warm pools on a gVisor or Kata RuntimeClass gives you isolation and fast allocation, but memory snapshots only on GKE. Per-pod VM options like AWS Nitro Sandboxes and AKS Pod Sandboxing give strong isolation with no multiplexing.

Can I run Agent Substrate on a Qovery-managed cluster?

Not on a Qovery-managed EKS cluster yet, because those run Kubernetes up to 1.35 and Substrate supports only the latest stable release and the previous minor, currently 1.37 and 1.36. You can run Substrate on a cluster you already operate at 1.36 or later and connect that cluster to Qovery with Bring Your Own Kubernetes. Qovery then deploys your agent services and apps onto it, with policy-scoped agent tokens and an audit log.

Do I need Agent Substrate if my agents are short-lived jobs?

Probably not. Substrate's density gain comes from suspending long, mostly idle interactive sessions and restoring them later. If each agent run starts, works for a few minutes and exits, a warm pool of sandboxes on a gVisor or Kata RuntimeClass, or a per-pod VM such as AWS Nitro Sandboxes, gives you the isolation without a second control plane to operate.

Alessandro Carrano
About the author
Alessandro Carrano

Alessandro leads product at Qovery. He drives the changelog, roadmap, and product strategy - turning customer feedback into platform capabilities.

Next step

Run the agent platform in your own cloud account.

Qovery deploys your agent services, sandbox controllers and the apps they touch on Kubernetes in your own AWS, GCP, Azure or Scaleway account, or your existing cluster, with scoped agent tokens and a full audit log.