Google’s Agent Substrate Targets Secure, Efficient Agent Workloads on Kubernetes
- Cargo
- Machine Learning
- Shipped
- Shipper
- Jonathan Anthony
- Readers
- 415
Google’s open-source Agent Substrate isolates agents on Kubernetes and suspends idle workloads to free compute until they’re needed again.

As companies run more AI agents, infrastructure has to handle two problems at once: agents need tightly controlled access to tools and data, and idle agents shouldn’t consume resources while they wait. Google’s open-source Agent Substrate, built on Kubernetes, is designed to address both by isolating agents and suspending those that are not actively working.
Google donated the project to the Cloud Native Computing Foundation alongside its gVisor sandbox. The effort responds to a recurring need among customers over the past 18 months: running agent workloads securely and efficiently on infrastructure they already use, said Brandon Royal, a Google Cloud product manager for AI agents and infrastructure.
Isolation and controlled access
Agent Substrate runs hardened sandbox environments on Kubernetes clusters, packing them densely to make use of available infrastructure. A traffic layer applies access rules and checks identity, so each agent can reach only the resources it has been granted access to, according to Benjamin Elder, a Google staff software engineer.
This design treats isolation as a requirement for agents that use tools, operate computers or browse the web. An agent that can take actions needs boundaries around what it can access. The sandbox provides one layer of those boundaries; the traffic controls add another by mediating connections beyond it.
Credential handling is a separate part of the design. Rather than putting secrets inside an agent’s sandbox, Agent Substrate can inject credentials into requests as they pass through the system. That lets an external component make an access decision without giving the agent direct possession of the underlying credential, Elder said.
The distinction matters because agents may need to perform authorized actions without needing unrestricted access to the credentials that enable them. Keeping secrets outside the sandbox narrows what an agent can expose if its behavior goes wrong. It also makes the surrounding infrastructure responsible for applying access decisions as requests are made.
Suspending idle agents
Agent workloads can spend substantial stretches waiting. An agent may be blocked on a response from a large language model or waiting for a person to provide input. Keeping every such workload resident in memory and using CPU during that interval can waste cluster capacity, particularly when many agents are active at once.
Agent Substrate can snapshot idle agents, remove them from active memory and CPU use, and store their state offline. When work resumes, the system restores them. This approach aims to keep the agent’s progress available without reserving active compute for an unknown wait.
The wait could last minutes or days, Royal observed. That uncertainty makes fixed assumptions about how long an agent will be inactive difficult to apply. Suspending it while it waits offers a way to return resources to the cluster, then resume the workload when it has something to do.
For operators, the practical question is how much infrastructure can be reclaimed during those idle periods and how quickly an agent can resume. The project’s description points to resource density and suspension as key mechanisms, but the available information doesn’t provide benchmark results, restoration times, or cost comparisons. Those measurements will matter when teams evaluate the system against their own workloads.
Google’s deployment and the open questions
Google says Gemini Managed Agents already runs on Agent Substrate, using the same isolation and resource management approach. Google Cloud has also introduced Agent Compute Engine to host agents. These deployments show that the project is being used within Google’s own agent offerings, while the open-source release makes the underlying infrastructure available to others.
How well the approach fits a particular deployment will depend on the agent’s access needs, the duration and frequency of its idle periods, and the surrounding Kubernetes environment. Teams will also need to assess how their tools and services integrate with the traffic layer and credential injection. The source description doesn’t specify supported configurations, operational overhead, or licensing details, so those are points to check in the project’s documentation.
Royal expects agents to become a predominant workload, though he framed the timing as uncertain: perhaps six months, perhaps 12. That forecast isn’t a measured adoption rate. The infrastructure problem is clearer: systems built around agents need to control their access while avoiding the cost of keeping every waiting process active.
Agent Substrate’s central bet is that isolation and resource efficiency can be handled together on Kubernetes. Its real test will be whether suspension and restoration work reliably across the varied waits and tool access patterns that agent deployments produce.