Northflank vs Sprites
Northflank is a full cloud platform where sandboxes are one kind of workload, with GPUs, many regions and your own cloud, but only attached volumes survive a pause. Sprites gives each agent a fixed Linux VM whose whole disk survives, which sleeps seconds after work stops and wakes on the next request.
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.
Sprites
Sprites is Fly.io's product for agents: persistent Linux computers you create by API or CLI, which sleep when idle and wake on the next request.
Each Sprite is a Firecracker microVM with 8 vCPU, memory the platform manages, and a 100 GB ext4 disk that syncs to object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled, gets an HTTPS URL that wakes it, and bills only for the CPU and memory it actually uses while awake. It is built for coding agents, dev environments and user code that sit idle most of the time.
- Isolation
- Firecracker microVM per Sprite
- Regions
- Not selectable for Sprites
- Free start
- $30 trial credit per organization
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 | Sprites: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent installs packages all over the machine: Sprites keeps its whole disk, Northflank keeps only attached volumes, and boat keeps the whole disk and adds systemd, /dev/kvm and many ports. | 159th of 367, with limits $1,477 a month | 66th of 367, with limits $546 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that waits on a queue loses its open connections on every Sprites pause and its unsaved files on a Northflank pause; boat just keeps the machine running. | 173rd of 366, with limits $1,365 a month | 157th of 366, with limits $1,166 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 runs suit both: Northflank has small per-second plans from a tenth of a vCPU, and Sprites bills only the CPU and memory it really uses while awake. | 84th of 345, with limits $115 a month | 93rd of 345, with limits $140 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 Sprites gives each user a persistent VM that wakes on the first request, Northflank adds regions around the world, and boat adds SSH, raw TCP and HTTPS on up to 50 ports. | 89th of 361, with limits $815 a month | 56th of 361, with limits $428 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 | 105th of 360, with limits $6,540 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 | 125th of 364, with limits $545 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 Both fit plain CI; builds that need Android emulators or VM images want /dev/kvm, which boat exposes and neither Northflank nor Sprites documents. | 38th cheapest of 377 $352 a month | 63rd cheapest of 377 $476 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A 24/7 dev box wants SSH and systemd: Northflank has SSH, Sprites tunnels SSH through its CLI and does not run systemd, and boat has both. | 151st of 368, with limits $59 a month | 213th of 368, with limits $27 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 Both Northflank and Sprites are headless, so a computer-use agent needs a desktop you build yourself; boat streams a 60fps desktop with Chromium. | 151st of 369, with limits $371 a month | 85th of 369, with limits $136 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 | 171st of 367, with limits $122 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 | 229th of 346, with limits $206 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 | 83rd of 338, with limits $2,049 a month | 141st of 338, with limits $4,113 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 | 210th of 360, with limits $223 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 Only Northflank has GPU sandboxes, from L4 to H100 and up; Sprites and boat run on CPUs 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 | Sprites | boat |
|---|---|---|---|
| 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 |
| Machine size | Plans from 0.1 vCPU up to 20 vCPU / 40 GB, more on request; a resize restarts the sandbox | Fixed 8 vCPU and 100 GB disk; memory managed and scaled by the platform | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Image | Any container image you deploy | One managed Ubuntu 25.10 image; you install on top of it | Root Linux VM you install on; named snapshots to start new sandboxes from |
| What survives a stop | Only attached volumes, which bill while paused; the rest of the disk and all processes reset | The whole disk; a warm pause also keeps processes in memory | The whole disk, saved every minute and on stop; stopped sandboxes cost nothing |
| Idle behavior | No idle auto-pause; bills its plan until you pause it | Pauses about 30 seconds after activity stops, wakes on the next request in 100 to 500 ms | Runs until you stop it or its time to live ends |
| Inside the machine | Docker inside its own kernel; no /dev/kvm documented | Root and Docker (with rough edges users report); no systemd, and no /dev/kvm in the docs | Root, Docker, systemd and /dev/kvm for emulators and VMs |
| Snapshots and fork | Opt-in filesystem snapshots of a running sandbox; restore into a new one | Filesystem checkpoints that restore in place; no fork in the public API or CLI | Automatic disk snapshots; fork a running sandbox |
| Reaching the sandbox | HTTPS ports on a code.run domain, private by default; public TCP and UDP need a separate load balancer | One HTTPS URL to one HTTP port; other ports and SSH only through the sprite proxy CLI | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH |
| Outbound rules | Network policies with allow lists by IP, CIDR or domain, documented for your own cluster | Optional DNS-based domain allowlist set from outside; private IPs always blocked | Open internet, no provider-side allowlist |
| Keeping API keys out of the sandbox | Header injection for listed hosts in the network policy API | Connectors gateway holds the token for any HTTP API, with path allow and block lists | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Harnesses with Claude Code, Codex, Cursor, OpenCode or Pi, reached through a terminal or SSH | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Desktop and browser | Headless; no browser product | Headless; no desktop or browser product | 60fps Linux desktop and Chromium, computer use built in, embeddable stream |
| GPUs | L4, A100, H100, RTX PRO 6000 and more | No | No |
| Regions | US, Europe, Asia, Australia, South America and Africa; fixed per project; or your own cloud | Region not selectable | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Northflank | Sprites | boat |
|---|---|---|---|
| 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 | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | 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 | Yes | Yes |
| Idle auto-stop | No | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | 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 | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Northflank or Sprites: neither has a result on the hpc-sandbox-benchmarks test we use. boat 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. A Sprite always has 8 vCPU, so a fair test would also need a matching shape.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Northflank and Sprites 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 | Sprites, a month | boat, 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 | $23 · Pay-as-you-go | $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 | $92 · 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 | $1,322 · Developer Sandbox (free tier) · with limits | $1,120 · 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 | $361 · Developer Sandbox (free tier) · with limits | $314 · 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 | $1,134 · 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.
Sprites: Sprites bills CPU time at $0.0385 per CPU-hour and actual memory at $0.021875 per GB-hour, only while the Sprite is awake, plus storage on the bytes you write. Optional plans such as Hero at $100 a month buy fixed CPU, memory and storage allowances that are not credit.
Sprites: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its whole disk.
Limits in those scenarios
On Northflank the limit that bites in the first four scenarios is what survives a stop: only attached volumes keep their files, so packages installed anywhere else reset. Neither Northflank nor Sprites publishes how many sandboxes can run at once on pay as you go, so 300 or 1,000 at a time is not confirmed, and Sprites creates 10 a minute without a plan. A Sprite stays awake only while something holds it, so an always-on agent needs a task hold of at most an hour that must be renewed. boat's limit is the burst: even the $2,000 plan queues starts above 90 a minute.
| Scenario | Northflank | Sprites | boat |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
| None that bite | 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, regions outside Europe, sandboxes inside your own cloud account, or one platform for apps, databases and sandboxes.
- GPU sandboxes. For agents that train, fine-tune or run models: Northflank has GPU sandboxes from L4 to H100 and up.
- Regions and your own cloud. For teams with users far from Europe, or that must run inside their own AWS, GCP or Azure account.
- Any image, any size, one platform. For teams that want sandboxes from any container image, sized from 0.1 vCPU up, next to their apps and databases.
Use Sprites when
your agents or apps sit idle most of the day and should wake on a request with their whole disk intact, or when you want a domain allowlist on outbound traffic.
- Sleeps when idle, wakes on request. For agents and apps idle most of the day: a Sprite stops billing compute and wakes on the next request.
- The whole disk comes back. For agents that install tools anywhere: a Sprite keeps its whole 100 GB disk across pauses, not only chosen volumes.
- Domain allowlist and API connectors. For teams that want to limit which domains an agent reaches and which API paths a stored token may call.
Where boat fits
Look at boat when your agents work on one machine for hours or days and need it to act like a real Linux server. boat keeps the whole disk on every stop, runs systemd, Docker and /dev/kvm, and lets you fork a running sandbox and drive the agents inside from your own code.
The machine comes back, and forks
A Northflank pause wipes everything outside attached volumes, so agents reinstall tools. Sprites keeps the disk, but checkpoints restore in place and there is no fork, so trying two fixes from one state means rebuilding the second machine.
A full Linux server, reachable
Sprites has no systemd or /dev/kvm and exposes one HTTP port, with SSH only through its proxy CLI. Northflank needs a separate load balancer for public TCP. boat has systemd, /dev/kvm, SSH, raw TCP and HTTPS on 50 ports.
Agents driven from outside, with a screen
Northflank Harnesses are reached through a terminal or SSH and Sprites runs agents through exec, so you build the layer that prompts and watches them. Both are headless; boat adds an agent API and a 60fps desktop.
Use boat when your agents need a full machine for hours: the whole disk kept on every stop, systemd, Docker, emulators, many ports, a desktop and browser, forks, and an API to drive the agents inside from outside. Compare it one to one: boat vs Northflank and boat vs Sprites.
Questions people ask
Is Northflank cheaper than Sprites?
In four of the five scenarios we priced, Sprites costs less: one agent that never stops is $108 a month on Northflank against $92 on Sprites, and 50 agents in parallel are $1,322 against $1,120. For 1,000 short jobs at once, Northflank comes to $688 against $1,134. boat comes to $26 a month for the always-on agent and $317 for the 50-agent fleet.
Which is faster, Northflank or Sprites?
We cannot say yet: neither has a result on the CPU benchmark we use. A Sprite wakes from a warm pause in 100 to 500 ms. boat did 26.69 runs per second on that benchmark at 4 vCPU / 8 GB.
Do Northflank and Sprites keep files when a sandbox stops?
A Sprite keeps its whole disk, and a warm pause keeps processes in memory too, though open connections drop. A Northflank sandbox keeps only files on attached volumes; the rest of its disk and all processes reset. boat keeps the whole disk on every stop.
Can Northflank and Sprites run Docker?
Both give each sandbox its own kernel, so Docker runs inside. On Sprites, users report that docker exec fails for containers whose main process is not root, and there is no systemd. Neither documents /dev/kvm; boat has Docker, systemd and /dev/kvm in every sandbox.
Do Northflank or Sprites have GPUs?
Northflank has GPU sandboxes under gVisor with cards from L4 to H100 and more. Sprites and boat run on CPUs only.
Can I choose where my sandboxes run?
On Northflank, yes: each project is pinned to one region in the US, Europe, Asia, Australia, South America or Africa, or you run in your own cloud. Sprites does not let you choose a region. boat runs only in the EU, in Germany, Finland and France, with EU data residency.
Try boat
Install the CLI, then run boat new.
7-day free trial