Google Cloud Previews Agent Compute Engine for Isolated, Persistent AI Workloads

Google is turning infrastructure built for its own autonomous agents into a managed Google Cloud service. Agent Compute Engine is scheduled to enter preview later this year, giving each agent a hardware-isolated microVM that can be checkpointed while idle and resumed when more work arrives. The design targets a practical tension in agent systems: they need machine-level freedom to run tools and code, but they also need strong boundaries and quick lifecycle changes.
Google announced the service Thursday at the Linux Foundation’s AGNTCon+MCPCon in San Jose. The company says the platform first supported Gemini, Antigravity, and internal model-training pipelines. Its arrival as a cloud offering makes that underlying system available to customers rather than limiting it to Google’s own workloads.
Why Google is building another agent runtime
Agent sandboxes already have a crowded field. Startups including E2B and Daytona offer developer-focused environments across cloud providers, while AWS sells Bedrock AgentCore. Google also has existing options: GKE provides a managed version of its open source Agent Sandbox project, and the Gemini Enterprise Agent Platform offers sandboxes for code execution and computer use.
Those products make Agent Compute Engine less a first entry into sandboxing than a bet on a particular combination of isolation, persistence, and scale. Google says agentic workloads are among the fastest-growing consumers of compute and storage across its fleet. Its engineers argue that the bursty way agents work—starting quickly, making tool calls, and then waiting—doesn’t fit neatly into either traditional virtual machines or ordinary containers.
Rohit Jnagal and Ramanathan Venkatapathy, distinguished engineers at Google, describe the trade-off in a technical deep dive. Conventional VMs offer developers control, but booting, suspending, and resuming them can be too slow for agents. Containers start quickly, yet some workloads, including coding agents and developer assistants, need kernel- and root-level control alongside stronger isolation. “With Agent Compute Engine,” they write, the team set out to build “a unified, agent compute platform for Google.”
A machine that can wait with its agent
Agent Compute Engine gives each agent a persistent, sandboxed computer. Within it, an agent can run shell scripts, operate a headless browser, and write code with root permissions. Google says the platform can support agent loops lasting weeks, as well as compute-heavy workflows such as model evaluation, AI benchmarking, and reinforcement learning. It is also designed to host sandboxed backends for Google services.
The key efficiency mechanism is checkpointing. Agents often spend much of their runtime waiting for a model response, a user, or a tool. When an agent completes a tool call, its host can checkpoint the microVM, leaving it without active resource use until another task arrives. That makes the workload’s idle time part of the runtime design rather than requiring each agent to occupy an actively running machine throughout a long session.
Other sandbox providers have explored related approaches, though their implementations differ. E2B runs each sandbox in a Firecracker microVM, the virtualization technology AWS originally developed for Lambda. It can preserve a sandbox’s memory and filesystem when pausing it, then resume it in about a second. Daytona began with containers and added microVM sandboxes in July, with support for pausing a machine or forking a running one into matching copies.
AWS’s AgentCore assigns a microVM to each agent session. AWS doesn’t charge for CPU while an agent waits on a model or tool call, although memory remains billable until the runtime reclaims it. Sessions are limited to eight hours; AWS added EC2-based runtime instances in August that can maintain shared sessions for as long as 14 days. These details underline that agent infrastructure isn’t just about launching a secure environment. Providers are also deciding how to handle idle time, persistence, and the economics of long-running sessions.
Isolation assumes the agent may be compromised
Google’s security model starts from a deliberately pessimistic premise: an agent inside a sandbox might behave as an attacker. Each session runs in a single-tenant, memory-safe microVM. The environment is designed to contain no secrets on disk or in memory, and the agent receives only a short-lived identity scoped to that session through a local listener inside the VM.
The microVM has no standard network interface. Instead, traffic goes through an external proxy. If an agent needs to reach a service such as Google Drive, Google’s Agent Gateway checks both the user’s delegation and the sandbox’s identity before attaching the relevant credential outside the sandbox. Google says traffic is encrypted end to end in transit, while snapshots and disks are encrypted at rest.
The host itself is designed as a stateless appliance with a read-only filesystem. Google says its hardware and firmware are cryptographically verified at boot. The system uses the company’s Titan and Titanium IPU security platform; microVMs run on Cloud Hypervisor, an open source virtual machine monitor, and each gets its own guest kernel and root access.
Jnagal and Venkatapathy illustrate the risk with an inbox agent that encounters an email containing hidden instructions to find API keys and send them to an external address. A model may ignore such instructions, they say, but that outcome isn’t guaranteed. Their stated design principle is direct: “Assume an attacker controls everything inside the sandbox, and make sure they find nothing there to use.” That approach puts the boundary and credential-handling path outside the agent’s reach, rather than relying on the model to resist every malicious prompt.
Agent Substrate targets teams running Kubernetes
Customers who don’t want a managed Google service have another option in Agent Substrate, an open source runtime for Google Kubernetes Engine first announced in May. It builds on Google’s Agent Sandbox project and adds a lightweight control plane aimed at handling the high volume of brief tool calls that can overwhelm Kubernetes when managed directly.
Substrate also suspends idle agents by snapshotting their memory and returning the machine to a pool, then reactivates them when work resumes. Google claims the design can deliver up to 10 times the density of traditional compute. In a company-reported benchmark involving 200,000 agents, Substrate handled 500 activations per second, with suspension and resumption taking less than half a second.
Teams can choose microVMs or gVisor to isolate sandboxes. Each agent receives a cryptographic identity, while egress proxies attach credentials outside the sandbox, following the same broad security pattern as Agent Compute Engine. Google says Substrate works on any Kubernetes cluster and supports different agent harnesses, including Claude Code, OpenClaw, and Nous Research’s Hermes.
“We built Hermes Enterprise to enable customers to deploy into their existing infrastructure, while handling per-agent isolation and extensible access control,” says Hervé Bizira, Nous Research’s chief business officer. “Agent Substrate addresses both at the platform layer in a way that also preserves valuable compute resources.”
Google is therefore offering two routes to a similar operational goal: a managed service for customers who want Google to run the agent compute layer, and a Kubernetes runtime for teams that want to keep it within their own environments. The preview will show whether Agent Compute Engine’s blend of persistent workspaces, fast checkpointing, and tightly mediated access meets the demands of real production agents. For infrastructure teams, the defining test won’t be whether an agent can run a tool, but whether its execution environment can stay isolated without wasting resources while it waits.