Chinese
Uncategorized

Google’s Agent Compute Engine: The Sandbox Becomes the Infrastructure

Google Cloud introduced Agent Compute Engine with hardware-isolated microVM sandboxes and governance services for agents that run beyond a single request.

Jacky Wang 4 min read 94 views

When I run a long task on Kubernetes, the worst failure is not always a slow Pod. It can be an agent with tool access treating a temporary directory as a permanent workspace, or carrying context from one job into the next. On October 22, Google Cloud introduced Agent Compute Engine, planned as a preview service with hardware-isolated microVM sandboxes. The announcement also described expanded governance through Agent Gateway and Agent Registry. The message is clear: an agent’s execution environment is becoming a first-class infrastructure problem.

Why a container may not be enough

Containers are excellent for dense deployment and familiar service boundaries. An agent may run uncertain code, call external tools, process untrusted input, and stay alive much longer than a normal request. A hardened container can still be a sound design. I can combine a read-only filesystem, seccomp, network policy, a separate ServiceAccount, and short-lived credentials. The cost is that the platform team has to assemble and maintain those controls for every framework and workload shape.

Google describes Agent Compute Engine as a compute service for agents, with Titanium’s offload infrastructure processing unit and a focus on hardware isolation and silicon-rooted defence in depth. It also points to Agent Gateway and Agent Registry for connection, identity, and governance. I would keep the claim narrow: this is a preview direction, not a promise that every agent workload can move there today, and not a magic solution to security.

Define the execution contract first

Whether the runtime is a microVM or Kubernetes, I want four answers before a migration: what identity does the task receive, which networks can it reach, when are files destroyed, and where does human approval happen? My platform contract might look like this:

agent:
  filesystem: ephemeral
  network: allowlist
  credentials: short_lived
  approval:
    - deploy
    - external_payment
  max_runtime: 15m

This is not an Agent Compute Engine configuration format. It is the kind of contract I would ask the platform to implement. Short-lived credentials are easier to revoke than a cloud key placed in an environment variable. An allowlist is easier to audit than general egress. A maximum runtime stops a retry loop from quietly becoming a large bill.

The other requirement is evidence. I want the task ID, agent version, tool calls, resource accesses, blocked actions, and final disposition in the same observability system as the rest of the platform. A registry can tell me which agents exist. A gateway can centralise connections. Neither replaces an audit trail that explains what happened.

Kubernetes still has a role

The same announcement points to Agent Substrate for teams that already standardise on Kubernetes and need customisation or multi-cloud portability. Google previously described Agent Substrate on GKE as a high-density sandbox runtime with a zero-trust kernel and network isolation. Its announcement gives engineering figures of 10 times the density of standard container runtimes, sub-500-millisecond resume operations, and more than 500 suspend/resume activations per second. Those are Google’s published figures, not measurements from my clusters.

The practical question is the boundary. If a task is a normal HTTP service with predictable resources and mature telemetry, a container remains simpler. If it executes unfamiliar code, needs fast create-and-pause cycles, and runs in large numbers of short-lived sessions, an agent-specific sandbox may justify its operational cost. I would not migrate a workload merely because its prompt contains the word “agent.”

Start with a harmless workload

My first experiment would have no payment authority and no production write access. It would read internal documentation and test data, use an ephemeral filesystem, reach only an allowlisted network, and stop after 15 minutes. The test would cover more than startup: does an interrupted task resume correctly, do credentials really expire, and can data cross from one session to another?

The next competition in agent infrastructure will not be only about model size. It will be about a trustworthy execution boundary. Putting microVMs, a gateway, and a registry in one product is a reasonable direction. I would still prove isolation with a small, reversible workload before connecting the runtime to a system that can deploy code, move money, or alter customer data.

Sources: Introducing Agent Compute Engine and expanded agent governance, Agent Substrate on GKE, Google Cloud AI infrastructure updates.

发表评论