Fly.io Machines vs Deno Sandbox

Both run code in Firecracker microVMs. Fly.io Machines are an app hosting building block that runs your image for as long as you want, while Deno Sandbox is built for short runs of untrusted code that start in under 200 ms and end after 30 minutes.

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

Deno Sandbox

Deno Sandbox is part of Deno Deploy, the hosting platform from the company behind the Deno runtime, and runs untrusted or AI-generated code in Linux microVMs.

Each sandbox is a Firecracker microVM with 2 vCPU, up to 4 GB of memory and a 10 GB disk that is wiped when it ends, created from a TypeScript or Python SDK. Outbound traffic goes through a proxy that can enforce a host allowlist and swap placeholder secrets for real ones. It is built for short runs of agent or user code, and a sandbox can be promoted to a Deno Deploy app.

Isolation: Firecracker microVM per sandbox
Machine size: 2 vCPU, 768 MB to 4 GB memory, 10 GB ephemeral disk
Lifetime: Bound to a session, up to 30 minutes
Regions: Amsterdam and Chicago; volumes only in Chicago
Plans: Sandboxes on Pro and Builder; 3 or 20 at once per region
Compliance: Deno Deploy states SOC2 and ISO27001; HIPAA BAA for enterprise contracts

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	Deno Sandbox: price rank	bochka: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Fly can keep an agent running for hours where Deno stops at 30 minutes, but on Fly you build the image and keep files on a Volume; bochka fits fully with Docker, /dev/kvm and a desktop ready.	92nd of 367, with limits $836 a month	290th of 367, with limits $5,665 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month cannot run on Deno's 30-minute sandboxes, and on Fly only its one Volume survives a restart; bochka keeps the whole disk.	125th of 366, with limits $816 a month	287th of 366, with limits $5,803 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 Short code bursts suit both: Deno starts in under 200 ms and bills CPU only while code runs, and Fly bills per second with no plan fee.	75th of 345, with limits $94 a month	141st of 345, with limits $329 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 has no published cap on Machines at once but creates about one per second per app, while Deno Builder allows 20 sandboxes at once per region.	69th of 361, with limits $600 a month	148th of 361, with limits $1,863 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	122nd of 360, with limits $7,963 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	296th of 364, with limits $1,563 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 that builds Docker images needs Docker, which you can install on Fly but Deno does not document, and neither offers /dev/kvm for Android emulators; bochka has both.	152nd of 377, with limits $288 a month	304th of 377, with limits $731 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box that stays on all month works on Fly with a Volume, not on Deno with its 30-minute lifetime; bochka keeps the whole disk and costs nothing while stopped.	118th of 368, with limits $53 a month	179th of 368, with limits $200 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 Neither Fly nor Deno ships a desktop, so computer use means building and streaming one yourself; bochka has a 60fps desktop with Chromium in every machine.	95th of 369, with limits $173 a month	280th of 369, with limits $1,583 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	284th of 367, with limits $783 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	286th of 346, with limits $573 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 ranks far ahead of Deno here: scrapers can spread across 17 regions with no 30-minute stop or 20-at-once cap.	44th of 338, with limits $1,232 a month	247th of 338, with limits $11,923 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	251st of 360, with limits $367 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	Deno Sandbox	bochka
Kind of product	App hosting platform; you boot your own image as a microVM	Sandbox for short runs of untrusted or AI-written code, part of Deno Deploy	Agent sandbox: a full VM per agent, ready to use
Isolation	Firecracker microVM with its own kernel	Firecracker microVM with its own kernel	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts
Machine size	Shared or performance CPU presets you choose	2 vCPU fixed, 768 MB to 4 GB memory, 10 GB disk	4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB on the $100 plan and above
Session length	No documented cap; a Machine runs until you or autostop stop it	Up to 30 minutes; longer work can be promoted to a Deno Deploy app	No cap on paid plans; you set the time to live
Files after a stop	Root file system is ephemeral; one Volume of up to 500GB per Machine, billed for its full size all month	Root disk wiped when the sandbox ends; opt-in volumes of 300 MB to 20 GB, Chicago only	The whole disk is kept, saved every minute and on stop; a stopped sandbox costs nothing
Pause, snapshots and fork	Suspend keeps memory for Machines up to 2GB; a clone copies config and gets an empty Volume	Read-only volume snapshots that new sandboxes boot from; no pause or fork	Automatic disk snapshots and fork of a running sandbox; resume reboots from disk
Docker, systemd and nested virtualization	Root and Docker you install yourself; Fly's own init, no systemd; /dev/kvm not offered	Root access; Docker and nested virtualization not documented	Docker, root, systemd and /dev/kvm on every machine
CPU	Shared vCPUs guarantee 6.25% of a core plus bursts; performance vCPUs get the full core at a higher rate	2 vCPU, CPU billed only while code is running	One CPU class on every plan, with no baseline quota or burst balance
Start time	Fast-starting microVMs; Fly Proxy can wake a stopped Machine on a request	Under 200 ms	Boots a full VM
Desktop and coding agents	None built in; you add a desktop, browser and agents to your own image	No desktop; a root image with Claude Code run through shell commands, a VS Code editor in the browser and SSH	60fps desktop with Chromium and computer use; Claude Code, Codex and more preinstalled with a prompt, steer and events API
Keeping keys out of the sandbox	Secrets arrive as environment variables; Fly's open-source tokenizer proxy can be deployed yourself	Secrets swapped in on outbound requests to approved hosts; the sandbox only sees a placeholder	AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out
Outbound rules	Network policies allow chosen ports and protocols and deny the rest	Host allowlist per sandbox, enforced by a proxy outside the VM	Open internet on every plan; no provider-side allowlist
Reaching the sandbox	Public HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, private network	HTTPS URL per exposed port, public without authentication; SSH	HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv6 or IPv4
Regions	17 regions on six continents	Amsterdam and Chicago	EU only: Germany, Finland, France

Every feature Battleships tracks (43)

Feature	Fly.io Machines	Deno Sandbox	bochka
Full VM (own kernel)	Yes	Yes	Yes
Docker inside	Yes	Not published	Yes
Nested virtualization	No	No	Yes
Root	Yes	Yes	Yes
Systemd	No	Not published	Yes
Desktop GUI	No	No	Yes
Browser	No	No	Yes
Computer-use API	No	No	Yes
SSH	Yes	Yes	Yes
Persistent disk	Yes	Yes	Yes
Pause/resume	Yes	No	Yes
Automatic snapshots	Yes	No	Yes
Fork/clone	Yes	No	Yes
Live fork (no pause)	Yes	No	Yes
Memory fork	No	No	No
Custom image (Docker or snapshot)	Yes	Yes	Yes
≥24 h sessions	Yes	No	Yes
Idle auto-stop	Yes	No	No
Wake on request	Yes	No	No
HTTPS preview URLs	Yes	Yes	Yes
Raw TCP inbound	Yes	No	Yes
Public IPv4	Yes	No	No
Egress allowlist	Yes	Yes	No
Secret proxy	No	Yes	Yes
Secret proxy for any API	No	Yes	Yes
Preinstalled agents	No	Yes	Yes
Agent harness API	No	No	Yes
MCP server	Yes	No	No
GPU	No	No	No
Windows	No	No	No
Arm64	No	No	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	Yes	Yes
Usage per sandbox (API)	No	No	Yes
Audit logs	Not published	Not published	No
SSO	No	No	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

Deno SandboxNot measured

bochka26.69 runs/s

There is no comparable measurement for either one: neither Fly.io Machines nor Deno Sandbox is in the StarSling benchmark where bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. On Fly the result would depend on the CPU class, since shared vCPUs guarantee only 6.25% of a core, and Deno's fixed 2 vCPU shape could not run the 4 vCPU test as set up.

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 Deno Sandbox 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	Deno Sandbox, 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	$53 · Pro · with limits	$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	$200 · Builder · 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	$487 · Pay As You Go · with limits	$2,779 · Builder · 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	$783 · Builder · with limits	$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	$1,563 · Builder · with limits	$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; Volumes bill for their full size all month. The figures here use shared vCPUs bought in 1-year reservation blocks for 40% off, the lowest rate Fly sells.

Deno Sandbox: Sandboxes need Pro at $20 a month or Builder at $200 a month, with CPU, memory and egress allowances shared with Deno Deploy apps. Past those, CPU costs $0.10 per hour of active CPU time and memory $0.025 per GiB-hour for the whole life of the sandbox.

Deno Sandbox: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.

Limits in those scenarios

Neither fits any of the five scenarios as written. Fly's low figures need a 1-year reservation and 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. Deno is fixed at 2 vCPU and 4 GB, stops each sandbox after 30 minutes, and Builder allows 20 at once per region, short of 50 agents or 300 users. bochka fits four of the five; at 1,000 short jobs at once it queues starts above 90 a minute.

Scenario	Fly.io Machines	Deno Sandbox	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	Pro: sessions capped at 0.5 h capped at 2 vCPU / 4 GiB largest size is 2 vCPU / 4 GiB disk beyond 10 GiB: price unknown	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	Builder: sessions capped at 0.5 h capped at 2 vCPU / 4 GiB largest size is 2 vCPU / 4 GiB disk beyond 10 GiB: price unknown	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	Builder: max 20 concurrent Builder: sessions capped at 0.5 h capped at 2 vCPU / 4 GiB largest size is 2 vCPU / 4 GiB	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	Builder: max 20 concurrent	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	Builder: max 20 concurrent	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 long-running microVMs from your own image, near users in many regions, and you are happy to build the sandbox yourself.

No 30-minute stop. For work that runs for hours or all month: a Fly Machine has no documented time cap and keeps running until you stop it.
17 regions worldwide. For users spread across the world: Fly runs Machines in 17 regions, from the US to Sydney and Johannesburg.
Wake on request and a full app platform. For services that sleep between requests: Fly Proxy wakes Machines on traffic, with custom domains and a private network around them.

Use Deno Sandbox when

you run short pieces of untrusted code that must start in milliseconds and reach only the hosts you allow, especially on Deno Deploy.

Starts in under 200 ms. For one sandbox per request: Deno says a sandbox starts in under 200 ms, and CPU bills only while code runs.
Locked-down outbound traffic and secrets. For untrusted code: each sandbox can reach only hosts you list, and real secrets are swapped in outside the VM.
A path to Deno Deploy. For teams already on Deno Deploy: a sandbox can be promoted to a Deploy app on the same meters.

Where bochka fits

If what you are running is coding or computer-use agents that work for hours, both products leave a gap: Deno stops at 30 minutes on 2 vCPU, and Fly makes you build the sandbox and keep files on a Volume. bochka gives each agent a full VM with Docker, a desktop and coding agents ready, and a disk that survives every stop.

A disk that keeps everything

On Deno the root disk is wiped after at most 30 minutes, and on Fly anything outside the one Volume can vanish on a restart, while the Volume bills its full size all month. bochka keeps the whole disk, saved every minute, free while stopped.

Docker, systemd and /dev/kvm ready

Deno does not document Docker, and on Fly you install it yourself without systemd. Neither offers /dev/kvm, so Android emulators and nested VMs cannot start. bochka has all of them on every machine.

A desktop and agents you drive from outside

Neither ships a desktop, so computer use means building one. On Fly you also package agents into your image, and on Deno you run Claude Code through shell commands and parse its output. bochka has a 60fps desktop and a prompt, steer and events API.

Use bochka when your agents do real work for hours: installs, builds, Docker, emulators and a browser on a full VM whose disk survives every stop, with coding agents and a keys proxy built in. Compare it one to one: bochka vs Fly.io Machines and bochka vs Deno Sandbox.

Questions people ask

Is Fly.io Machines cheaper than Deno Sandbox?

In every scenario on this page, yes. One agent running all month is $36 on Fly against $200 on Deno, and 50 agents in parallel are $487 against $2,779 a month. Fly's figures assume a 1-year reservation and shared vCPUs, and Deno's 2 vCPU shape and 30-minute cap mean neither fits these scenarios as written.

Which is faster, Fly.io Machines or Deno Sandbox?

Neither has a comparable CPU measurement. Deno says a sandbox starts in under 200 ms. On Fly, speed depends on the CPU class: shared vCPUs guarantee 6.25% of a core with bursts, and performance vCPUs get the full core at a higher rate.

How long can each one run?

A Deno sandbox lives up to 30 minutes, and longer work can be promoted to a Deno Deploy app. A Fly Machine has no documented time cap and runs until you or autostop stop it. A bochka sandbox has no cap on paid plans.

Can Fly.io Machines or Deno Sandbox run Docker?

On Fly you can install and run Docker yourself, since a Machine is a microVM with root. Deno's docs do not say Docker works inside a sandbox. Neither offers /dev/kvm for nested VMs; bochka has Docker, systemd and /dev/kvm on every machine.

Do they keep files after a stop?

Only on volumes. A Fly Machine's root file system is ephemeral and it can mount one Volume, and a Deno sandbox's root disk is wiped when it ends, with volumes only in Chicago. bochka keeps the whole disk and saves it every minute and on stop.

Is bochka SOC 2 compliant?

SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.

Try bochka

Install the CLI, then run bochka new.

Product preview