Fly.io Machines vs Islo

Fly.io Machines are fast microVMs for hosting your own apps near users in 17 regions, and you build any sandbox on top yourself. Islo is made for coding agents: each one gets a microVM with agents preinstalled and a gateway that controls and logs what it reaches.

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

Islo

Islo is an agent sandbox from Incredibuild: each coding agent gets its own microVM, with network rules and credentials handled at a gateway.

An Islo sandbox is a Linux microVM with its own kernel, built from a container image, with Claude Code, Cursor CLI and Codex preinstalled. Outbound traffic can pass through a gateway that allows or blocks hosts, injects credentials and logs every request. It is built for teams that run coding agents, evals and RL rollouts in the background, on Islo's cloud or in their own cloud account.

Maker: Incredibuild, a build acceleration company based in Tel Aviv
Launched: May 4, 2026
Isolation: A microVM with its own kernel for each agent computer
Regions: US West on Islo's cloud; BYOC puts the control plane and sandboxes in your own cloud account
Billing: CPU per core, memory per GB and disk per GB while a sandbox runs, billed per hour; signup credits with no card
Compliance: No certification named on its site; compliance documents on request from support

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	Islo: price rank	bochka: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run Docker inside a microVM with no /dev/kvm or desktop, and Fly also resets its root disk on restart; bochka fits fully with Docker, /dev/kvm and a desktop on every machine.	92nd of 367, with limits $836 a month	326th of 367, with limits $7,402 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Islo fits an assistant that runs for weeks, keeping its disk and pausing with memory when idle, while a Fly Machine keeps only what sits on its one Volume.	125th of 366, with limits $816 a month	30th cheapest of 366 $9,928 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 Fly fits short bursts better on paper, with per-second billing and no plan fee, while Islo's Team plan is reported at 50 running sandboxes at once.	75th of 345, with limits $94 a month	153rd of 345, with limits $503 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 300 user sandboxes at once is past Islo's reported Team limit of 50, and Fly's API creates about one Machine per second per app; bochka fits this fully.	69th of 361, with limits $600 a month	171st of 361, with limits $3,160 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	167th of 360, with limits $15,265 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	198th of 364, with limits $2,456 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 Islo fits CI runners in the table, while busy CI jobs drain a shared Fly vCPU's burst balance and get throttled.	152nd of 377, with limits $288 a month	119th cheapest of 377 $1,507 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB	118th of 368, with limits $53 a month	112th cheapest of 368 $402 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 has a desktop or a computer-use API, so you build one yourself on both; bochka streams a 60fps desktop with Chromium that agents can see and click.	95th of 369, with limits $173 a month	310th of 369, with limits $2,210 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 Islo has a browser inside the sandbox for testing, while on Fly you package the browser into your own image; bochka adds a visible desktop and computer use.	160th of 367, with limits $90 a month	113th of 367, with limits $1,105 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	66th cheapest of 346 $748 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 higher here, since it can spread scrapers across 17 regions and pay only for the seconds they run.	44th of 338, with limits $1,232 a month	265th of 338, with limits $14,966 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	47th of 360, with limits $746 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	Islo	bochka
Kind of product	App hosting platform; you boot your own image as a microVM	Agent sandbox: a microVM per coding agent	Agent sandbox: a full VM per agent, ready to use
Isolation	Firecracker microVM with its own kernel	MicroVM with its own kernel, built from a container image	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X (Zen 5) hosts
Docker, systemd and nested virtualization	Root and Docker you install yourself; Fly's own init, no systemd; /dev/kvm not offered	Docker inside and sudo; no /dev/kvm or nested virtualization documented	Docker, root, systemd 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	Files, processes and memory kept when a sandbox pauses	The whole disk is kept, with snapshots every minute and on stop; a stopped sandbox costs nothing
Pause with memory	Suspend keeps memory for Machines up to 2GB; dropped on deploy or host move	Pause keeps memory; can pause after idle time and resume on the next exec, file access or webhook	Resume reboots from disk (no memory snapshots)
Fork	Clone copies a Machine's config; a cloned Volume starts empty	Snapshot a running sandbox's files, then start new sandboxes from it	Fork a running sandbox, disk included
Desktop and computer use	None built in; you add a desktop and browser to your own image	A browser inside the sandbox for testing; no desktop or computer-use API	60fps desktop and Chromium, computer use and browser control, embeddable stream
Coding agents	None built in; you install and run agents yourself	Claude Code, Cursor CLI and Codex preinstalled; factory lines with events, steer and follow-ups	Claude Code, Codex, OpenCode 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	Gateway injects stored credentials into outbound requests for any host	AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out
Outbound rules and logs	Network policies allow chosen ports and protocols and deny the rest	Gateway rules by host, path and HTTP method, default deny, and a log of every request	Open internet on every plan; no provider-side allowlist or per-request log
Reaching the sandbox	Public HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, private network	HTTPS share links open to anyone with the URL, expiring after 24 hours by default; SSH and port-forward via CLI; no raw TCP	HTTPS URLs for up to 50 ports, token-protected; raw TCP; its own IP
Wake on request	Fly Proxy wakes a stopped or suspended Machine when a request arrives	A paused sandbox resumes on the next exec, file access or webhook	You start and stop machines through the API
CPU	Shared vCPUs guarantee 6.25% of a core plus bursts; performance vCPUs get the full core at a higher rate	Billed per CPU core while a sandbox runs	One CPU class on every plan, with no baseline quota or burst balance
Where it runs	17 regions on six continents	US West, or inside your own cloud account with BYOC	EU only: Germany, Finland, France; EU data residency

Every feature Battleships tracks (43)

Feature	Fly.io Machines	Islo	bochka
Full VM (own kernel)	Yes	Yes	Yes
Docker inside	Yes	Yes	Yes
Nested virtualization	No	No	Yes
Root	Yes	Yes	Yes
Systemd	No	Not published	Yes
Desktop GUI	No	No	Yes
Browser	No	Yes	Yes
Computer-use API	No	No	Yes
SSH	Yes	Yes	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	No	No
Custom image (Docker or snapshot)	Yes	Yes	Yes
≥24 h sessions	Yes	Yes	Yes
Idle auto-stop	Yes	Yes	No
Wake on request	Yes	Yes	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	Yes	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	Yes	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	Yes	No
SSO	No	Yes	No
SOC 2	Yes	Not published	No
HIPAA	Yes	Not published	No
EU data residency	Yes	No	Yes
Zero data retention	Not published	Not published	Yes

Performance

Fly.io MachinesNot measured

IsloNot measured

bochka26.69 runs/s

There is no comparable measurement for either: neither Fly.io Machines nor Islo 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. Fly's results would also depend on its CPU class, since shared vCPUs guarantee only 6.25% of a 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 Islo 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	Islo, 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	$101 · Free	$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	$420 · Free	$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	$4,863 · Team	$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,382 · Team · 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	$3,053 · Team · 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 are billed for their full size all month. The figures use Fly's lowest rate: shared vCPUs in 1-year reservation blocks.

Islo: Islo bills each CPU core and each GB of memory and disk while a sandbox runs, billed per hour, with no plan fee. An idle sandbox keeps billing until a pause-after-idle timer set at creation fires, and egress has no published price.

Islo: 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 marked a compromise in every scenario: its lowest figures need a 1-year reservation, and shared vCPUs guarantee only 6.25% of each core, so long builds get throttled. Islo's Team plan is reported at 50 running sandboxes at once, so 300 user sandboxes and 1,000 short jobs at once do not fit without a custom contract. On bochka the 1,000-job burst is limited by starts per minute and per day, so it gets queued even on the $2,000 plan.

Scenario	Fly.io Machines	Islo	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	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	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	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	Team: max 50 concurrent 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	Team: max 50 concurrent 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 host web apps or light services that must run near users worldwide, sleep between requests and wake on traffic.

17 regions worldwide. Useful if your users are spread out: Fly runs Machines in 17 regions, from the US to Sydney and Johannesburg.
A full app platform. Useful if you host whole products: Fly adds Anycast IPs, custom domains, raw TCP and a private network around each Machine.
Per-second billing with no plan fee. Useful for short bursts and light services: you pay only for the seconds a Machine runs, with cheap shared CPU.

Use Islo when

you want coding agents ready to run with per-host egress rules, a log of every outbound call, memory pause, or sandboxes in your own cloud account.

Built for coding agents. Useful if you want agents running today: Islo ships Claude Code, Cursor CLI and Codex, with factory lines to drive them.
Egress rules and request logs. Useful if you must control what agents reach: Islo allows or blocks each host, path and method, and logs every call.
Pause with memory, or your own cloud. Useful for idle agents or strict data rules: Islo pauses with memory kept, and can run inside your own cloud account.

Where bochka fits

If what you are really running is agents that build, test and browse for hours, look at bochka. It gives each agent a full VM with Docker, systemd, /dev/kvm and a desktop, keeps the whole disk across stops, and runs up to 2,000 sandboxes at once.

A desktop agents can see and use

Neither Fly Machines nor Islo has a screen or a computer-use API. On both you install a VNC stack and a control layer into your image yourself; bochka streams a 60fps desktop with Chromium in every sandbox.

Nested virtualization and systemd

Fly does not offer /dev/kvm and Islo documents none, so Android emulators and tools that start their own VMs stop at the first boot. bochka has /dev/kvm, systemd and Docker on every machine.

Every file kept, forks of running sandboxes

A Fly Machine's root disk is ephemeral, so you pay for a Volume all month, and a clone gets an empty one. Islo snapshots files only. bochka keeps the whole disk, snapshots every minute, and forks a running sandbox.

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

Questions people ask

Is Fly.io Machines cheaper than Islo?

In every scenario we priced, yes, using Fly's cheapest rate of shared vCPUs on a 1-year reservation. One coding agent on workdays is $15 a month on Fly and $101 on Islo, and 50 agents in parallel are $487 versus $4,863. Fly's figures assume work that stays within a shared vCPU's 6.25% baseline.

Which is faster, Fly.io Machines or Islo?

Neither has a public benchmark we can compare. Fly's speed depends on the CPU class: shared vCPUs guarantee 6.25% of a core, performance vCPUs the full core. bochka did 26.69 runs per second in StarSling's public run at 4 vCPU / 8 GB.

Can Fly.io Machines and Islo run Docker?

Yes, both. On Fly you install Docker yourself inside the microVM, and Islo runs Docker inside its sandboxes. Neither offers /dev/kvm for nested VMs or Android emulators, which bochka has on every machine.

Do they keep my files when a sandbox stops?

On Fly, only what sits on the one Volume a Machine can mount, since the root file system is ephemeral. Islo keeps files, processes and memory when a sandbox pauses. bochka keeps the whole disk, with snapshots every minute and on stop.

Where do Fly.io Machines and Islo run?

Fly runs Machines in 17 regions on six continents. Islo runs in US West, or inside your own cloud account with BYOC. bochka runs only in the EU, in Germany, Finland and France, with EU data residency.

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