Northflank vs exe.dev

Northflank runs sandboxes as one workload on a broad cloud platform, with GPUs, 17 regions and your own cloud. A pause keeps attached volumes, and the rest of the disk through a filesystem snapshot you take. exe.dev rents Linux VMs that keep their 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 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 with 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. It suits developers who want a persistent dev box or a sandbox for their agents.

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. “44th cheapest of 361” means 43 of the other 360 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 workloadNorthflank: price rankexe.dev: price rankboat: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
A software factory needs Docker and a disk that stays. exe.dev VMs keep their disk; Northflank needs a snapshot before each pause for files outside volumes. boat adds a built-in desktop and a disk snapshot every minute.
186th of 365, with limits
$1,413 a month
267th of 365, with limits
$3,721 a month
5th cheapest of 365
$634 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
Both fit an always-on assistant. exe.dev VMs and Northflank sandboxes run until you stop them. On boat, turn auto-stop off (default 1 hour) on a paid plan.
44th cheapest of 361
$2,551 a month
20th cheapest of 361
$3,833 a month
6th cheapest of 361
$657 a month
Code interpreter bursts
100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month
91st of 336, with limits
$114 a month
231st of 336, with limits
$175 a month
189th of 336, 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
exe.dev Personal allows 50 VMs in total; a Work pool allows up to 1,000. Northflank does not publish a concurrency limit. boat publishes 100 at once on $20 and up to 2,000 on $2,000, with token-gated URLs.
94th of 349, with limits
$810 a month
252nd of 349, with limits
$1,234 a month
3rd cheapest of 349
$209 a month
RL rollouts
1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month
333rd of 349, with limits
$1,742 a month
260th of 349, with limits
$5,250 a month
39th of 349, with limits
$2,000 a month
Agent evals
250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month
139th of 359, with limits
$685 a month
280th of 359, with limits
$1,050 a month
10th cheapest of 359
$200 a month
CI runners
40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month
All three boot or bill CI by the second in some form. Northflank and exe.dev boot your own image. boat has /dev/kvm on every sandbox; exe.dev turns nested virtualization on through support.
36th cheapest of 374
$347 a month
289th of 374, with limits
$504 a month
2nd cheapest of 374
$86 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
exe.dev fits a 24/7 dev box well: its VMs keep their disk and run until you stop them, in nine regions. Northflank keeps volumes, and the rest of the disk through a filesystem snapshot before a pause. boat keeps its disk for at least 14 days after a stop.
124th cheapest of 371
$106 a month
24th cheapest of 371
$35 a month
19th cheapest of 371
$26 a month
Computer-use agents
50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month
Neither Northflank nor exe.dev ships a desktop. On both you set it up: install a desktop and a stream (VNC on exe.dev). boat streams a built-in 60 fps desktop.
189th of 367, with limits
$367 a month
270th of 367, with limits
$1,055 a month
7th cheapest of 367
$200 a month
Browser-use agents
50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month
83rd of 356, with limits
$359 a month
187th of 356, with limits
$530 a month
7th cheapest of 356
$200 a month
Scraping & bots (startup scale)
50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month
94th cheapest of 343
$200 a month
187th of 343, with limits
$278 a month
6th cheapest of 343
$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 327, with limits
$2,031 a month
165th of 327, with limits
$5,490 a month
73rd of 327, with limits
$1,800 a month
Parallel red teaming
200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month
43rd of 351, with limits
$180 a month
51st of 351, with limits
$264 a month
3rd cheapest of 351
$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, H200 and B200. exe.dev and boat have no GPU.
5th cheapest of 102
$692 a month
Not ranked: misses a requirementNot ranked: misses a requirement
macOS agents
5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month
Not ranked: misses a requirementNot ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureNorthflankexe.devboat
IsolationKata microVM with its own kernel for CPU sandboxes; gVisor for GPU sandboxesKVM VM with Cloud Hypervisor on rented bare metal; you cannot choose the kernelFull VM with its own kernel, on physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared
What survives a stopAttached volumes survive (billed while paused); the rest of the disk resets unless you snapshot it before pausing and restore from it (microVM sandboxes only); processes resetThe VM disk persists and is replicated across the regional cluster; on-demand disk backups to your own S3 bucket (preview)The disk, saved every minute and at each stop, kept at least 14 days; memory and processes are not saved; a machine failure loses writes after the last good snapshot
Snapshots and forkFilesystem snapshots of a running or terminating sandbox (opt-in, microVM only); restore into a new sandboxcp copies a VM's disk and config into a new VM; backups restore into a new VM (preview)Automatic disk snapshots; fork a running sandbox from its last 1-minute snapshot; saved snapshots as templates
Custom imagesAny container imageBoot from your own Docker imageStart from boat's image or a saved snapshot; you cannot boot your own Docker or OCI image
Docker and nested virtualizationDocker can run on the sandbox's own kernel; /dev/kvm not documentedRoot, systemd and Docker; nested virtualization off by default, on request from supportDocker, systemd and root on every sandbox, plus /dev/kvm for Android emulators and VMs
Desktop and browserNo built-in desktop. You set it up: Northflank's guide runs Playwright browser agents from your own image; a desktop and stream you install yourselfNo built-in desktop or stream; you can install a desktop and VNC yourself, and Shelley's browser tool takes screenshots of a headless Chromium1920x1080, 60 fps Linux desktop and Chrome, computer tools for agents, embeddable stream
Coding agentsHarnesses with Claude Code, Codex, Cursor, OpenCode, Pi, OMP or Devin CLI and a lifecycle API; you talk to the agent through a terminal or SSHClaude Code, Codex, Pi and Shelley installed; Shelley takes prompts through the API, other agents run through the HTTPS exec APISeven agents installed, with a prompt, steer and events API
Keeping API keys out of the sandboxHeader injection for listed hosts in the network policy API (documented for your own cluster); otherwise secrets are env vars or filesIntegrations inject secrets at the network edge for any HTTP host, S3, GitHub and a large catalogOptional AI credentials proxy, off by default, $1 a day plus $1 per 1,000 requests; keys of supported model providers stay outside; other secrets still enter the sandbox
Inbound accessHTTP ports on a code.run domain or your own domain, private by default; SSH; public TCP and UDP through a separate Layer 4 load balancerHTTPS proxy for ports 3000 to 9999, one of them public; SSH; no public IP or raw TCPUp to 50 HTTPS URLs, token-gated by default; SSH; public IPv6 address with raw ports (some sandboxes have no IPv4 of their own)
Outbound rulesNetwork policies with allow lists by IP, CIDR or domain, documented for your own cluster; static egress IPsOpen by default; an egress policy can block everything but attached integrationsOpen internet, no provider-side allowlist; you set it up: firewall rules inside the VM with root
GPUsL4, A100, H100, H200, B200, RTX PRO 6000 and moreNo GPUNo GPU on any size
Regions17 managed regions on six continents, or your own cloud account9 regions in the US, Europe, Asia and Australia; BYOC on EnterpriseGermany, Finland and France; you cannot pick a region; no US or Asia region
Teams and accessTeams, roles and network policies on one platform; SOC 2 Type 2, HIPAA and ISO 27001Unlimited users, SSO and roles on Work; dedicated hardware on EnterpriseOrg seats, scoped API keys, spend limits, usage per sandbox; no SSO; SOC 2 in progress
Every feature Battleships tracks (43)
FeatureNorthflankexe.devboat
Full VM (own kernel)YesYesYes
Docker insideYesYesYes
Nested virtualizationNo documented wayWith your own setupYes
RootNot publishedYesYes
SystemdNot publishedYesYes
Desktop GUINo documented wayNo documented wayYes
BrowserWith your own setupYesYes
Computer-use APINo documented wayNo documented wayYes
SSHYesYesYes
Persistent diskWith your own setupYesYes
Pause/resumeYesYesYes
Automatic snapshotsYesNo documented wayYes
Fork/cloneYesYesYes
Live fork (no pause)YesYesYes
Memory forkNo documented wayNo documented wayNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesYesYes
Idle auto-stopNo documented wayNo documented wayNo documented way
Wake on requestNo documented wayNo documented wayNo documented way
HTTPS preview URLsYesYesYes
Raw TCP inboundYesNo documented wayYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesWith your own setupNo documented way
Secret proxyYesYesYes
Secret proxy for any APIYesYesYes
Preinstalled agentsYesYesYes
Agent harness APINo documented wayYesYes
MCP serverNo documented wayYesNo documented way
GPUYesNo documented wayNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64YesNo documented wayNo documented way
Self-hostingYesNo documented wayNo documented way
BYOCYesYesNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysNot publishedYesYes
Spend limitsNot publishedNot publishedYes
Usage per sandbox (API)YesYesYes
Audit logsYesNot publishedNo documented way
SSOYesYesNo documented way
SOC 2YesNo documented wayNo documented way
HIPAAYesNo documented wayNo documented way
EU data residencyYesYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

NorthflankNot measured
exe.devNot measured
boat28.06 runs/s

Neither Northflank nor exe.dev is in the public CPU benchmark we use, so we cannot say which of the three is faster. In StarSling's run of 3 October 2026 (run 37073680030), boat did 28.06 V8 Web Tooling Benchmark runs per second at 4 vCPU / 8 GB, second of 15. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure.

V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Northflank and exe.dev are not in the public benchmarks we use, so we cannot say which is faster.

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. Start limits, per-start fees and plan minimums are in the price, boat's included.

ScenarioNorthflank, a monthexe.dev, a monthboat, 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
$30 · Developer Sandbox (free tier)$35 · Personal$20 · $20/mo
One agent that never stops
4 vCPU / 8 GB, 50 GB disk, running 24/7 all month
$106 · Developer Sandbox (free tier)$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,290 · Developer Sandbox (free tier)$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
$359 · 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
$684 · Developer Sandbox (free tier) · with limits$1,050 · Personal · with limits$8,800 · $2000/mo · with limits

Northflank: Northflank bills per second for the plan size you pick, from $0.0038 an hour for 0.1 vCPU; 4 vCPU / 8 GB is $0.1333 an hour. There is no monthly fee and no start fee. There is no idle auto-pause, so a sandbox bills until you pause it. Volumes cost $0.11657 per GiB a month, also while paused, and outbound traffic costs $0.06 per GB.

exe.dev: Pools are reserved capacity that your VMs share. Personal is a flat fee paid upfront, $15 to $155 a month for 2 to 16 vCPU. Work is $75 a month for the team, plus $0.105 an hour per extra 2 vCPU / 4 GiB. A pool bills the same whether its VMs are busy or idle. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour; a stopped one keeps its disk and pays nothing for CPU and memory.

Limits in those scenarios

exe.dev Personal allows up to 16 vCPU and 50 VMs in total, standalone VMs included, so 300 or 1,000 at once do not fit there; a Work pool holds up to 1,000 VMs, and pools above 32 vCPU need support approval. Northflank keeps files outside attached volumes only if you snapshot the filesystem before each pause and restore from it, and it does not publish how many sandboxes can run at once. boat's limits: plans start at $20 a month, and the included time expires at the end of the month. A stopped sandbox has no compute charge, but saved snapshots above the included count and the AI credentials proxy still charge. In the burst, even the $2,000 plan charges $0.03 to $0.07 for starts above 90 a minute and refuses them above 270, so boat costs about $8,800 there.

ScenarioNorthflankexe.devboat
One coding agent, workdaysNone for this scenario
  • flat pool: the tier is billed whether used or not
None for this scenario
One agent that never stopsNone for this scenario
  • flat pool: the tier is billed whether used or not
None for this scenario
50 agents in parallel
  • how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
None for this scenarioNone for this scenario
Sandboxes for your users
  • not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
  • Personal: max 50 concurrent
None for this scenario
1,000 short jobs at once
  • not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)
  • Personal: max 50 concurrent
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429

Which one should you use?

Use Northflank when

you need GPUs, sandboxes inside your own cloud account next to your apps, SOC 2 Type 2, HIPAA or ISO 27001, or lower bills for large fleets.

  • GPUs on the same platform. For agents that also need a GPU: Northflank has GPU sandboxes from L4 to H100, H200 and B200.
  • One platform, and your own cloud. For teams that want apps, databases and sandboxes together, inside their own AWS, GCP or Azure account, with compliance reports.
  • Lower bills for fleets in these scenarios. At list prices Northflank costs less than exe.dev in four of the five scenarios on this page, such as 50 agents in parallel.

Use exe.dev when

you want a Linux VM that keeps its disk until you stop it, a flat monthly price for an always-on box, regions in the US, Asia and Australia, or team SSO and an outbound lockdown.

  • A VM that keeps its disk. For a dev box or an assistant: an exe.dev VM keeps its disk and runs until you stop it, with no snapshot to set up.
  • A flat price for always-on. For one machine that never stops: an exe.dev Personal pool is a flat $35 a month for 4 vCPU, against $106 on Northflank.
  • Team controls and an outbound lockdown. Work covers a whole team with SSO and roles, and a VM can be blocked from everything but its integrations.

Where boat fits

Look at boat if your agents do long, hands-on work and need a screen. Northflank and exe.dev both give an agent a Linux machine with a shell. On both, a desktop is work you set up yourself, and agents other than exe.dev's Shelley run through a terminal or exec. boat ships a desktop and an agent API in every sandbox.

A desktop and a browser inside

Neither Northflank nor exe.dev has a built-in desktop. You install a desktop and a stream yourself. boat streams a 1920x1080, 60 fps desktop with Chrome and computer tools in every sandbox. There is no GPU, so graphics run on the CPU.

Disk saved every minute with no setup

Northflank keeps files outside volumes through a snapshot you take before a pause, and exe.dev backs up a disk when you trigger it. boat saves the disk every minute and at each stop, and keeps it at least 14 days. Memory and running programs are not saved.

Agents driven from your code

Northflank Harnesses are reached through a terminal or SSH, and exe.dev's API takes prompts for Shelley only. boat installs seven agents behind one prompt, steer and events API. boat runs only in Germany, Finland and France.

Use boat when your agents do real work for hours: builds, tests, Docker, emulators, a built-in desktop and a browser, with the disk saved every minute and one API to drive the agents inside. boat runs only in Germany, Finland and France and has no GPU. Compare it one to one: boat vs Northflank and boat vs exe.dev.

boat's own limits
  • Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
  • Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
  • A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
  • Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
  • boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
  • Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
  • Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
  • Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source

Questions people ask

Is Northflank cheaper than exe.dev?

At list prices, Northflank costs less in four of the five scenarios on this page: 50 agents in parallel are $1,290 a month against $1,848 on exe.dev. exe.dev costs less for one agent that never stops: $35 against $106. boat is $317 and $26 for those two. For 1,000 short jobs at once, Northflank is $684, exe.dev $1,050 (with limits) and boat about $8,800, because boat charges for starts above its plan's included number.

Which is faster, Northflank or exe.dev?

We cannot say: neither is in the public CPU benchmark we use. exe.dev says a new VM boots from a container image in about two seconds.

Do they keep the disk when a machine stops?

An exe.dev VM keeps its disk. Northflank keeps attached volumes, and the rest of the disk if you take a filesystem snapshot before the pause and restore from it. boat saves the disk every minute and at each stop, and keeps it at least 14 days; memory and running programs are not saved.

Can I run Claude Code on each?

Yes. Northflank Harnesses start Claude Code, Codex and others, and you connect through a terminal or SSH. exe.dev installs Claude Code, Codex, Pi and its Shelley agent. boat installs seven agents and adds an API to prompt, steer and follow them.

Which one has GPUs?

Northflank, with GPU sandboxes from L4 to H100, H200 and B200. exe.dev and boat have no GPU.

Is boat SOC 2 compliant?

SOC 2 is in progress, so there is no SOC 2 report today. Northflank lists SOC 2 Type 2, HIPAA and ISO 27001. Live status is at status.ascii.dev and the data retention policy is at docs.boat.dev/data-retention.

Try boat

Install the CLI, then run boat new.

7-day free trial

More comparisons