Google turns the computers under Gemini’s agents into a cloud service
Google Cloud, Thursday at AGNTCon in San Jose: Agent Compute Engine, the microVM layer that already runs Gemini as an agent for work, will be in preview in the coming months. A same-day deep dive says the sandbox holds no user credentials, and that idle agents are checkpointed off the CPU. Agent Substrate, an open-source runtime on Kubernetes, is available now and names Claude Code, OpenClaw and Hermes. Neither post states a price.
Feature5 minIn-depth
James Okonkwo5 min read
- Google Cloud
- Gemini
- Agents
- Antigravity
- Hermes

Photo: Google CloudSource page
Google Cloud said on Thursday that the computers it built to run Gemini’s agents are becoming a product. At AGNTCon and MCPCon in San Jose, a conference the Linux Foundation lists for 22 and 23 October, Nirav Mehta, Michael Bachman and Kevin Hutchins wrote that Agent Compute Engine already powers Gemini as an agent for work tasks and will be available in preview in the coming months. The service gives each agent a hardware-isolated microVM. The same post says Google is extending the agent-governance tools in Gemini for business to agents running on Google Cloud, in other clouds, on premises and on a user’s machine. Neither post states a price, or a date inside “the coming months.”
The design claim is that an agent does not behave like a web server. It starts, pauses and resumes, and it spends stretches waiting on a model or a person. Agent Compute Engine’s answer, in the launch post, is a microVM that boots quickly, shares memory with other agents on the same operating-system template through copy-on-write, and can be paused when it goes idle. When an agent finishes a tool call and enters what Google calls the thinking phase, the microVM signals that it is idle and the host moves it from active to idle. The company says it can pause the machine while the agent waits on a human or an external system, and resume it from a snapshot. Customers are told they will soon be able to point their own agents at the same service.
The sandbox is not supposed to hold the keys
A technical post the same day, by distinguished engineers Ramanathan Venkatapathy and Rohit Jnagal, splits every agent in two. The harness, which they call the brain, calls the model and decides the next step. The sandbox, the hands, runs the code, the shell and the browser. Each product team writes and trusts its own harness. The sandbox is the part Google says it treats as hostile. The rule they state is to assume an attacker controls everything inside it, and to leave nothing there to steal. A microVM, they write, never holds user credentials, API keys, OAuth refresh tokens or cloud service-account keys in memory or on disk, and it has no access to the instance metadata server. It also has no ordinary network card, default gateway or direct path into a virtual private cloud. Traffic crosses a point-to-point channel, virtio-vsock, to a local proxy and then to an external one.
The identity scheme is four names, and only one of them is allowed on the machine. The user identity authenticates the overall task. A delegated on-behalf-of grant, which says the user allowed the harness to do specific work, stays in a central authorization service. The agent workload identity is a short-lived SPIFFE certificate minted when the microVM starts. Venkatapathy and Jnagal say that is the only identity used for sandbox traffic, and that it cannot by itself call a backend if someone copies it off the machine. A fourth identity, the agent workforce identity, is for agents that have their own account. When code inside the sandbox makes a request, the local proxy binds an attestation from the node and from Titanium, Google’s infrastructure offload chip, and forwards it to Agent Gateway. The gateway checks the user delegation, the agent and the node, then swaps in the credential the backend expects. The downstream service sees a normal identity. The sandbox does not. Those are design statements from the engineers who built it. The post does not name an outside auditor.
The example they use is an inbox. An email contains a hidden instruction to find API keys on the machine and send them somewhere. The model sometimes follows that instruction. The mitigation they describe is not a better prompt. It is an empty box: if the model does as the email says, the engineers’ claim is that the keys were never in the guest. Gautham Thambidorai, a Google fellow on Gemini, is quoted on the same design from the product side. “Scaling the Gemini agent to planet scale requires compute that spins up rapidly and operates with extreme efficiency,” he said. The microVMs, he said, supply the responsiveness, hardware isolation and density for interactive sandboxes.
Most of the agents are waiting
Venkatapathy and Jnagal write that when they measured typical sessions, agents spent most of their lives waiting, on the model or on the user, and that at any moment only a small portion of open sessions were running code. They do not print the fraction. The cost argument that follows is that reserving CPU and memory for every open session would bill Google for waiting. Because the sandbox runtime was co-designed with the host, the guest can tell the host that no command is in flight. The host then checkpoints the microVM. They say an idle agent consumes zero active resources on the host and can be woken on the next tool call. On a busy host, they add, agents share one copy of the base image, the Python runtime and the browser, mapped with direct access and copy-on-write, so memory is allocated for the pages an agent actually changes. Persistent work sits on Hyperdisk. Scratch files, shared read-only toolchains and the user’s own workspace are stored differently, so a follow-up question the next day does not start from an empty disk.
A second runtime is already public. Agent Substrate, on Google Kubernetes Engine, is open source. The launch post says it can deliver as much as 10 times the compute density of traditional compute while keeping a kernel boundary and a network identity per agent. In a benchmark Google describes as validation, 200,000 agents produced 500 activations a second, with suspend and resume under 500 milliseconds. It runs on any Kubernetes cluster, the post says, and with any harness, and it names three: Claude Code, OpenClaw and Hermes. Hervé Bizira, chief business officer at Nous Research, said Hermes Enterprise deploys into a customer’s existing infrastructure and that Agent Substrate handles per-agent isolation and access control “at the platform layer.” Clement Farabet, a vice president at Google DeepMind, is the internal customer for the other product. He said Agent Compute Engine gives Antigravity snapshot-and-fork and rapid resume for coding agents that need root, compilers, test runners and a git workspace they can branch.
The governance list is wider than the microVM, and several items are marked as not yet generally available. Agent Gateway, a registry, SPIFFE identities and OpenTelemetry-style traces are what Google says it already built into the Gemini platform. Extending that to other clouds with an Envoy proxy, and to coding agents such as Claude Code and the Antigravity command line on managed laptops, is “in preview soon.” Token budgets, model routing, and delegated authorization through Ping Identity, SailPoint and Saviynt are described as coming this quarter, in preview. Alexandre Frizzo, an AI lead engineer at L’Oréal, said the company’s Beauty Tech Agentic Platform uses the governance layer on Cloud Run so developers can ship agents while the company controls what each one can reach. The computers under Gemini’s own agents are in production, by Google’s account. The rental version is a preview with no price on the page.


