Northflank vs exe.dev
Northflank runs sandboxes as one workload on a broad cloud platform, with GPUs, many regions and your own cloud, but a pause keeps only attached volumes. exe.dev rents Linux VMs that keep their whole disk and run until you stop them, billed as a reserved pool or per second.
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.
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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 | exe.dev: price rank | bochka: 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: exe.dev keeps them, Northflank keeps only volumes, and bochka keeps the disk with a snapshot every minute. | 159th of 367, with limits $1,477 a month | 253rd of 367, with limits $3,701 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB exe.dev fits always-on assistants well and ranks 15th, while Northflank resets everything outside volumes; bochka ranks 5th with a disk saved every minute. | 173rd of 366, with limits $1,365 a month | 15th cheapest of 366 $3,833 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 Northflank's small per-second plans from a tenth of a vCPU suit many short code runs better than exe.dev, and neither is a built-in code interpreter. | 84th of 345, with limits $115 a month | 235th of 345, with limits $175 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 For sandboxes you hand to users, Northflank does not publish a concurrency limit and exe.dev Personal stops at 50 VMs at once; bochka ranks 1st. | 89th of 361, with limits $815 a month | 257th of 361, with limits $1,226 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 | 265th of 360, with limits $5,250 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 | 283rd of 364, with limits $1,050 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 fits CI runners with per-second billing and ranks 38th, while exe.dev pools bill whether jobs run or not; bochka ranks 4th and adds /dev/kvm. | 38th cheapest of 377 $352 a month | 288th of 377, with limits $504 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB exe.dev fits a 24/7 dev box fully and ranks 25th, since its VMs keep their whole disk; on Northflank only attached volumes survive a pause, and bochka ranks 18th. | 151st of 368, with limits $59 a month | 25th cheapest of 368 $35 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 exe.dev are headless, so a computer-use agent needs a desktop you build and stream yourself; bochka ships a 60fps desktop. | 151st of 369, with limits $371 a month | 240th of 369, with limits $1,055 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 | 130th of 367, with limits $530 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 | 124th of 346, with limits $278 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 | 166th of 338, with limits $5,490 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 | 60th of 360, with limits $263 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 here, from L4 to H100 and up, and it ranks 4th; exe.dev and bochka are 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 | exe.dev | bochka |
|---|---|---|---|
| Isolation | Kata microVM with its own kernel for CPU; gVisor for GPU | KVM VM with Cloud Hypervisor; you can't choose the 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 | The whole disk, streamed to a second server | The whole disk, saved every minute and on stop; stopped sandboxes cost nothing |
| Snapshots and fork | Opt-in filesystem snapshots of a running or stopping sandbox; restore into a new one | No snapshots; cp copies a VM's disk and config into a new VM | Automatic snapshots every minute; fork a running sandbox; named snapshots as templates |
| Custom images | Deploy your own container image | Boot each VM from your own Docker image | Templates from named snapshots; no Dockerfile or OCI images |
| Nested virtualization | Not documented inside a sandbox | Enterprise only | Yes, /dev/kvm on every plan for Android emulators and VMs |
| Desktop and browser | Headless; access by SDK, browser terminal or SSH | Headless; no desktop or screen streaming | 60fps Linux desktop, Chromium, computer use and an embeddable stream |
| Coding agents | Harnesses with Claude Code, Codex, Cursor, OpenCode or Pi; you reach them by terminal or SSH | Claude Code, Codex, Pi and Shelley; only Shelley takes prompts through the API | Seven agents preinstalled, with a prompt, steer and events API and TypeScript and Python SDKs |
| Keeping API keys out | Header injection for listed hosts in the network policy API | Integrations inject secrets at the network edge for any HTTP host | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Inbound access | HTTPS ports on a code.run domain; public TCP and UDP need a separate load balancer | HTTPS proxy for ports 3000 to 9999, one of them public; SSH; no public IP or raw TCP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | Network policies with allow lists by IP, CIDR or domain | Open internet, no allow list | Open internet, no provider-side allow list |
| Machines at once | Limit not published | Personal: 50 VMs in the pool plus up to 50 standalone VMs | 100 to 2,000 by plan |
| GPUs | L4, A100, H100, RTX PRO 6000 and more | No | No |
| Regions | US, Canada, Brazil, UK, EU, Switzerland, Asia, Australia and South Africa | 9 regions in the US, Europe, Asia and Australia | EU only: Germany, Finland, France |
| Your own cloud | Run on AWS, GCP, Azure, Oracle and others, or the control plane in your VPC on Enterprise | Bring your own cloud and dedicated hardware on Enterprise | No |
Every feature Battleships tracks (43)
| Feature | Northflank | exe.dev | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Not published | Yes | Yes |
| Systemd | Not published | Yes | 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 | No | 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 | No | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | Yes | 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 | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Yes | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither Northflank Sandboxes nor exe.dev has a result on the hpc-sandbox-benchmarks test, so there is no comparable CPU measurement for either and we don't guess. 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.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Northflank and exe.dev 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 | exe.dev, 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 | $35 · Personal | $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 | $35 · Personal | $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,848 · Personal | $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 | $530 · Personal · 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,050 · Personal · 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.
exe.dev: exe.dev pools are reserved capacity your VMs share, billed the same whether they are busy or idle: a Personal 4 vCPU pool is a flat fee. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB an hour and pay nothing for CPU and memory while stopped.
exe.dev: Plans start at $20 a month, and the whole fee is usage credit. Sandboxes bill per second while they run, 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, and it does not publish how many sandboxes can run at once, so 300 or 1,000 together is not confirmed. On exe.dev Personal the cap is 50 VMs at once, so the 300-at-once and 1,000-at-once scenarios don't fit, and a pool is billed whether used or not. bochka's limit is the burst scenario: even the $2,000 plan queues starts above 90 a minute.
| Scenario | Northflank | exe.dev | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
| None that bite | 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 that also runs your apps and databases.
- GPU sandboxes. For agents that train, fine-tune or run models: Northflank has GPU sandboxes from L4 to H100 and up.
- One platform, in your own cloud. For teams that want apps, databases and sandboxes together, in many regions or inside their own AWS, GCP or Azure account.
- Small machines for short runs. For many quick code runs: per-second plans start at a tenth of a vCPU, with allow lists for outbound traffic.
Use exe.dev when
you want a persistent Linux VM that keeps its whole disk and runs around the clock, booted from your own Docker image, in a region near you.
- The whole disk stays. For agents and developers who live on one machine: every exe.dev VM keeps its whole disk, not just mounted volumes.
- A flat pool for always-on work. For machines that never stop: a 4 vCPU pool is $35 a month on exe.dev against $108 on Northflank.
- Docker image boot and an MCP server. For teams that build images already: exe.dev boots VMs from your Docker image and serves an MCP server for control.
Where bochka fits
Look at bochka if your agents work on one machine for hours and should find it as they left it, with a screen to look at and an API to drive them. It keeps the whole disk like exe.dev, saves it every minute, adds a desktop and /dev/kvm, and runs up to 2,000 sandboxes at once.
Saved every minute, free when stopped
A Northflank pause wipes everything outside attached volumes, so agents reinstall their tools. exe.dev keeps the disk but has no snapshots, so one bad agent step can cost a session's work. bochka snapshots every minute and can fork a running sandbox.
A screen agents can use
Northflank and exe.dev are both headless, so a computer-use or browser agent first needs you to build an image with a desktop, a browser and a way to stream it. bochka ships a 60fps desktop with Chromium in every sandbox.
Agents driven from outside
Northflank Harnesses are reached by terminal or SSH, and on exe.dev only Shelley takes prompts by API, so you script shells to run Claude Code. bochka lets you prompt, steer and stream seven agents through one API.
Use bochka when your agents work on one machine for hours or days: the whole disk saved every minute, Docker, /dev/kvm, a 60fps desktop and browser, and the agents themselves driven from your code. Compare it one to one: bochka vs Northflank and bochka vs exe.dev.
Questions people ask
Is Northflank cheaper than exe.dev?
It depends on how long machines run. For one agent that never stops, exe.dev is $35 a month against $108 on Northflank, because a pool is flat. For 50 agents in parallel Northflank is $1,322 a month against $1,848 on exe.dev, though Northflank resets files outside volumes.
Which is faster, Northflank or exe.dev?
We can't say: neither has a result on the hpc-sandbox-benchmarks test, so there is no comparable CPU score. bochka did 26.69 runs per second on that test at 4 vCPU / 8 GB.
Can Northflank and exe.dev run Docker?
Yes. Northflank CPU sandboxes run in Kata microVMs with their own kernel, and exe.dev VMs have root, systemd and Docker. Nested VMs are another matter: exe.dev offers them only on Enterprise, Northflank does not document them, and bochka has /dev/kvm on every plan.
Do Northflank and exe.dev keep files when a machine stops?
exe.dev keeps each VM's whole disk. Northflank keeps only attached volumes when you pause; the rest of the disk and all processes are lost. bochka keeps the whole disk and also snapshots it every minute.
Does Northflank or exe.dev have GPUs?
Northflank does, with GPU sandboxes under gVisor from L4 to H100 and more. exe.dev and bochka run on CPUs only.
Try bochka
Install the CLI, then run bochka new.
Product preview