Northflank vs Fly.io Machines
Northflank is a developer platform with a sandbox product: Kata microVMs, GPU sandboxes, agent harnesses and the option to run in your own cloud. Fly.io Machines are fast microVMs for hosting your own apps near users, which you can also use as sandboxes if you build the rest yourself.
The companies and products
Northflank
Northflank is a London developer platform for running services, jobs and databases on Kubernetes, and Sandboxes is its product for running untrusted code.
A Northflank sandbox is a container image deployed as a service: CPU sandboxes run in Kata microVMs with their own kernel, and GPU sandboxes run under gVisor. You create and drive them from the JavaScript or Python SDK, the CLI or the dashboard, on Northflank's cloud or inside your own. It suits teams that already want one platform for apps, databases, GPUs and sandboxes.
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.
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. “38th cheapest of 377” means 37 of the other 376 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 | Northflank: price rank | Fly.io Machines: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month On both, only attached volumes survive a stop, so a coding agent's installs reset unless you plan volumes; bochka keeps the whole disk and fits fully here. | 159th of 367, with limits $1,477 a month | 92nd of 367, with limits $836 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 for weeks keeps only its volume on Northflank or Fly; on bochka the whole disk stays, with snapshots every minute. | 173rd of 366, with limits $1,365 a month | 125th of 366, with limits $816 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 fit short code runs on paper: Northflank has plans from a tenth of a vCPU and Fly has cheap shared CPU, both billed per second. | 84th of 345, with limits $115 a month | 75th of 345, with limits $94 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 Northflank does not publish how many sandboxes run at once, and Fly's API creates about one Machine per second per app; bochka fits fully with HTTPS on up to 50 ports. | 89th of 361, with limits $815 a month | 69th of 361, with limits $600 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 | 342nd of 360, with limits $1,762 a month | 48th of 360, with limits $2,838 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 | 134th of 364, with limits $689 a month | 117th of 364, with limits $457 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 Northflank ranks 38th and fits fully, while CI drains a shared Fly vCPU's burst balance; bochka adds /dev/kvm for emulators and VM builds. | 38th cheapest of 377 $352 a month | 152nd of 377, with limits $288 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 151st of 368, with limits $59 a month | 118th of 368, with limits $53 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 Northflank nor Fly has a desktop built in, so you build and stream one yourself; bochka ships a 60fps desktop with Chromium and computer use. | 151st of 369, with limits $371 a month | 95th of 369, with limits $173 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 | 200th of 367, with limits $194 a month | 160th of 367, with limits $90 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 | 196th of 346, with limits $117 a month | 161st of 346, with limits $67 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 than Northflank, since it can spread scrapers across 17 regions and pay only for the seconds they run. | 83rd of 338, with limits $2,049 a month | 44th of 338, with limits $1,232 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 | 141st of 360, with limits $99 a month | 118th of 360, with limits $63 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 Northflank has GPU sandboxes from L4 to H100 and up; Fly discontinued its GPU Machines, and bochka is CPU only. | 4th cheapest of 98 $693 a month | 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 | Northflank | Fly.io Machines | bochka |
|---|---|---|---|
| Kind of product | Developer platform with a sandbox product for untrusted code | App hosting platform; you boot your own image as a microVM | Agent sandbox: a full VM per agent, ready to use |
| Isolation | Kata microVM with its own kernel for CPU; gVisor for GPU | Firecracker microVM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| What survives a stop | Only attached volumes, which bill while paused; the rest of the disk and all processes reset | Root file system is ephemeral; lasting data goes on one Volume, billed for its full size around the clock | The whole disk, saved every minute and on stop; stopped sandboxes cost nothing |
| Pause and memory | Pause scales to zero; no memory snapshots | Suspend keeps memory for Machines up to 2GB; dropped on deploy or host move | Resume reboots from disk (no memory snapshots) |
| Snapshots and fork | Filesystem snapshots of a running sandbox, restored into a new one | Clone copies a Machine's config; a cloned Volume starts empty | Automatic disk snapshots; fork a running sandbox, disk included |
| Idle behavior | No idle auto-pause; a sandbox bills its plan until you pause it | Fly Proxy stops or suspends idle Machines and wakes them on a request | You start and stop machines through the API; stopped machines cost nothing |
| Docker and nested virtualization | Docker inside; /dev/kvm not documented | Docker you install yourself; Fly's own init, no systemd; no /dev/kvm | Docker, root, systemd and /dev/kvm on every machine |
| Coding agents | Harnesses with Claude Code, Codex, Cursor, OpenCode or Pi, reached through a terminal or SSH | None built in; you install and run agents yourself | Seven agents preinstalled, with a prompt, steer and events API |
| Desktop and browser | Headless; access by SDK, browser terminal or SSH | None built in; you add a desktop and browser to your own image | 60fps Linux desktop, Chromium and computer use built in |
| Keeping API keys out of the sandbox | Header injection for listed hosts in the network policy API; otherwise env vars or files | Secrets as environment variables; Fly's open-source tokenizer proxy you deploy yourself | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Inbound access | HTTPS ports on a code.run domain, private by default; public TCP and UDP need a load balancer | Public HTTPS and TCP through Fly Proxy, Anycast IPs, custom domains, private network | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| CPU | Plans from 0.1 vCPU up to 20 vCPU / 40 GB, more on request | Shared vCPUs guarantee 6.25% of a core plus bursts; performance vCPUs get the full core at a higher rate | One CPU class with no baseline quota or burst balance, up to 16 vCPU / 32 GB |
| GPUs | L4, A100, H100, RTX PRO 6000 and more | GPU Machines discontinued | No |
| Where it runs | Many regions on six continents, or your own AWS, GCP or Azure account | 17 regions on six continents, on Fly's own servers | EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Northflank | Fly.io Machines | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Yes | Yes |
| Systemd | Not published | No | 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 | 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 | No | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | Yes | Yes |
| Public IPv4 | No | Yes | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | Yes | No | No |
| Self-hosting | Yes | No | No |
| BYOC | Yes | No | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | No | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | 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
There is no comparable CPU measurement for Northflank or Fly.io Machines: neither has a result on the hpc-sandbox-benchmarks test. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. On Fly, results would also depend on whether you pick shared or performance vCPUs.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Northflank and Fly.io Machines 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 | Northflank, a month | Fly.io Machines, 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 | $32 · Developer Sandbox (free tier) · with limits | $15 · Pay As You Go · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $108 · Developer Sandbox (free tier) · with limits | $36 · 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 | $1,322 · Developer Sandbox (free tier) · with limits | $487 · 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 | $361 · Developer Sandbox (free tier) · with limits | $110 · Pay As You Go · 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 | $688 · Developer Sandbox (free tier) · with limits | $232 · Pay As You Go · with limits | $2,000 · $2000/mo · with limits |
Northflank: Northflank bills per second for the plan size you pick, with no monthly fee, until you pause the sandbox; there is no idle auto-pause. Volumes cost $0.15 per GB a month even while paused, and outbound traffic costs $0.06 per GB.
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 here use shared vCPUs bought in 1-year reservation blocks, Fly's lowest rate.
Fly.io Machines: Plans start at $20 a month, and the whole fee is usage credit spent per second. A stopped sandbox costs nothing and keeps its whole disk.
Limits in those scenarios
On Northflank the limit that bites is what survives a stop: only attached volumes keep their files, and it does not publish how many sandboxes can run at once, so 300 or 1,000 at a time is not confirmed. Fly's lowest 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. bochka's limit is the 1,000-job burst, where starts above 90 a minute are queued even on the $2,000 plan.
| Scenario | Northflank | Fly.io Machines | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Northflank when
you need GPUs next to the agent, sandboxes in your own cloud account, or one platform for your apps, databases and sandboxes.
- GPU sandboxes. For agents that train or run models: Northflank has GPU sandboxes from L4 to H100, and Fly no longer sells GPUs.
- Your own cloud. For teams that must run in their own AWS, GCP or Azure account, or keep the control plane in their VPC.
- Agent harnesses and shared volumes. For teams that want Claude Code or Codex started for them, with volumes that several sandboxes can share.
Use Fly.io Machines when
you host web apps or light services near users around the world that sleep between requests and wake on traffic.
- Wake on request. For services that sleep between requests: Fly Proxy wakes a Machine when traffic arrives, and small Machines resume with memory kept.
- A full app platform. For teams hosting whole apps: Anycast IPs, custom domains and a private network sit around every Machine.
- Cheap shared CPU for light work. For code that mostly waits: shared vCPUs on a 1-year reservation cost less than Northflank in every scenario here.
Where bochka fits
Northflank and Fly both give each workload its own kernel, but both keep only what you put on a volume and leave the agent tooling to you. If your agents work on one machine for hours or days, installing tools, running Docker and using a browser, bochka gives them a full VM that comes back as they left it, with the agent, desktop and keys proxy already inside.
The whole disk comes back
On Northflank a pause wipes everything outside attached volumes, and a Fly Machine's root file system is ephemeral. Either way an agent reinstalls its tools, or you put every path on a volume billed even while stopped.
Agents driven from your code
Northflank Harnesses start an agent you reach through a terminal or SSH, and Fly has none. bochka preinstalls seven agents and gives you an API to prompt, steer and follow each one, so you drive agents inside from outside.
Desktop, emulators and keys proxy
Both are headless with no /dev/kvm, so computer-use agents and Android emulators need a custom image or do not run. bochka has a 60fps desktop, Chromium and /dev/kvm, and keeps real API keys outside in a credentials proxy.
Use bochka when your agents do real work for hours on one machine and should find it as they left it: installs, Docker, emulators, a desktop and a browser, with the agent driven from your code. Compare it one to one: bochka vs Northflank and bochka vs Fly.io Machines.
Questions people ask
Is Northflank cheaper than Fly.io Machines?
Not in the scenarios on this page, using Fly's lowest rate of shared vCPUs on a 1-year reservation. One agent that never stops is $36 a month on Fly against $108 on Northflank, and bochka is $26. Fly's figures assume work that stays within a shared vCPU's 6.25% baseline.
Which is faster, Northflank or Fly.io Machines?
Neither has a result on the public CPU benchmark used here, so there is no fair comparison. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. Fly's shared vCPUs get throttled above 6.25% of a core once their burst balance runs out.
Do Northflank and Fly keep files when a sandbox stops?
Only files on attached volumes. A Northflank pause resets the rest of the disk and all processes, and a Fly Machine's root file system is ephemeral. bochka keeps the whole disk on every stop.
Can Northflank and Fly.io Machines run Docker?
Yes, both give each workload its own kernel, so Docker can run inside; on Fly you install it yourself. Neither offers /dev/kvm for Android emulators or nested VMs, while bochka has Docker, systemd and /dev/kvm ready.
Which one has GPUs?
Northflank has GPU sandboxes from L4 and A100 up to H100 and more, billed per hour. Fly discontinued its GPU Machines, and bochka runs on CPUs only.
Can I run Claude Code or Codex on each?
Northflank Harnesses start Claude Code, Codex, Cursor, OpenCode or Pi, and you connect through a terminal or SSH. On Fly you build the agent into your own image. bochka preinstalls seven agents with an API to prompt, steer and follow them.
Try bochka
Install the CLI, then run bochka new.
Product preview