Google Cloud has introduced Agent Compute Engine, a compute service designed to reduce the cost of running AI agents that spend much of their time waiting. The service can pause inactive agent environments and restore them later while preserving their memory, files, and execution state.
The service was announced at AGNTCON + MCPCon and is expected to enter preview in the coming months. Google says it already powers Gemini’s agent capabilities for work tasks.
The idle-agent problem
AI agents rarely run continuously. They may wait for a human approval, a tool response, an external API call, or the next step in a multi-stage workflow.
In traditional cloud environments, keeping compute resources running during those gaps can be expensive. Shutting an agent down saves money, but restarting it often means rebuilding its environment and restoring its context, which adds latency and engineering complexity.
Agent Compute Engine is designed to avoid that trade-off. When an agent finishes a tool call or enters a waiting phase, its microVM can be checkpointed and moved from an active to an idle state. When the agent is needed again, Google says it can be restored from a snapshot.
How the technology works
Each agent runs in a hardware-isolated microVM rather than a conventional container. MicroVMs use their own kernel, creating a stronger isolation boundary than containers, which share the host operating system kernel.
That isolation matters for agents that execute AI-generated code, connect to external tools, or process untrusted input. If an agent is compromised, the impact is intended to remain contained within its own runtime environment.
Google says the service uses copy-on-write memory sharing to run multiple agents from a single operating-system template. Idle microVMs are paused through fast checkpoint-and-restore operations, reducing active compute consumption while preserving the agent’s state.
Potential savings for enterprises
The service is most relevant for long-running coding agents, research agents, and enterprise workflows that may remain active for hours or days while waiting between actions.
For these workloads, application-aware checkpointing can reduce idle sessions to near-zero active compute while retaining files and memory across turns and days. Google says agents can resume where they left off without paying for idle virtual machines.
For developers, the approach could also remove the need to build custom save-and-resume systems. Instead of writing code to preserve state across interruptions, teams could rely on the platform’s checkpointing mechanism.
Governance and security controls
Agent Compute Engine is part of a broader set of Google Cloud agent-governance capabilities. These include:
- Agent Registry, a centralized catalog for plugins, skills, MCP servers, and A2A agents.
- Agent Identity, an authentication and credential-management system that gives agents distinct identities.
- Agent Gateway, a runtime enforcement point for policies, identities, and network traffic.
Google’s design keeps service credentials outside the hardware sandbox. Instead of storing long-lived credentials inside the agent environment, credential injection and policy enforcement are handled through the Agent Gateway.
Trade-offs to consider
The service is not without limitations. Because it is closely integrated with Google Cloud, enterprises may face challenges moving agent workloads to another provider or operating them across multiple clouds.
Cost savings will also depend on workload patterns. Agents that remain continuously active and compute-intensive may see smaller benefits than agents with frequent idle periods. Organizations should measure how many agents hold state across more than a few minutes of inactivity before assuming meaningful savings.
Storage is another consideration. Persistent agent environments require disk space, and at scale, retaining thousands of suspended microVMs could increase infrastructure costs.
Checkpointing introduces new risks
Checkpointing is powerful, but it creates engineering challenges when an agent is paused in the middle of an external action.
For example, if an agent is suspended between sending an API request and receiving confirmation, it may resume without knowing whether the action completed. Developers must therefore design external operations to be safe to repeat, such as using idempotent APIs or explicit confirmation checks.
Long-lived environments can also drift over time as dependencies, files, and software versions change. Teams may need expiration policies and periodic rebuilds from clean base images to keep environments reproducible and auditable.
Debugging suspended environments may be more difficult as well, since developers may need to inspect paused virtual machines to diagnose issues that appear only after an agent resumes.
What it means for AI infrastructure
Agent Compute Engine reflects a growing shift in cloud infrastructure: AI agents are becoming a distinct workload category, with requirements that differ from web applications, batch jobs, and traditional virtual machines.
If Google’s approach works as described, it could make large agent fleets more economically viable by charging for active work rather than idle waiting time. But enterprises should treat the service as an emerging platform capability, validate its cost model against their own workloads, and design agent workflows that can safely survive pauses and resumes.
