Google’s AI Agents Can Pause Their Virtual Computers While Waiting

Conceptual illustration of a server hosting an active AI workspace beside a paused virtual computer with its working state preserved. Automation
An AI agent can keep a task open without keeping its execution computer active. Google’s approach preserves the working environment between actions, while workflow recovery remains a separate problem.

An AI agent has finished processing a file. It asks you which result to export, and you leave the conversation open while you decide. The task still exists, but its execution computer may have nothing left to run.

Google’s Agent Compute Engine can pause that virtual computer and restore it when another command arrives. The working environment survives the gap between actions.

Google announced the service on October 22, 2026. It already supports workloads inside Google; a public preview is planned for the coming months.

The model works outside the computer it controls

Google separates the agent’s orchestration software, called the harness, from the sandbox that executes commands. The harness calls the model and manages the task. The sandbox provides the working computer.

That computer runs inside a small, hardware-isolated virtual machine, or microVM. The model can generate its next response elsewhere while the execution environment is paused.

This is the same boundary explained in our guide to how AI agents actually use tools: the model requests an action, and software executes it.

What happens between two commands

According to Google’s technical deep dive, the sandbox signals when no active commands or background tasks remain. The host can then checkpoint the environment and restore it for a later tool call.

Outside the sandbox Model + orchestration

The model produces the next response. The orchestration software manages user input and sends tool commands.

Tool commands enter; results return

Execution environment lifecycle

  1. Execute the command

    The virtual computer runs code or another requested tool operation.

  2. Save state and pause

    Once commands and background tasks finish, the host checkpoints the environment.

  3. A new command arrives

    The orchestration software requests another operation in the paused environment.

  4. Restore and continue

    The environment resumes from its saved state to execute the next command.

Simplified lifecycle based on Google’s description. The highlight shows the order of events, not measured execution or resume times. The model runs outside the paused environment.

The important condition is that execution work has finished. A low CPU reading alone cannot establish that an environment is ready to suspend.

A saved computer and a saved workflow preserve different things

A machine snapshot preserves an execution environment. A workflow checkpoint records application progress. Depending on the system, either may help work continue, but their contents and recovery boundaries differ.

Google’s ADK tutorial on long-running agents demonstrates explicit workflow state stored persistently, with external events triggering continuation.

Machine snapshots and workflow checkpoints
Question Virtual machine snapshot Workflow checkpoint
What is saved? Machine execution state, including memory where supported. Disk state and storage are handled by the platform’s persistence design. Recorded application data, completed steps, pending work and relevant results.
How does work continue? The platform restores the environment from its saved state. The application loads recorded progress and continues from a supported workflow boundary.
Does it preserve a running process? A memory-inclusive snapshot can preserve process state. Not necessarily. A new process can reconstruct work from stored records.
What about external actions? Restoration alone does not establish whether an external action completed. Only recorded outcomes are known; uncertain actions still need reconciliation.

The comparison describes general mechanisms, not a guarantee for every platform. For failure scenarios, see what happens when an AI agent crashes halfway through a task.

An example: the file is ready, but the user has not decided

From a processed CSV to an approved export

  1. Process the file. An agent reads a sales CSV, checks its columns and creates a regional summary. It saves an intermediate result in its workspace.
  2. Ask for a decision. The agent asks whether you want every region or only selected ones. Its file-processing command has finished.
  3. Wait with the environment preserved. With no active commands or background tasks remaining, the environment can be checkpointed and paused.
  4. Receive the answer. You choose two regions. The orchestration software turns that decision into the next tool command.
  5. Resume and export. The environment is restored. The next command uses the saved intermediate result to create the requested file.

Illustrative workflow, not a reported Google demonstration or benchmark. File retention and recovery depend on the platform’s storage and lifecycle guarantees.

For this example, the useful acceptance test is concrete: does the exported file contain the selected regions, and can the intermediate result be reused after the pause?

Restoring local state does not settle external uncertainty

Now imagine that the next command sends the report to a remote service. The service accepts it, but the confirmation is lost.

Restoring the caller cannot, by itself, prove whether delivery succeeded. Before repeating the action, the workflow needs to check its outcome or use duplicate protection supported by the receiving service.

That is the problem behind AI agents repeating actions after a timeout. A preserved environment and a reliable record of external effects serve different purposes.

Where the resource saving comes from

Keeping a dedicated execution computer active throughout a user’s decision reserves resources during a gap in useful work. Pausing it creates an opportunity to reclaim active capacity while retaining a restorable environment.

Google also describes copy-on-write sharing of common memory content across agent environments. Shared starting material and idle suspension address different sources of resource overhead.

For a real deployment, evaluate the whole lifecycle: active execution, retained storage, checkpoint overhead and the delay before useful work resumes. The practical question is whether your task continues correctly and responsively after its waits.

Sources

Rate article
Add a comment