Orbital / Google Agent Compute Engine: a business evaluation guide

Google Agent Compute Engine: a business evaluation guide.

Google announced Agent Compute Engine for AI-agent workloads. Use this practical framework to evaluate availability, isolation, identity, governance and cost.

AI infrastructure · Business evaluation

By Orbital Content Team · Published October 23, 2026

AI-assisted research and drafting with editorial review. Reported product, architecture, availability and benchmark statements were checked against two Google Cloud announcements published October 22, 2026. The evaluation framework and business implications are Orbital analysis. Orbital did not access the unreleased service, reproduce Google's benchmarks, validate security controls, inspect pricing or quotas, compare vendors or test a production workload.

Google Cloud announced Agent Compute Engine, infrastructure designed to give an AI agent a persistent, isolated computer for tasks such as running code, using tools, driving a browser and working across longer sessions. Google says the service will use hardware-isolated microVMs, short-lived identity and gateway-mediated access. The company is also expanding agent-governance capabilities across multiple runtimes.

The important buyer detail is timing: Google says Agent Compute Engine is targeted for preview in the coming months. The announcement does not provide public pricing, quotas, region coverage, service-level commitments or generally available production terms. A business can use the architecture to improve its requirements now, but should not build a committed launch plan around an unreleased service.

What Google announced on October 22

Google describes Agent Compute Engine as a purpose-built compute service for agent workloads. Each agentic session runs in a dedicated microVM with its own guest kernel and root access. Google says the design combines a VM-style isolation boundary with faster start, suspend and resume behavior for sessions that repeatedly alternate between acting and waiting.

The announced architecture separates the agent's decision layer from its execution environment. The execution environment can contain a filesystem, language runtimes, shell tools and a browser. Google says idle environments can be checkpointed while preserving files and memory, then resumed later. Persistent workspaces are intended to retain the useful working state across sessions.

Google also describes a zero-secrets design. The guest environment is not intended to hold persistent OAuth refresh tokens or cloud service-account keys. Instead, it receives short-lived identity material, while an external gateway validates identity and policy before exchanging or injecting credentials outside the microVM. Network access is mediated rather than giving the microVM ordinary direct network or VPC access.

Alongside the compute service, Google announced broader governance across Google Cloud, cross-cloud, on-premises and device environments. Named components include Agent Gateway for traffic and policy, Agent Registry for an approved inventory, Agent Identity for authentication and audit, and OpenTelemetry-compatible observability. Some expanded capabilities are described as current, some as preview and some as coming in preview soon or this quarter. Buyers must verify each feature separately.

Separate documented facts from business implications

Announcement evidence and the decision it does—and does not—support
AreaGoogle's documented statementPractical implicationNot yet established
AvailabilityAgent Compute Engine is targeted for preview in the coming months.Requirements and a future evaluation plan can start now.Preview date, eligible customers, regions, general availability or production readiness.
IsolationEach agentic session uses a dedicated hardware-isolated microVM with its own guest kernel.Isolation can reduce the blast radius of executing untrusted code.That every threat is prevented, that the design fits a buyer's compliance needs or that controls have been independently validated.
CredentialsLong-lived credentials stay outside the guest and short-lived identity is used.Credential exposure can be reduced when policy and identity are configured correctly.Correct least privilege, safe downstream tools or protection from every misuse of authorized access.
PersistenceWorkspaces can preserve files and memory while idle sessions are checkpointed.Long-running tasks may avoid rebuilding their environment for every step.Retention defaults, deletion behavior, backup guarantees or the cost of persistent state.
NetworkingTraffic passes through mediated boundaries and external policy enforcement.Egress and service access can become explicit control points.A buyer's exact allowlists, private connectivity, latency, failure behavior or third-party integration coverage.
EfficiencyGoogle describes rapid activation, idle checkpointing and shared base memory.The design targets workloads that alternate between bursts and waiting.Public price-performance for a specific business workload.
GovernanceGoogle names registry, identity, gateway, policy and observability capabilities.Agent fleets can be managed as governed systems rather than disconnected experiments.Availability and maturity of every announced control in the buyer's selected runtime.
Scale claimsGoogle reports internal scale and Agent Substrate benchmark results.The architecture has been designed around large agent fleets.Independent reproduction or equivalent results for a smaller customer's code, tools and data.

Hardware isolation is valuable, but it is only one layer. An agent inside a strong sandbox can still make an incorrect decision, use an allowed tool badly, expose data through an approved endpoint or generate a misleading result. The business still needs authorization rules, input controls, output validation, human approval and incident response.

Screen the workload before evaluating the platform

Agent Compute Engine is aimed at work that needs more than a single model response. The strongest candidate needs an execution environment and benefits from continuity between steps.

Workload-fit screen
QuestionPotential fitWeak fit or warning
Does the task execute code or use a browser?The workflow needs packages, files, command-line tools or controlled browser actions.The requirement is only classification, extraction or one generated draft.
Does state need to survive?Work continues across pauses, approvals or multiple sessions.Every request is independent and can be handled statelessly.
Is the agent idle between steps?It waits for a person, job, system or scheduled window.The task is a short continuous batch with no interactive pauses.
Is untrusted code or content involved?Isolation and mediated access are material requirements.The workflow can be completed without executing external code or opening broad tools.
Is there a repeatable business outcome?Success can be measured with a fixed test set and review rubric.The goal is broad experimentation without an owner or acceptance criteria.
Can consequences stay bounded?The first release creates drafts or recommendations for review.The first release would message customers, move money, delete data or make binding decisions.

Examples worth evaluating include an internal coding workspace, a research task that uses approved public sources, a long-running data preparation job, a browser-based reconciliation draft or an overnight test sweep. A simple FAQ answer, form classification or summarization flow may be cheaper and easier with a narrower service.

Start with the workflow, not the infrastructure. Orbital's AI automation readiness checklist helps define the trigger, owner, data boundary, approval and fallback before a team compares runtimes.

Define identity, credentials and data boundaries

Google's design makes an important distinction between the identity of an agent session and the credentials used to reach a service. A buyer should preserve that distinction in the operating model.

  1. Name the actor. Give each agent or workflow a unique identity that can be attributed in logs.
  2. Scope the task. Bind the identity to one approved purpose, user or job rather than a generic automation account.
  3. Limit the destination. Allow only the APIs, hosts, tools and methods required for that purpose.
  4. Use short-lived authorization. Avoid durable credentials in prompts, files, images or the guest environment.
  5. Keep user authority visible. If an agent acts on behalf of a person, record whose authority is being used and where delegated access ends.
  6. Separate read from write. A workflow may need broad discovery but very narrow mutation rights.
  7. Revoke centrally. The business needs one place to disable an identity, route or policy without rebuilding the agent.

The system should also classify data before an agent receives it. Record what may enter prompts, the workspace, logs, snapshots and persistent storage; where each copy lives; how long it remains; who can retrieve it; and how deletion is verified. Google says workspaces can persist. That makes retention and cleanup a design question, not an afterthought.

Map these dependencies with a tech stack audit. The map should include the model, harness, execution environment, identity provider, gateway, data stores, observability pipeline, human approval interface and every external tool.

Govern the workflow before increasing autonomy

An agent registry is useful only if teams use it as an operating control. For every agent, record:

  • business purpose, owner and technical maintainer;
  • model, harness, runtime and exact deployed version;
  • approved users, data classes, tools and destinations;
  • identity, permissions and credential path;
  • human approvals and actions the agent may never take;
  • expected output, validation rules and quality threshold;
  • logs, retention, monitoring and alert owners;
  • cost ceiling, concurrency limit and stop conditions;
  • fallback process, rollback version and kill switch; and
  • last review date and next review trigger.

Registry, policy and observability solve different problems. Inventory answers what exists. Policy controls what may happen. Observability records what did happen. None replaces an evaluation showing whether the agent performed the business task correctly.

Require a visible approval before customer communication, publishing, payment, account changes, deletion, legal commitments, hiring decisions or access expansion. Approval should show the proposed action, affected records, evidence, cost and a cancel option. A human clicking an unexplained button is not meaningful oversight.

Evidence to request before a production decision

When preview documentation and commercial terms become available, ask Google or an implementation partner for evidence tied to the exact service and configuration:

  • preview and production eligibility, regions, quotas and roadmap boundaries;
  • pricing units for active compute, idle or suspended state, storage, snapshots, networking, gateways, logs and support;
  • service-level objectives, maintenance behavior and failure recovery;
  • tenant, host, memory, storage and network isolation documentation;
  • identity issuance, token lifetime, revocation and delegated-user controls;
  • supported ingress, egress, private connectivity and domain policies;
  • workspace, snapshot, log and backup retention and deletion;
  • customer-managed encryption options and key-failure behavior;
  • audit exports, log completeness and integration with existing monitoring;
  • data-processing terms, support access and geographic handling;
  • vulnerability reporting, patching, incident notice and forensic support; and
  • which governance features are generally available, preview-only or future work.

Marketing architecture should lead to testable acceptance criteria. For example, do not accept “credentials remain outside the sandbox” as the end of the review. Test whether a compromised workflow can request an unauthorized host, method, resource, user scope or credential, and confirm the denial appears in the expected log.

Build a complete cost model

Google has not published pricing in the two October 22 announcements. Until prices, billing units and quotas are documented, no buyer can responsibly claim this architecture will lower the total cost of a specific workload.

Model at least:

  • active runtime by session and concurrency;
  • suspend, checkpoint, resume and storage charges;
  • persistent workspace and snapshot growth;
  • network, gateway and external-service traffic;
  • model tokens and tool-specific usage;
  • logs, traces, metrics and retention;
  • environment images, dependency caches and updates;
  • failed runs, retries, timeouts and abandoned sessions;
  • security, privacy, procurement and platform engineering;
  • human review, correction and exception handling;
  • support plans, incident response and disaster recovery; and
  • the manual fallback retained during outages or transition.

Measure cost per accepted business outcome, not per agent run. A cheap run that creates rework or an unsafe action is not efficient. Compare the candidate with the current manual process and with simpler automation that does not require a persistent execution environment.

Use one scorecard across runtime options

Evidence-based runtime scorecard
CategoryMinimum evidenceDecision measure
Task qualityRepresentative cases, acceptance rubric and critical-error count.Accepted outputs without prohibited behavior.
IsolationArchitecture documentation plus attempted boundary violations.Unauthorized file, process, network and tenant access denied.
IdentityTraceable session identity and delegated-user chain.Every action attributable; revocation takes effect as expected.
PolicyAllowlist, deny tests and approval gates.Unauthorized actions blocked outside the agent's own instructions.
DataInventory of prompts, files, snapshots, logs and backups.Location, retention, access and deletion meet requirements.
ReliabilityTimeout, restart, resume and dependency-failure tests.No duplicate or partial consequential actions.
ObservabilityLinked model, tool, network, identity and approval events.A reviewer can reconstruct an outcome without exposing unnecessary data.
CostComplete metering for accepted and failed cases.Predictable total cost per accepted outcome.
PortabilityDocumented images, interfaces, data export and fallback.A credible exit or migration path.
OperationsNamed owners, alerts, support path and rollback drill.Issues detected, contained and recovered within the business threshold.

Set non-negotiable thresholds before the test. Strong average quality should not compensate for one unauthorized write, data leak or missed approval. Keep critical failures separate from ordinary formatting or preference errors.

A bounded pilot once access is available

  1. Define one reversible workflow. Choose an internal task with a measurable output, approved low-sensitivity data and no automatic customer impact.
  2. Capture the baseline. Measure current cycle time, error rate, review effort and complete operating cost.
  3. Write the control contract. Document identity, inputs, allowed tools, destinations, data, approvals, logs, stop conditions and fallback.
  4. Build a representative test set. Include normal, missing, conflicting, malicious and dependency-failure cases.
  5. Start without write access. Validate environment creation, persistence, identity, network denial, logging and cleanup.
  6. Run shadow mode. Produce drafts alongside the current process. Review every result and reconcile every tool call.
  7. Add one permission. Expand a single data source or action only after its denied and allowed paths pass.
  8. Test interruption. Suspend, resume, revoke, time out, retry, roll back and disable the workflow.
  9. Reconcile cost. Include idle state, storage, model use, tools, logs, failures and human review.
  10. Decide deliberately. Stop, revise, keep as a controlled pilot or plan production. Do not let preview access imply approval.

For a small service business, the pilot does not need a large agent fleet. One well-defined workflow can reveal whether persistence, sandbox isolation and centralized governance solve a real constraint or add platform complexity without enough value.

Orbital's business take

Agent Compute Engine reflects an important shift: production AI agents need infrastructure and governance designed for tools, code, identity, long-running state and unpredictable pauses—not only an API call to a model. Separating credentials from the execution environment and mediating network access are sensible architectural directions.

The announcement is not yet a product-selection answer. Preview timing, pricing, regions, quotas, support, production terms and buyer-specific control evidence remain open. Google's internal scale and design experience are relevant signals, but they do not substitute for a test of the exact business workflow.

The useful action today is to improve requirements. Inventory proposed agents, define unique identities, remove long-lived secrets from execution environments, restrict egress, make approvals explicit and evaluate cost per accepted outcome. Those controls remain valuable whether the eventual runtime is Agent Compute Engine, another managed service or a smaller internal design.

Explore Orbital's AI automation services, tech stack consulting, connected-business planning, business consulting and service-business planning. A 60-minute consultation can turn one candidate workflow into a testable brief; implementation, cloud usage, third-party software, security, privacy, legal review and ongoing support are separately scoped.

Sources and editorial limits

Primary sources were checked October 23, 2026. Google Cloud published both cited announcements on October 22. Product architecture, internal usage, roadmap, availability and benchmark statements are Google's claims. Google says Agent Compute Engine is targeted for preview in the coming months; the cited materials do not publish a preview date, public price card, quota table, region list, service-level agreement or generally available production terms. Orbital did not access the service, indicate interest on a customer's behalf, reproduce performance or density benchmarks, validate hardware or software isolation, conduct a penetration test, inspect contracts, compare providers or calculate customer-specific savings. This article is business and technology analysis, not security, legal, privacy, compliance, procurement or investment advice. It does not guarantee availability, safety, performance, savings or business results.

Primary source links

Your next chapter.
Let’s give it lift.

Start a conversation