Fly.io Machines vs Google Agent Runtime

Fly.io Machines boot the image you build as a Firecracker microVM with root, made for hosting apps in 17 regions. Google Agent Runtime hosts agent code on Google Cloud and gives it sandboxes that run as an unprivileged user in a locked container.

The companies and products

Fly.io Machines

Fly.io is an app hosting platform, and Machines are the microVMs underneath it that you can also start and stop through a REST API.

A Fly Machine boots your Docker image as a Firecracker microVM on Fly's own servers, in one of 17 regions. You pick a shared or performance CPU preset, attach at most one Volume for data that must last, and Fly Proxy can stop, suspend and wake Machines as traffic comes and goes. It is built for teams that host web apps and services worldwide; it is not a sandbox product, so this page compares the parts that overlap with agent work.

Kind of product: App hosting platform; Machines are its VM building block with a REST API
Isolation: Firecracker microVMs with hardware virtualization, on Fly's own servers
Regions: 17 regions in North America, Europe, Asia, Oceania, South America and Africa
CPU classes: Shared vCPUs guarantee 6.25% of each core with a burst balance; performance vCPUs get the full core
Storage: Root file system is ephemeral; one Volume of up to 500GB per Machine for lasting data
Free trial: 2 Machine hours or 7 days, up to 10 Machines of 2 vCPU / 4GB that stop after 5 minutes
Compliance: Lists SOC 2 Type II; a HIPAA package with a pre-signed BAA is sold as an add-on

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. All of them run as secure containers inside your Google Cloud project.

Kind of product: Managed agent hosting plus code, shell and browser sandboxes on Google Cloud
Former name: Vertex AI Agent Engine, renamed Agent Runtime in April 2026
Isolation: Secure container sandboxing; commands run as the unprivileged user appuser with no sudo
Launch stage: Shell and Computer Use sandboxes GA since 2026-09-09; custom containers, templates and snapshots launched in Preview on 2026-05-26
Regions: 23 locations across the US, Europe, Asia, Canada, Australia and Brazil
Billing: $0.085 per vCPU-hour and $0.009 per GiB-hour allocated, first 50 vCPU-hours and 100 GiB-hours free each month

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. “92nd cheapest of 367” means 91 of the other 366 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 workload	Fly.io Machines: price rank	Google Agent Runtime: price rank	bochka: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Fly gives root and lets you install Docker yourself, while Google's sandboxes have neither, so Fly sits far above Google here; bochka fits fully with Docker and /dev/kvm ready.	92nd of 367, with limits $836 a month	295th of 367, with limits $5,801 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Google fits fully here, since Runtime hosts a long-lived agent and bills only its working turns; on Fly the root disk resets on restart, so lasting memory must live on a Volume.	125th of 366, with limits $816 a month	28th cheapest of 366 $7,519 a month	5th cheapest of 366 $657 a month
Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Both are a compromise: Fly suits short bursts with per-second billing and cheap shared CPU, and Google's Code Execution sandbox is a ready Python interpreter with no network.	75th of 345, with limits $94 a month	254th of 345, with limits $275 a month	186th of 345, 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 Fly can give each user a public URL through Fly Proxy, while Google documents no public URL for a sandbox; bochka serves HTTPS on up to 50 ports per sandbox.	69th of 361, with limits $600 a month	280th of 361, with limits $1,916 a month	Cheapest of 361 $209 a month
RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month	48th of 360, with limits $2,838 a month	128th of 360, with limits $8,240 a month	34th of 360, with limits $2,000 a month
Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month	117th of 364, with limits $457 a month	79th cheapest of 364 $2,060 a month	10th cheapest of 364 $200 a month
CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that build containers need Docker, which Google's sandboxes do not have and Fly makes you install, and busy builds drain a shared Fly vCPU's burst balance.	152nd of 377, with limits $288 a month	98th cheapest of 377 $989 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Fly lets you SSH into a Machine, while Google has no SSH and runs each command in a new shell; bochka gives you SSH and a desktop.	118th of 368, with limits $53 a month	311th of 368, with limits $241 a month	18th cheapest of 368 $26 a month
Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Google gives agents a browser with a VNC view and a click and type API, Fly has nothing built in, and bochka streams a full 60fps desktop with Chromium.	95th of 369, with limits $173 a month	283rd of 369, with limits $1,648 a month	6th cheapest of 369 $200 a month
Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month	160th of 367, with limits $90 a month	102nd of 367, with limits $824 a month	7th cheapest of 367 $200 a month
Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month	161st of 346, with limits $67 a month	53rd cheapest of 346 $515 a month	6th cheapest of 346 $90 a month
Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month Fly does best of the three here: it spreads scrapers across 17 regions and bills only the seconds they run.	44th of 338, with limits $1,232 a month	210th of 338, with limits $8,240 a month	71st of 338, with limits $1,800 a month
Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month	118th of 360, with limits $63 a month	260th of 360, with limits $412 a month	2nd cheapest of 360 $200 a month
GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month	Can't run it	Can't run it	Can't run it
macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month	Can't run it	Can't run it	Can't run it

Key features

Feature	Fly.io Machines	Google Agent Runtime	bochka
Kind of product	App hosting platform; you boot your own image as a microVM through a REST API	Managed agent hosting plus code, shell and browser sandboxes on Google Cloud	Agent sandbox: a full VM per agent, ready to use
Isolation	Firecracker microVM with its own kernel, on Fly's own servers	Secure container sandboxing inside your Google Cloud project	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X (Zen 5) hosts
Root, Docker and nested virtualization	Root, and Docker you install yourself; Fly's own init, no systemd; no /dev/kvm	Runs as appuser with no sudo; images must not need root; no Docker or /dev/kvm documented	Root, systemd, Docker and /dev/kvm on every machine
Files after a stop	Root file system is ephemeral; lasting data goes on one Volume, billed for its full size around the clock	Pause keeps the file system at a rate Google does not publish; the sandbox is deleted when its TTL ends	The whole disk is kept, with snapshots every minute and on stop; a stopped sandbox costs nothing
Memory snapshots and branching	Suspend keeps memory for Machines up to 2GB; a clone copies the config and gets an empty Volume	Snapshots keep memory and files; start many sandboxes from one snapshot	Fork a running sandbox, disk included; resume reboots from disk (no memory snapshots)
How long a machine lives	No documented maximum runtime	TTL of up to 7 days for a custom container and 14 days for Code Execution	No session cap on paid plans
Desktop and computer use	None built in; you add a desktop and browser to your own image	A browser with a VNC live view, a click, type and screenshot API, and CDP for Playwright	60fps desktop and Chromium, computer use and browser control, embeddable stream
Coding agents	None built in; you install and run agents yourself	Managed Agents API (Preview) runs Google's Antigravity harness	Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API
Hosting your agent code	You run your agent as your own app on a Machine	Agent Runtime deploys ADK, LangGraph, LangChain, AG2 and LlamaIndex agents; idle time between turns is not billed	You run your own agent loop inside a sandbox
Keeping keys out of the sandbox	Secrets arrive as environment variables; Fly's open-source tokenizer proxy can be deployed yourself	You provision and scope the credentials the agent uses	AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out
Reaching the machine	SSH; public HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, private network	Through Google's API or a private endpoint in your own VPC; no SSH or public URL documented	SSH; HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4
Wake and idle	Fly Proxy stops or suspends idle Machines and wakes them when a request arrives	Runtime bills only while an agent works on a turn; sandboxes bill while they exist	You start and stop machines through the API; a stopped one costs nothing
Outbound rules	Network policies allow chosen ports and protocols and deny the rest	Off unless the template turns it on; route through your VPC with Cloud NAT, a static IP, Cloud NGFW or Secure Web Proxy	Open internet on every plan; no provider-side allowlist
Regions	17 regions on six continents	23 locations in the US, Europe, Asia, Canada, Australia and Brazil	EU only: Germany, Finland, France

Every feature Battleships tracks (43)

Feature	Fly.io Machines	Google Agent Runtime	bochka
Full VM (own kernel)	Yes	No	Yes
Docker inside	Yes	No	Yes
Nested virtualization	No	No	Yes
Root	Yes	No	Yes
Systemd	No	Not published	Yes
Desktop GUI	No	No	Yes
Browser	No	Yes	Yes
Computer-use API	No	Yes	Yes
SSH	Yes	No	Yes
Persistent disk	Yes	Yes	Yes
Pause/resume	Yes	Yes	Yes
Automatic snapshots	Yes	Yes	Yes
Fork/clone	Yes	Yes	Yes
Live fork (no pause)	Yes	Yes	Yes
Memory fork	No	Yes	No
Custom image (Docker or snapshot)	Yes	Yes	Yes
≥24 h sessions	Yes	Yes	Yes
Idle auto-stop	Yes	No	No
Wake on request	Yes	No	No
HTTPS preview URLs	Yes	No	Yes
Raw TCP inbound	Yes	Not published	Yes
Public IPv4	Yes	No	No
Egress allowlist	Yes	Yes	No
Secret proxy	No	No	Yes
Secret proxy for any API	No	No	Yes
Preinstalled agents	No	Yes	Yes
Agent harness API	No	Yes	Yes
MCP server	Yes	No	No
GPU	No	No	No
Windows	No	No	No
Arm64	No	Yes	No
Self-hosting	No	No	No
BYOC	No	No	No
Open source	Yes	No	No
Scoped API keys	Not published	Not published	Yes
Spend limits	No	Not published	Yes
Usage per sandbox (API)	No	Yes	Yes
Audit logs	Not published	Not published	No
SSO	No	Yes	No
SOC 2	Yes	Yes	No
HIPAA	Yes	Yes	No
EU data residency	Yes	Yes	Yes
Zero data retention	Not published	Not published	Yes

Performance

Fly.io MachinesNot measured

Google Agent RuntimeNot measured

bochka26.69 runs/s

There is no comparable measurement for Fly.io Machines or Google Agent Runtime: neither was part of the public StarSling run where bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. On Fly, results would depend on the CPU class, since shared vCPUs guarantee only 6.25% of a core with a burst balance while performance vCPUs get the full core.

Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Fly.io Machines and Google Agent Runtime have no published run in this suite yet, so there is no like-for-like number to compare.

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.

Scenario	Fly.io Machines, a month	Google Agent Runtime, a month	bochka, 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	$15 · Pay As You Go · with limits	$73 · Pay as you go	$20 · $20/mo
One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month	$36 · Pay As You Go · with limits	$301 · Pay as you go	$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	$487 · Pay As You Go · with limits	$3,626 · Pay as you go · with limits	$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	$110 · Pay As You Go · with limits	$1,030 · 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	$232 · Pay As You Go · with limits	$2,060 · Pay as you go	$2,000 · $2000/mo · with limits

Fly.io Machines: Fly bills each Machine per second while it runs, by CPU preset and memory, with no plan fee, and Volumes are billed for their full size all month. The figures here use Fly's lowest rate: shared vCPUs bought in 1-year reservation blocks for 40% off.

Google Agent Runtime: Google bills $0.085 per vCPU-hour and $0.009 per GiB-hour allocated, with the first 50 vCPU-hours and 100 GiB-hours free each month. Runtime skips idle time between turns, but sandboxes bill while they exist, and disk and egress rates are not published.

Google Agent Runtime: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.

Limits in those scenarios

Fly is a compromise in all five scenarios: its lowest figures need a 1-year reservation and use shared vCPUs that guarantee only 6.25% of each core, so long builds get throttled, and its API starts about one Machine per second per app. Google cannot run the 50-agent fleet because its sandboxes have no Docker, a sandbox is deleted when its TTL ends, and every Google row leaves disk and egress unpriced. On bochka the 1,000-job burst gets queued, since starts are capped at 90 a minute and 2,400 a day on the $2,000 plan.

Scenario	Fly.io Machines	Google Agent Runtime	bochka
One coding agent, workdays	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	disk beyond 0 GiB: price unknown egress price not published	None that bite
One agent that never stops	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	disk beyond 0 GiB: price unknown egress price not published	None that bite
50 agents in parallel	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	missing Docker inside disk beyond 0 GiB: price unknown egress price not published	None that bite
Sandboxes for your users	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	disk beyond 0 GiB: price unknown egress price not published	None that bite
1,000 short jobs at once	different kind of product: app platform 1-year commitment burstable CPU: 6.25% of each vCPU guaranteed, throttled above that	disk beyond 0 GiB: price unknown egress price not published	max 2,400 starts/day (needs ~6,667) max 600 starts/hour (needs ~1,000) bursts above 90 starts/min are queued (a burst of 333 takes ~4 min to start)

Which one should you use?

Use Fly.io Machines when

you want to build your own sandbox image with root, host what it makes on public URLs, and run near users in 17 regions.

A root microVM with no time limit. Useful if you want your own image with root and Docker inside: Fly boots it as a microVM and documents no maximum runtime.
Public apps in 17 regions. Useful for showing what agents build: Fly Proxy gives HTTPS, TCP, custom domains and Anycast IPs in 17 regions.
Wake on request. Useful for services that sleep between requests: Fly Proxy wakes a Machine on traffic, and small Machines resume with memory kept.

Use Google Agent Runtime when

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

A managed home for your agent code. Useful if you build agents with ADK or LangGraph: Agent Runtime hosts them and skips billing for idle time between turns.
Inside your Google Cloud network. Useful if agents must stay in a Google Cloud perimeter, with egress off by default and routed through your own firewall.
Memory snapshots to branch from. Useful for trying many paths: a Google snapshot keeps files and memory, and many sandboxes can start from one.

Where bochka fits

Fly gives you a building block to turn into a sandbox, and Google gives you a locked container tied to its own agent stack. If what you are really running is coding agents that install, build and test for hours, bochka gives each one a full VM with the tools, the desktop and the agents already inside.

Root, Docker and /dev/kvm ready

Google's sandboxes run as appuser with no sudo or Docker. Fly gives root, but you install Docker into your image, run without systemd and get no /dev/kvm, so emulators and nested VMs are out on both.

A disk that survives every stop

A Fly Machine's root file system is ephemeral, so lasting files need a Volume billed for its full size all month. A Google sandbox is deleted when its TTL ends, 7 days at most. bochka keeps the whole disk, saved every minute.

Coding agents and keys built in

Fly ships no agents and passes secrets as environment variables, and Google runs only its own Antigravity harness in Preview. bochka preinstalls Claude Code and Codex, drives them from outside, and keeps real keys out through its credentials proxy.

Use bochka when your agents need a real computer for hours: root, Docker, /dev/kvm, a desktop and public URLs on a full VM that keeps its disk, with coding agents and a keys proxy built in. Compare it one to one: bochka vs Fly.io Machines and bochka vs Google Agent Runtime.

Questions people ask

Is Fly.io Machines cheaper than Google Agent Runtime?

In all five scenarios we priced, yes, using Fly's shared vCPUs on a 1-year reservation. One agent running all month is $36 on Fly and $301 on Google, 50 agents in parallel are $487 versus $3,626, and 1,000 short jobs at once are $232 versus $2,060. bochka comes to $26, $317 and $2,000 for the same three, and Fly's figures assume work that stays within a shared vCPU's 6.25% baseline.

Which is faster, Fly.io Machines or Google Agent Runtime?

Neither has a comparable public measurement. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's run, and Fly's speed depends on whether you pick shared or performance vCPUs.

Can Fly.io Machines or Google Agent Runtime run Docker?

On Fly you can install and run Docker inside a Machine yourself, since it is a microVM with root, but there is no /dev/kvm for nested VMs. Google's sandboxes run as the unprivileged user appuser with no sudo, so Docker is not available. bochka has Docker, systemd and /dev/kvm ready on every machine.

Do they keep my files when a machine stops?

On Fly only what is on the one Volume a Machine can mount, since the root file system is ephemeral. A paused Google sandbox keeps its files, but the sandbox is deleted when its TTL ends, 7 days at most for a custom container. On bochka the whole disk is kept, with snapshots every minute and on stop.

Is Google Agent Runtime the same as Vertex AI Agent Engine?

Yes. Google renamed Vertex AI Agent Engine to Agent Runtime in April 2026, as part of Gemini Enterprise Agent Platform. Its code, shell and browser sandboxes are a separate part called Agent Sandbox.

Where does my data run?

Fly runs Machines in 17 regions on six continents, and Google runs Agent Runtime in 23 locations across the US, Europe, Asia, Canada, Australia and Brazil. bochka runs only in the EU (Germany, Finland and France), with EU data residency.

Try bochka

Install the CLI, then run bochka new.

Product preview