Google Agent Runtime vs Azure Container Apps Sandboxes

Google Agent Runtime hosts the agent code you build with ADK or LangGraph. Its Agent Sandbox runs tools in gVisor-isolated containers where commands have no root. Azure Container Apps Sandboxes gives each agent a microVM with its own kernel and root, which can suspend with its memory and wake on traffic.

The companies and products

Google Agent Runtime

Google Agent Runtime is the agent hosting part of Gemini Enterprise Agent Platform on Google Cloud, renamed from Vertex AI Agent Engine in April 2026.

It is a hyperscaler service, not a sandbox company. Agent Runtime deploys agents you build with ADK, LangGraph, LangChain, AG2 or LlamaIndex and bills them only while they work on a turn. Next to it, Agent Sandbox gives those agents a place to run code: a Code Execution sandbox, a shell or custom container sandbox, and a Computer Use browser. Each sandbox runs in a gVisor-isolated container in a Google-managed tenant project. Teams on GKE can also run the open-source GKE Agent Sandbox in their own cluster, with gVisor or Kata Containers, and manage it themselves.

Azure Container Apps Sandboxes

Azure Container Apps Sandboxes is a service inside Microsoft Azure that gives each agent or user an isolated microVM you create, suspend and resume through an SDK.

It is part of Azure Container Apps, the hyperscaler's serverless container platform, and lives in your Azure subscription as a sandbox group resource. Each sandbox boots from an OCI image or a snapshot and has its own kernel. A stop keeps the disk, or the disk and the memory, and a memory-mode sandbox resumes in under a second. It is built for teams already on Azure that want stateful code execution with Azure networking, identity and billing.

Which use cases each one fits

For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “34th cheapest of 361” means 33 of the other 360 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.

Use case and its workloadGoogle Agent Runtime: price rankAzure Container Apps Sandboxes: price rankboat: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
Google's sandboxes run without root and document no Docker. Azure runs Docker on its azure-dev image, but documents no nested virtualization or SSH. boat gives each agent root, Docker, /dev/kvm and SSH on a full VM.
310th of 365, with limits
$5,801 a month
33rd cheapest of 365
$5,276 a month
5th cheapest of 365
$634 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
Google fits this one: a sandbox lives up to 7 days, and a snapshot (Preview) carries it into a new sandbox. Azure's always-on price needs a 3-year commitment. boat also gives the assistant a desktop, a browser and SSH, with auto-stop turned off (default 1 hour).
34th cheapest of 361
$7,519 a month
52nd cheapest of 361
$6,780 a month
6th cheapest of 361
$657 a month
Code interpreter bursts
100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month
Azure suits short code runs: its sandboxes suspend with their memory and resume in under a second. Google's Code Execution sandbox is a ready interpreter. On boat, each create counts against the plan's start limits.
251st of 336, with limits
$275 a month
39th cheapest of 336
$354 a month
189th of 336, with limits
$2,000 a month
Sandboxes for your users
300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month
Azure can publish public HTTPS routes per port for each user sandbox, though 300 at once needs a quota raise. Google reaches a sandbox through its API or a private endpoint in your VPC. boat serves token-gated HTTPS on up to 50 ports per sandbox.
275th of 349, with limits
$1,916 a month
32nd cheapest of 349
$2,260 a month
3rd cheapest of 349
$209 a month
RL rollouts
1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month
132nd of 349, with limits
$8,240 a month
158th of 349, with limits
$10,740 a month
39th of 349, with limits
$2,000 a month
Agent evals
250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month
90th cheapest of 359
$2,060 a month
85th cheapest of 359
$1,728 a month
10th cheapest of 359
$200 a month
CI runners
40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month
Jobs that build containers need Docker. Google documents none inside its sandboxes, and Azure has it in images like azure-dev. boat runs Docker and /dev/kvm on every VM, within its per-plan start limits.
104th cheapest of 374
$989 a month
108th cheapest of 374
$1,046 a month
2nd cheapest of 374
$86 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
Neither documents SSH: Google runs commands through its API, and Azure gives a shell through its own CLI, SDK and portal. boat gives you SSH and a desktop.
317th of 371, with limits
$241 a month
327th of 371, with limits
$262 a month
19th cheapest of 371
$26 a month
Computer-use agents
50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month
Google gives a browser with a VNC live view and a click and type API. Azure's public images have no desktop; you build one into your own image and publish it on an HTTPS port. boat streams a full Linux desktop at 60fps.
85th of 367, with limits
$1,648 a month
58th cheapest of 367
$1,573 a month
7th cheapest of 367
$200 a month
Browser-use agents
50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month
Google ships a Chromium you can drive over CDP with Playwright. On Azure you build a browser into your own image. boat ships Chrome on a desktop in every sandbox.
132nd of 356, with limits
$824 a month
129th of 356, with limits
$795 a month
7th cheapest of 356
$200 a month
Scraping & bots (startup scale)
50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month
56th cheapest of 343
$515 a month
112th cheapest of 343
$561 a month
6th cheapest of 343
$90 a month
Mass scraping & bots (undetectable)
1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month
212th of 327, with limits
$8,240 a month
240th of 327, with limits
$10,956 a month
73rd of 327, with limits
$1,800 a month
Parallel red teaming
200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month
281st of 351, with limits
$412 a month
30th cheapest of 351
$517 a month
3rd cheapest of 351
$200 a month
GPU eval jobs
10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month
Not ranked: misses a requirementNot ranked: misses a requirementNot ranked: misses a requirement
macOS agents
5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month
Not ranked: misses a requirementNot ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureGoogle Agent RuntimeAzure Container Apps Sandboxesboat
IsolationgVisor-isolated container in a Google-managed tenant projectMicroVM per sandbox with its own kernelFull VM with its own kernel, on hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared
Root, Docker and /dev/kvmRuns as appuser with no sudo; images must not need root; Docker and /dev/kvm inside are not documentedRoot; Docker depends on the image (azure-dev ships it on systemd, the default ubuntu image has only Buildah); nested virtualization not documentedRoot, systemd, Docker and /dev/kvm on every sandbox
Getting a shellCommands run through API calls; SSH is not documentedInteractive shell through the aca CLI, SDK or portal; SSH is not documentedSSH, plus CLI and API exec
Desktop, browser and computer useA browser in a container with a VNC live view, a click, type and screenshot API, and CDPNo desktop or browser in the public images; you can build one into your own OCI image and publish it on an HTTPS portLinux desktop and Chrome streamed at 60fps, with computer tools for agents; no GPU
Inbound accessThrough Google's API or a private endpoint in your VPC; a public URL is not documentedPublic HTTPS routes per published port; private endpoint from your VNet at extra cost; no public IPUp to 50 HTTPS URLs, token-gated by default; SSH; raw ports over IPv6 only on sandboxes with no IPv4 of their own
Memory snapshots and forksSnapshots (Preview) keep memory and files; start many sandboxes from one snapshot (same image and architecture)Suspend with memory and resume in under a second; snapshot a running sandbox with its memory to seed new onesFork a running sandbox from its last 1-minute snapshot; memory is not saved, so a resume is like a reboot
Idle handlingSandboxes are billed while they exist; a paused one keeps its files at a lower, unpublished rateAuto-suspend after an idle timeout (5 minutes by default); traffic or a start command wakes itAuto-stop defaults to 1 hour; disk saved every minute and at each stop; no compute charge while stopped, but extra saved snapshots and the AI credentials proxy still bill
How long a sandbox livesTTL of up to 7 days for a custom container and 14 days for Code Execution; a snapshot (Preview) restores it into a new sandboxNo maximum runtime documentedNo session cap once auto-stop is off on a paid plan
Outbound internetOff unless the template turns it on; route through your VPC with Cloud NAT, a static IP, Cloud NGFW or Secure Web ProxyEgress policy with allow, deny, rewrite and header rules by host, path and method; VNet integrationOpen internet on every plan; no provider-side allowlist
Coding agentsManaged Agents API (Preview) runs Google's Antigravity harnessCopilot CLI and Claude Code images, run through the exec APISeven harnesses installed, including Claude Code and Codex, with a prompt, steer and events API
Keeping AI keys out of the sandboxYou provision and scope the credentials the agent usesYou set it up: an egress rule adds a group secret or managed-identity token as a header, outside the sandbox; the built-in Copilot and Claude connections put tokens insideOptional paid proxy ($1 a day plus $1 per 1,000 requests) for model providers and HTTPS APIs you register; other secrets still enter the sandbox
Hosting your agent codeAgent Runtime deploys ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; idle time between turns is not billedNo separate agent hosting; you run your code inside sandboxes or other Container AppsYou run your own agent loop inside a sandbox
Scaling up a fleetDefault quota of 500 sandbox creates a minute per project and region300 concurrent active cores per region and subscription by default; more by Azure support request100 to 2,000 sandboxes at once by plan, self-serve; on the $2,000 plan, starts above 90 a minute cost extra and above 270 a minute fail
Regions23 locations across the US, Europe, the Middle East, Asia, Canada, Australia and Brazil40 Azure regions, 9 of them in the EUGermany, Finland and France; you cannot pick a region; no US or Asia region
Every feature Battleships tracks (43)
FeatureGoogle Agent RuntimeAzure Container Apps Sandboxesboat
Full VM (own kernel)No documented wayYesYes
Docker insideNo documented wayYesYes
Nested virtualizationNo documented wayNot publishedYes
RootNo documented wayYesYes
SystemdNot publishedYesYes
Desktop GUINot publishedWith your own setupYes
BrowserYesWith your own setupYes
Computer-use APIYesNo documented wayYes
SSHNo documented wayNo documented wayYes
Persistent diskYesYesYes
Pause/resumeYesYesYes
Automatic snapshotsYesYesYes
Fork/cloneYesYesYes
Live fork (no pause)YesYesYes
Memory forkYesYesNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesYesYes
Idle auto-stopNo documented wayYesNo documented way
Wake on requestNo documented wayYesNo documented way
HTTPS preview URLsNo documented wayYesYes
Raw TCP inboundNot publishedNo documented wayYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo documented way
Secret proxyNo documented wayYesYes
Secret proxy for any APINo documented wayYesYes
Preinstalled agentsYesYesYes
Agent harness APIYesNo documented wayYes
MCP serverNo documented wayNo documented wayNo documented way
GPUNo documented wayNo documented wayNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64YesNo documented wayNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCNo documented wayNo documented wayNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsNot publishedYesYes
Usage per sandbox (API)YesYesYes
Audit logsNot publishedYesNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesYesNo documented way
EU data residencyYesYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

Google Agent RuntimeNot measured
Azure Container Apps SandboxesNot measured
boat28.06 runs/s

Neither Google Agent Runtime nor Azure Container Apps Sandboxes is in the public benchmarks we use, so we cannot say which is faster. For reference, boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15 in StarSling's run of 3 October 2026 (run 37073680030). Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure.

V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Google Agent Runtime and Azure Container Apps Sandboxes are not in the public benchmarks we use, so we cannot say which is faster.

Pricing in five scenarios

Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario. Start limits, per-start fees and plan minimums are in the price, boat's included.

ScenarioGoogle Agent Runtime, a monthAzure Container Apps Sandboxes, a monthboat, a month
One coding agent, workdays
4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days
$73 · Pay as you go$68 · Pay-as-you-go$20 · $20/mo
One agent that never stops
4 vCPU / 8 GB, 50 GB disk, running 24/7 all month
$301 · Pay as you go$262 · Pay-as-you-go · with limits$26 · $20/mo
50 agents in parallel
50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside
$3,626 · Pay as you go · with limits$3,421 · Pay-as-you-go$317 · $20/mo × 3 seats
Sandboxes for your users
2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once
$1,030 · Pay as you go$989 · Pay-as-you-go$200 · $100/mo × 2 seats
1,000 short jobs at once
2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month
$2,060 · Pay as you go$2,148 · Pay-as-you-go$8,800 · $2000/mo · with limits

Google Agent Runtime: Google bills $0.085 per vCPU-hour and $0.009 per GiB-hour allocated, rounded to the second. The pricing page lists a monthly free amount but does not say it covers sandboxes, so our totals do not subtract it. Runtime skips idle time between turns, but sandboxes are billed while they exist. A paused one costs less at an unpublished rate, and disk, snapshot and egress rates are not published.

Azure Container Apps Sandboxes: Azure bills per second on the Container Apps Consumption meters for the vCPU and memory of the sandbox's tier while it runs, idle time before auto-suspend included. Stopped sandboxes pay no CPU or memory, and there is no plan fee. Some regions such as West Europe and UK South charge more, and storage for images, snapshots and volumes is announced as billed per GiB later.

Azure Container Apps Sandboxes: Plans cost $20, $100, $500 or $2,000 a month. The whole plan price comes back as VM time for that month, and it does not carry over. A 4 vCPU / 8 GB sandbox costs $0.036 an hour, billed per second while it runs, busy or idle. The $20 plan includes 200 starts a day; extra starts cost $0.03 to $0.07. A stopped sandbox has no compute charge; saved snapshots above the plan's count and the AI credentials proxy still charge. A card is required, also for the 7-day trial.

Limits in those scenarios

Each of the two fits four of the five scenarios. Google does not fit the 50-agent fleet, because it documents no Docker inside its sandboxes, and every Google row leaves disk and egress unpriced. A Google sandbox is deleted when its TTL ends, 7 days at most for a custom container; a snapshot (Preview) carries it into a new sandbox. Azure's always-on price ($262 a month) needs a 3-year savings plan, and Azure caps active cores at 300 per region and subscription by default, so 300 user sandboxes and 1,000 short jobs need a support request first. boat fits all but the burst: the $2,000 plan includes 90 starts a minute, charges for extra starts and refuses starts above 270 a minute. boat's always-on agent needs auto-stop turned off (default 1 hour).

ScenarioGoogle Agent RuntimeAzure Container Apps Sandboxesboat
One coding agent, workdays
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenarioNone for this scenario
One agent that never stops
  • disk beyond 0 GiB: price unknown
  • egress price not published
  • 3-year commitment
None for this scenario
50 agents in parallel
  • missing Docker inside
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenarioNone for this scenario
Sandboxes for your users
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenarioNone for this scenario
1,000 short jobs at once
  • disk beyond 0 GiB: price unknown
  • egress price not published
None for this scenario
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429

Which one should you use?

Use Google Agent Runtime when

you build agents with ADK or LangGraph on Google Cloud and want them hosted in your own project, with short code runs and a browser in a gVisor sandbox behind your network rules.

  • A managed home for your agent code. If you build agents with ADK or LangGraph, Agent Runtime hosts them and does not bill idle time between turns.
  • A browser agents can drive. Its Computer Use sandbox gives agents a browser with a VNC live view, a click and type API, and CDP for Playwright.
  • Egress locked down by default. Outbound internet is off unless a template turns it on, and it can leave through your VPC with a static IP.

Use Azure Container Apps Sandboxes when

your team already runs on Azure and wants microVMs from its own images with root, that suspend with their memory, wake on traffic and sit behind fine-grained egress rules.

  • A microVM with root. Each sandbox has its own kernel and root, and images like azure-dev ship Docker on systemd.
  • Memory suspend and wake on traffic. Idle sandboxes suspend with their memory and resume in under a second when traffic or a start command arrives.
  • Your own image and public ports. A sandbox boots from any OCI image you import, runs until you stop it or it goes idle, and can publish HTTPS routes per port.

Where boat fits

Google and Azure both run agents inside a hyperscaler account, and both are built more for tool calls than for agents that work like a person at a computer. If your agents install tools, run Docker and emulators, open a browser on a screen or serve what they build, boat gives each one a full VM that keeps its disk. boat has no pause with memory and no US region.

Root, Docker and /dev/kvm on every VM

Google runs commands as appuser with no sudo and documents no Docker, so the 50-agent fleet does not fit there. On Azure, Docker means picking an image like azure-dev, and nested virtualization for Android emulators is not documented. boat has all three on every sandbox.

A screen, SSH and shareable URLs

Google gives a browser view and documents no public URL; Azure publishes HTTPS routes and documents no SSH or desktop. You set up a VPC endpoint or tunnel on Google, and a display and streaming stack in your own image on Azure. boat ships SSH, a 60fps desktop and token-gated HTTPS URLs.

Coding agents driven from outside

Google's Managed Agents API is in Preview and runs Antigravity. Azure's Claude Code image runs through raw exec, and its built-in connections put tokens inside the sandbox. boat drives seven harnesses through one API, and its optional paid credentials proxy keeps real keys of supported providers out.

Use boat when your agents need a whole computer: root, Docker, /dev/kvm, SSH, a 60fps desktop and public HTTPS URLs on a full VM that keeps its disk, with coding agents installed. boat runs only in Germany, Finland and France, and caps starts per plan. Compare it one to one: boat vs Google Agent Runtime and boat vs Azure Container Apps Sandboxes.

boat's own limits
  • Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
  • Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
  • A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
  • Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
  • boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
  • Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
  • Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
  • Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source

Questions people ask

Is Google Agent Runtime cheaper than Azure Container Apps Sandboxes?

They are close. Azure comes out a little lower in two of our scenarios: one coding agent on workdays is $68 a month on Azure and $73 on Google, and sandboxes for your users are $989 against $1,030. For 1,000 short jobs at once Google is lower, $2,060 against $2,148. boat comes to $20 and $200 a month for the first two, and does not fit the burst.

Which is faster?

Neither Google Agent Runtime nor Azure Container Apps Sandboxes is in the public benchmarks we use, so we cannot say. For reference, boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB in StarSling's run of 3 October 2026, on an AMD Ryzen 9 9950X host.

Can Google Agent Runtime or Azure Container Apps Sandboxes run Docker?

Google's sandboxes run commands as appuser with no sudo, images must not need root, and Google documents no Docker inside; you build images outside and push them to Artifact Registry. On Azure it depends on the image: azure-dev ships Docker on systemd, while the default ubuntu image has only Buildah. boat runs Docker and /dev/kvm on every sandbox.

Can I SSH into either one?

Neither documents SSH. Google runs commands through its API, and Azure gives an interactive shell through the aca CLI, the SDK or the portal. Every boat sandbox has SSH.

Can a sandbox keep its memory when it stops?

Both can. Google snapshots (Preview) keep memory and files, and Azure suspends a sandbox with its memory and resumes it in under a second, waking on traffic. boat saves the disk every minute and at each stop, but a resume is like a reboot.

Where do they run?

Google runs in 23 locations across the US, Europe, the Middle East, Asia, Canada, Australia and Brazil, and Azure in 40 regions, 9 of them in the EU. boat runs on machines in Germany, Finland and France; you cannot pick a region, and snapshot copies can be stored outside the EU.

Try boat

Install the CLI, then run boat new.

7-day free trial

More comparisons