Google Agent Compute Engine: Zero-Credential AI Sandboxes

Google has announced Agent Compute Engine, a managed service running AI agents in isolated microVMs with external secret injection, copy-on-write memory sharing, and fast checkpoint/restore capabilities.

TL;DR

  • Google announced Agent Compute Engine, a managed service running AI agents inside isolated microVM sandboxes on Google Cloud.
  • The platform enforces zero-credential sandboxing by routing outbound requests through an external Agent Gateway that injects API keys and OAuth tokens at the egress perimeter.
  • Architectural decoupling separates the orchestration harness (brain) from guest microVMs (hands), establishing a deterministic audit trail for every tool invocation.
  • High-density workload execution leverages copy-on-write memory sharing across shared OS templates and fast state checkpointing for idle instances.
  • Google introduced Agent Substrate as an open-source, Kubernetes-native runtime for cloud-agnostic agent lifecycle management.
  • Managed Agent Compute Engine pricing, exact boot latency, microVM density metrics, and the underlying hypervisor technology remain unannounced ahead of public preview.

Executing untrusted, model-generated code presents a fundamental security conflict for cloud infrastructure teams. Autonomous AI agents require shell access, package managers, and dynamic code execution to complete complex tasks, yet granting these privileges inside standard container environments creates severe security risks. Prompt injection attacks, data exfiltration vectors, and dependency exploitation frequently turn agent execution runtimes into targets for lateral movement. On 22 November 2026, Google announced Google agent compute engine, a managed execution platform engineered specifically to isolate untrusted AI workloads within hardware-backed microVM sandboxes on Google Cloud.

The design of Agent Compute Engine addresses three core operational challenges in AI infrastructure: eliminating credential exposure inside guest execution environments, minimizing the resource cost and latency of idle agent fleets, and preserving stateful Linux workspaces across host OS maintenance cycles. Rather than embedding authentication keys inside the guest virtual machine, the platform relies on an external perimeter proxy to intercept, authenticate, and sign outbound network traffic. This approach ensures that even if an attacker achieves root access inside an agent sandbox, no long-lived API tokens or infrastructure credentials exist within guest memory to compromise.

Google relies on this microVM pattern internally to power production workloads across Gemini, Gemini for Business, model evaluation pipelines, and the Antigravity agentic development platform. As cloud providers move to secure autonomous code execution—competing directly with offerings like AWS Bedrock AgentCore and Azure Foundry Agent Service—Google’s model introduces distinct architectural separation between orchestration logic and dynamic compute. Platform teams evaluating these patterns must examine how credential externalisation, copy-on-write memory sharing, and Kubernetes-native runtimes alter the baseline for secure AI infrastructure.

Deconstructing Google Agent Compute Engine Architecture

Google Agent Compute Engine functions as a managed, high-density microVM execution platform designed specifically for untrusted agent workflows. Standard container runtimes (such as Docker or unhardened Kubernetes pods) share the underlying host Linux kernel. When an autonomous agent executes model-generated Python scripts or dynamic bash commands, any unpatched kernel vulnerability or container escape flaw directly compromises the host node. Agent Compute Engine mitigates this risk by enforcing hardware-assisted virtualization boundaries around every agent execution session.

In the technical analysis “Inside Agent Compute Engine,” Google Distinguished Engineers Ramanathan Venkatapathy and Rohit Jnagal detail how the platform decouples the execution lifecycle into distinct isolation zones. The service provides isolated compute environments where developers control the image composition, identity boundaries, network egress policies, and lifecycle triggers, while Google manages underlying host provisioning, hardware allocation, and hypervisor maintenance.

Hypervisor Technology Unconfirmed

Google has not disclosed the specific virtual machine monitor (VMM) powering Agent Compute Engine microVMs. While Google historically utilizes gVisor for container sandboxing and KVM for Compute Engine, the underlying hypervisor stack for this service remains unconfirmed. Engineers should verify technical specifications in the official vendor advisory upon public preview launch.

The architecture directly resolves the operational trade-offs that previously hindered microVM adoption for AI workflows: high cold-start latency, heavy memory overhead per instance, and state loss upon instance termination. According to reporting by InfoQ, Google’s platform uses aggressive memory optimization techniques to maintain persistent Linux developer workspaces while keeping compute costs predictable during long periods of agent inactivity.

Market context highlights a industry-wide transition toward dedicated agent execution runtimes. AWS Bedrock AgentCore and Azure Foundry Agent Service similarly offer managed isolation for model tool execution. However, Google’s approach differentiates itself by enforcing complete credential absence within the guest environment, pairing the managed service with an open-source, Kubernetes-native runtime named Agent Substrate.

Credential Externalisation and the Agent Gateway Pattern

Traditional deployment models place cloud credentials, API keys, and OAuth refresh tokens inside environment variables or mounted configuration files within the execution container. If an agent falls victim to prompt injection—or executes malicious code pulled from an external repository—those credentials can be read from guest memory or disk and exfiltrated. Securing agent workflows against prompt leaks and credential harvest attacks requires removing secrets from the execution environment entirely.

Agent Compute Engine enforces a zero-credential sandbox design pattern using an external network proxy called the Agent Gateway. The sandbox environment contains no static API keys, cloud service account credentials, or database connection strings. When an agent script attempts to communicate with an external SaaS API or Google Cloud service, the network request is intercepted at the virtual network boundary by the Agent Gateway.

# Conceptual egress request flow from within an isolated microVM sandbox
# The guest agent emits an unauthenticated request targeting an internal proxy endpoint:

curl -X POST https://agent-gateway.internal.net/v1/services/github/pulls \
  -H "X-Agent-Invocation-ID: inv-8f92a4e1" \
  -H "Content-Type: application/json" \
  -d '{"repo": "org/repo", "title": "Automated patch"}'

# The Agent Gateway validates identity via SPIFFE, retrieves the OAuth token 
# from Secret Manager, injects authorization headers, and forwards to api.github.com.

The Agent Gateway performs several critical security functions at the perimeter:

  • Identity Verification: Validates the caller’s cryptographic identity using workload attestation before processing traffic.
  • Secret Lookup and Injection: Retrieves short-lived OAuth access tokens or API keys from centralized key management services (KMS) outside the sandbox.
  • Header Modification: Injects the required Authorization: Bearer <token> headers into the outgoing HTTP request at the proxy boundary.
  • Policy Enforcement: Applies structural payload inspection, destination domain allowlisting, and request rate limiting.

Because secret injection occurs entirely at the external proxy layer, compromise of the microVM guest yields zero persistent credentials. Memory dumps, environment variable reads, and local disk inspection reveal only ephemeral local configurations. Even if an adversary achieves arbitrary shell execution within the microVM, they cannot extract static service keys to pivot into adjacent enterprise systems.

Harness-Sandbox Separation: Isolation of Brain and Hands

A structural innovation in Agent Compute Engine is the strict separation between the agent orchestration harness and the guest execution sandbox. In legacy agent frameworks, the Large Language Model (LLM) reasoning loop, prompt management, tool orchestration, and shell execution often run inside the same OS process or container. This monolithic structure grants untrusted code execution direct access to the decision-making logic of the agent.

Google’s model formalises a clear boundary: the orchestration harness acts as the “brain,” while the isolated microVM sandbox acts as the “hands.”

+-----------------------------------------------------------------------+
|                        EXTERNAL ORCHESTRATION                         |
|                                                                       |
|   +-----------------------+           +---------------------------+   |
|   |  Orchestration        |           |  Agent Gateway            |   |
|   |  Harness (The Brain)  |           |  (Credential Injection)   |   |
|   +-----------+-----------+           +-------------^-------------+   |
+---------------|-------------------------------------|-----------------+
                | RPC Command                         | Egress Traffic
                | Dispatch                            | (Filtered/Signed)
+---------------v-------------------------------------|-----------------+
|   +-------------------------------------------------|-------------+   |
|   | microVM Sandbox (The Hands)                     |             |   |
|   |                                                 |             |   |
|   |   +---------------------+             +---------+---------+   |   |
|   |   |  Guest Workload /   |             |  Virtual Egress   |   |   |
|   |   |  Untrusted Code     |------------>|  Network Interface|   |   |
|   |   +---------------------+             +-------------------+   |   |
|   |                                                               |   |
|   |   Zero Static Secrets | CoW Memory Base | Checkpoint-Ready    |   |
|   +---------------------------------------------------------------+   |
|                                                                       |
|                        MICROVM ISOLATION ZONE                         |
+-----------------------------------------------------------------------+

The harness runs in a secure, control-plane environment outside the microVM. It handles prompt generation, model invocation, state management, and policy evaluation. When the model decides to invoke a tool—such as compiling a code snippet, modifying a local file, or running a terminal command—the harness dispatches an explicit, serialized RPC command to the guest sandbox.

The guest sandbox receives the command, executes the process within its isolated kernel space, and streams standard output, standard error, and execution codes back to the harness over a restricted IPC or gRPC channel. The untrusted guest environment cannot initiate arbitrary RPC requests back to the control plane; it can only respond to explicitly dispatched harness commands.

This unidirectional command model creates a deterministic audit trail. Every tool invocation initiated by the orchestration harness maps directly to a discrete, logged compute event inside the microVM sandbox. Incident response teams can correlate high-level model decisions with low-level kernel system calls, process executions, and network connections, providing granular visibility during post-incident investigations of exploited agent environments.

Memory Optimisation: Copy-on-Write and Checkpoint-Restore

Running isolated microVMs for thousands of concurrent agent instances introduces significant memory overhead and compute cost if each instance requires a dedicated operating system footprint. To make microVM isolation economically viable for high-density agent workloads, Agent Compute Engine employs copy-on-write (CoW) memory sharing and fast state checkpointing.

Instead of booting a complete Linux operating system for every agent session, the platform instantiates microVM guests from a shared, pre-warmed OS base template. Using copy-on-write memory mapping, multiple running microVMs share read-only access to the identical underlying physical memory pages containing the Linux kernel, core system libraries, and common language runtimes (such as Python binaries and Node.js modules).

Resource Dimension Standard MicroVM Model Agent Compute Engine CoW Model
Base Memory Overhead Dedicated RAM per instance (512MB – 2GB) Shared base memory pages across instances
Disk Footprint Full OS image duplication per guest Shared read-only template with thin delta layers
Idle Lifecycle State Continuous vCPU/RAM allocation Paused to disk/memory checkpoint
Cold-Start Latency Full kernel boot sequence (seconds) Fast snapshot restore (milliseconds target)
State Retention Requires persistent attached block storage Checkpoint-restored root filesystems

When an agent process writes to memory or modifies filesystem blocks, the host kernel allocates a private memory page exclusively for that specific instance. This minimizes physical memory consumption across dense clusters while maintaining strict isolation between tenant environments.

To address the cost of idle workloads, Agent Compute Engine introduces fast checkpointing and state restoration capabilities. Autonomous agents spend substantial time waiting for user input, external API responses, or upstream model inference generation. During these idle intervals, the platform pauses the microVM, serializing its vCPU state, register values, and dirty memory pages to a persistent state store, releasing physical CPU and memory resources back to the host pool.

When a new command arrives from the orchestration harness, the control plane restores the microVM from its checkpointed state. This mechanism preserves persistent Linux workspaces—including local file paths, installed package dependencies, and environment states—across extended sessions and underlying host maintenance events without requiring continuously allocated compute hardware.

Agent Substrate: Portable Kubernetes Runtime for Agent Sandboxes

Alongside the managed Agent Compute Engine service, Google announced Agent Substrate, an open-source, Kubernetes-native runtime designed for platform engineering teams that require agent sandbox orchestration on self-managed infrastructure. While Agent Compute Engine operates as a proprietary, fully managed Google Cloud service, Agent Substrate provides a cloud-agnostic framework built on Kubernetes Custom Resource Definitions (CRDs) and custom controllers.

Agent Substrate decouples agent lifecycle management from specific underlying cloud APIs. It manages microVM sandboxes as native Kubernetes primitives, orchestrating creation, state suspension, snapshot persistence, and restoration across standard Kubernetes worker nodes. When an agent enters an idle state, the Agent Substrate controller captures the snapshot boundary and frees node capacity, rehydrating the workload onto any available node when execution resumes.

Open-Source Metrics vs Cloud Performance

In his analysis of Google’s announcement, AI specialist Harel Asaf noted that performance benchmarks and operational metrics published during the initial release originate from Agent Substrate testing environments rather than the managed Agent Compute Engine. Boot latency figures, density ratios, pricing tiers, and public GitHub repository locations for Agent Compute Engine itself have not been released by Google.

For enterprise platform teams, choosing between Agent Compute Engine and Agent Substrate involves trade-offs between operational overhead and deployment flexibility:

  • Managed Simplicity vs Operational Control: Agent Compute Engine offloads hypervisor patching, physical capacity planning, and hardware maintenance to Google Cloud. Agent Substrate requires infrastructure teams to manage Kubernetes node pools, storage drivers, and VMM integrations.
  • Multi-Cloud Portability: Agent Compute Engine is restricted to Google Cloud infrastructure. Agent Substrate runs on any Kubernetes cluster—on-premises, AWS EKS, or Azure AKS—that supports the required virtualization drivers.
  • Egress Gateway Integration: Agent Compute Engine natively integrates with Google’s managed Agent Gateway and IAM services. Agent Substrate deployments require platform teams to configure custom ingress/egress controllers and SPIFFE identity providers.

Governance Stack: Identity, Registry, and Observability

Securing autonomous agents across enterprise environments requires operational governance beyond execution isolation. Google’s infrastructure architecture integrates a multi-layered control plane comprising four primary components: SPIFFE-based Agent Identity, Agent Registry, Agent Gateway, and OpenTelemetry-compatible observability.

# Inspecting a SPIFFE Workload API identity document issued to an agent runtime:
# Platform teams verify SVID issuance via local SPIFFE socket

spiffe-id-verifier \
  -socketPath /run/spire/sockets/agent.sock \
  -expectedSpiffeID "spiffe://prod.internal/ns/agent-runtime/sa/python-worker-01"

# Output confirms cryptographic workload attestation before network egress:
# SPIFFE ID: spiffe://prod.internal/ns/agent-runtime/sa/python-worker-01
# Trust Domain: prod.internal
# Validity: Expiring in 3599 seconds (Short-lived X.509 SVID)

The governance components operate in concert across the execution lifecycle:

SPIFFE-Based Agent Identity: Every agent instance is assigned a cryptographic identity using the Secure Production Identity Framework for Everyone (SPIFFE) standard. The host platform issues short-lived X.509 SVID (SPIFFE Verifiable Identity Document) certificates based on workload attestation parameters (such as image hash, namespace, and harness signature). This identity dictates which tools, cloud resources, and external APIs the agent may access via mutual TLS (mTLS).

Agent Registry: A centralized catalog governing pre-approved agent tools, system container templates, and execution capabilities. The registry enforces software supply chain security, ensuring that agent microVMs only mount pre-scanned base images and execute approved binary packages.

Agent Gateway Traffic Control: Functions as the centralized network enforcement point. It validates SPIFFE identities against policy rules, executes structural request inspection, logs outbound requests, and injects authentication tokens into authorized traffic.

OpenTelemetry Observability: Captures unified telemetry across the execution stack. Trace contexts propagate seamlessly from the orchestration harness through tool invocation RPCs, guest process execution, and Agent Gateway network egress. Integrating this data into an enterprise observability control plane allows SREs to monitor model latency, tool execution failures, and anomalous network patterns across multi-region infrastructure.

Workload Taxonomies: From Interactive Agents to Parallel Environments

Agent Compute Engine targets four operational workload profiles, each demanding distinct compute characteristics, memory configurations, and network isolation policies.

1. Interactive Consumer and Enterprise Agents

These workloads execute real-time code snippets, perform multi-step data manipulation, and conduct automated web browsing in response to direct user prompts. They require ultra-low cold-start latency to prevent interactive user friction. Execution sandboxes are typically short-lived, ephemeral instances that terminate immediately upon task completion, discarding all local guest memory and temporary storage.

2. Persistent Software Engineering Workspaces

Autonomous coding agents (such as Google’s internal Antigravity platform) require long-running, stateful Linux environments containing compilers, git repositories, language runtimes, and local testing frameworks. These workloads rely heavily on state checkpointing to pause execution while awaiting developer code reviews or external CI/CD pipeline results. The underlying sandbox filesystem must persist across host reboots, platform maintenance, and host OS updates.

3. Large-Scale Parallel Evaluation and Reinforcement Learning

Model evaluation and reinforcement learning (RL) workflows instantiate thousands of concurrent, highly parallel microVM environments. These sandboxes run automated regression tests, benchmark model performance, or generate training rollouts. This profile prioritises maximum compute density per host node and minimal per-instance memory consumption over persistent storage retention.

4. Lightweight Sandboxed Execution Logic

Embedded dynamic logic within enterprise cloud applications requires sandboxed execution of user-defined scripts or extensions. These lightweight tasks execute within highly constrained microVM boundaries with strict memory caps (e.g., 128MB RAM) and enforced execution timeouts (e.g., <500ms) to ensure secure multi-tenant execution.

Implementation Strategy for Enterprise AI Agent Sandboxes

Enterprise platform teams constructing secure agent execution platforms today can implement Google’s core architectural patterns using available cloud and open-source primitives prior to the public availability of Agent Compute Engine.

Step 1: Decouple Orchestration Nodes from Guest Execution Environments

Separate your agent architecture into two distinct deployment zones. Run the orchestration harness (LangChain, LlamaIndex, or custom Python controllers) inside secure, internal Kubernetes pod pools with restricted external network interfaces. Provision guest code execution workloads inside dedicated sandboxes (e.g., gVisor containers, Firecracker microVMs, or Kata Containers).

# Diagnostic script to verify zero-credential compliance inside an execution guest
# Test this command within staging sandbox images prior to deployment:

#!/usr/bin/env bash
set -euo pipefail

echo "[+] Auditing Environment Variables for Exposed Credentials..."
EXPOSED_KEYS=$(env | grep -Ei "aws_|gcp_|azure_|api_key|secret|token|password" || true)

if [ -n "$EXPOSED_KEYS" ]; then
    echo "[-] CRITICAL SECURITY RISK: Credentials found in guest memory!"
    echo "$EXPOSED_KEYS"
    exit 1
else
    echo "[+] SUCCESS: Zero secrets detected in sandbox environment."
fi

echo "[+] Verifying Network Egress Interception..."
# Attempt direct unproxied outbound request (should fail under strict policy)
if curl -s --connect-timeout 3 https://api.github.com > /dev/null; then
    echo "[-] WARNING: Direct network egress allowed; bypass possible."
else
    echo "[+] SUCCESS: Direct egress blocked. Traffic forced through gateway."
fi

Step 2: Implement Egress API Gateways for Perimeter Secret Injection

Remove static credentials from sandbox configuration files and environment variables. Deploy an egress proxy (such as Envoy Proxy or custom API Gateway instances) equipped with credential injection plugins. Configure local iptables rules inside the worker node to force all outbound HTTP/HTTPS traffic from guest sandboxes through the proxy layer.

Step 3: Adopt SPIFFE Workload Attestation

Implement SPIFFE identity standards (using HashiCorp Vault or SPIRE) to issue short-lived cryptographic identities to execution sandboxes upon creation. Force the egress API gateway to validate the calling sandbox’s SPIFFE ID before retrieving and appending API credentials to outbound requests.

Step 4: Benchmark MicroVM Checkpointing in Staging

Deploy Kubernetes runtime classes leveraging Kata Containers or Firecracker on staging nodes. Evaluate snapshotting performance, memory allocation footprints, and restore latencies across typical agent python runtimes. Test state recovery under simulated host preemption to validate persistent storage retention.

Common Implementation Pitfalls to Avoid

  • Environment Variable Leakage: Passing secret keys into sandbox containers via ENV flags during build or runtime initialization.
  • Standard Container Reuse: Relying solely on default Docker/OCI runtimes without user namespaces, seccomp filters, or hardware virtualization boundaries.
  • Unconstrained Egress: Allowing guest sandboxes direct outbound internet access without domain allowlisting or proxy inspection.
  • Monolithic Auditing: Logging tool execution at the harness layer without binding harness call IDs to kernel system-call events inside the execution guest.

Key Architectural Takeaways for AI Platform Engineers

The architecture of Google Agent Compute Engine establishes a reference model for running untrusted AI workloads safely at enterprise scale. Decoupling authentication credentials from guest execution environments eliminates the primary risk vector associated with prompt injection attacks and malicious dynamic code execution. If the guest operating system is compromised, the blast radius remains strictly confined to the ephemeral compute instance.

From an infrastructure economics perspective, hardware isolation cannot scale without aggressive memory optimization. High-density techniques like copy-on-write memory sharing and fast checkpoint-restore are necessary engineering primitives to make per-agent microVM execution financially viable compared to shared multi-tenant container fleets.

As platform teams await the public preview of Agent Compute Engine, evaluation criteria should center on three key benchmarks:

  • Cold-Start Latency: Measuring microVM restoration time from a checkpointed state when receiving interactive harness calls.
  • Density and Overhead: Analyzing memory overhead per active and idle agent instance on standard Google Cloud host nodes.
  • Pricing Topology: Evaluating whether Google charges for paused checkpoint states based on passive storage footprint or flat execution runtime fees.

Frequently asked questions

What is the difference between Google Agent Compute Engine and Agent Substrate?

Google Agent Compute Engine is a fully managed, proprietary service running isolated AI agent sandboxes on Google Cloud infrastructure. Agent Substrate is an open-source, Kubernetes-native runtime framework that allows platform teams to orchestrate agent microVM lifecycles, state checkpointing, and suspension on self-managed Kubernetes clusters across any cloud or on-premises environment.

How does Agent Compute Engine keep credentials secure during agent execution?

The platform removes all credentials, API keys, and OAuth tokens from inside the microVM sandbox. Outbound network requests emitted by the agent are intercepted at the virtual egress boundary by an external Agent Gateway. The gateway validates the agent’s identity, retrieves required tokens from external secret vaults, and injects authentication headers prior to forwarding requests outward.

What virtualization technologies does Agent Compute Engine rely on?

Google has not publicly disclosed the underlying hypervisor or virtual machine monitor powering Agent Compute Engine. While the service employs hardware-assisted microVM isolation, copy-on-write memory sharing, and fast state checkpointing, specific details regarding whether it uses gVisor, Firecracker, or a proprietary hypervisor remain unconfirmed prior to the public preview launch.

Can Agent Substrate be deployed on self-hosted Kubernetes clusters outside Google Cloud?

Yes. Agent Substrate is designed as an open-source, cloud-agnostic Kubernetes extension. It leverages standard Kubernetes Custom Resource Definitions (CRDs) and container runtime interfaces to manage sandbox lifecycles, enabling platform engineers to run microVM agent environments on self-managed infrastructure, AWS EKS, or Azure AKS.

How does harness-sandbox separation improve security auditability?

By strictly isolating the orchestration harness (brain) from the execution sandbox (hands), the control plane receives and dispatches explicitly typed RPC commands. This architecture creates a deterministic, unidirectional audit trail that correlates every high-level LLM tool call initiated by the harness with real-time kernel events, process creations, and network connections inside the guest microVM.

Sources and further reading

This article was drafted with AI assistance from the publicly cited sources and passed automated checks for structure and sourcing. Verify critical details against the vendor advisories linked above before acting.