Modal vs Northflank
Modal runs short-lived serverless sandboxes under gVisor, next to its GPUs, and each one lasts at most 24 hours. Northflank runs each CPU sandbox in a Kata microVM with its own kernel that runs until you pause it, on its cloud or inside yours.
The companies and products
Modal
Modal is a serverless cloud for AI work: inference, training, batch jobs and sandboxed code, all driven from Python, TypeScript or Go code.
Modal Sandboxes are containers you create from code, run commands in, and then terminate. By default they run under gVisor, a user-space kernel from Google; since October 2026 you can also pick a VM runtime with its own Linux kernel for Docker and FUSE (Battleships tracks that as a separate card, Modal VM Sandboxes). It suits teams that already run models on Modal and want short-lived, scalable code execution next to their GPUs.
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.
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. “19th cheapest of 345” means 18 of the other 344 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 | Modal: price rank | Northflank: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | Can't run it | 159th of 367, with limits $1,477 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An agent that lives on its machine hits Modal's 24-hour cap; Northflank has no session cap but resets everything outside attached volumes on a pause, and boat keeps the whole disk. | 196th of 366, with limits $1,924 a month | 173rd of 366, with limits $1,365 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 For many short code runs, Modal's fast starts and up to 5,000 containers on Team fit better than Northflank, which does not publish how many sandboxes can run at once. | 19th cheapest of 345 $181 a month | 84th of 345, with limits $115 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 Modal's Team plan allows 5,000 containers, so 300 sandboxes at once fit; Northflank does not publish its limit, and boat keeps each user's disk for free between visits. | 11th cheapest of 361 $811 a month | 89th of 361, with limits $815 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 RL rollouts launch huge bursts of short sandboxes, which is what Modal is built for; Northflank's concurrency is not published. | 5th cheapest of 360 $19,038 a month | 342nd of 360, with limits $1,762 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 | 59th cheapest of 364 $1,244 a month | 134th of 364, with limits $689 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 CI jobs that build Docker images run in a Northflank microVM as is; on Modal they need the VM runtime, and boat runs Docker in every sandbox. | 126th cheapest of 377 $1,793 a month | 38th cheapest of 377 $352 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box that runs all day is cut off after 24 hours on Modal and loses packages outside volumes on Northflank; boat keeps the whole machine. | 138th of 368, with limits $23 a month | 151st of 368, with limits $59 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 Modal nor Northflank ships a desktop, so you build and stream one yourself; boat has a 60fps desktop, Chromium and a computer-use API built in. | 98th of 369, with limits $183 a month | 151st of 369, with limits $371 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 | 177th of 367, with limits $136 a month | 200th of 367, with limits $194 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 | 267th of 346, with limits $394 a month | 196th of 346, with limits $117 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 | 223rd of 338, with limits $8,795 a month | 83rd of 338, with limits $2,049 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 | Can't run it | 141st of 360, with limits $99 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 Both rent GPUs next to their sandboxes; Northflank costs less in this use case and boat has no GPUs. | 19th cheapest of 98 $1,187 a month | 4th cheapest of 98 $693 a month | 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 | Modal | Northflank | boat |
|---|---|---|---|
| Isolation | gVisor by default; VM runtime with its own kernel since October 2026 | Kata microVM with its own kernel for CPU; gVisor for GPU | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker inside | Only with the VM runtime | Yes, each CPU sandbox has its own kernel | Yes, in every sandbox |
| Longest session | 24 hours (default 5 minutes) | No documented limit; runs until you pause or delete it | No cap on paid plans (default TTL 1 h, changeable) |
| What survives a stop | No paused state; a finished sandbox is gone, only Volumes keep files | Pause keeps only attached volumes, which bill while paused | The whole disk, saved every minute and on stop; stopped sandboxes cost nothing |
| Snapshots and fork | Filesystem snapshots into an image; memory snapshots in alpha that end the sandbox | Filesystem snapshots of a running or stopping sandbox, restored into a new one | Automatic disk snapshots; fork a running sandbox without stopping it |
| Nested virtualization | VM runtime only, Team and Enterprise plans, on request | Not documented inside a sandbox | Yes, /dev/kvm for Android emulators and VMs |
| Desktop and browser | Not offered; an example shows how to set up VNC yourself | Headless; access by SDK, browser terminal or SSH | 60fps Linux desktop, Chromium and computer use built in |
| Coding agents | Examples only | Harnesses with Claude Code, Codex, Cursor, OpenCode or Pi, reached by terminal or SSH | Seven agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets are environment variables, or you run your own proxy in a sidecar | Header injection for listed hosts in the network policy API | Credentials proxy for model providers and any HTTPS API |
| Inbound access | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | HTTPS ports on a code.run domain; public TCP and UDP need a separate load balancer | HTTPS URLs for up to 50 ports, token-protected by default, plus raw TCP |
| Outbound rules | Block all, IP-range allowlist, domain allowlist (beta) | Network policies with allow lists by IP, CIDR or domain | Open internet, no provider-side allowlist |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | L4, A100, H100, RTX PRO 6000 and more | None |
| Regions | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | US, Canada, Brazil, UK, EU, Switzerland, Asia, Australia and South Africa, fixed per project | EU only: Germany, Finland, France |
| Self-hosting | No | Bring your own cloud, or the control plane in your VPC on Enterprise | No |
Every feature Battleships tracks (43)
| Feature | Modal | Northflank | boat |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | Not published | 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 | No | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | Yes | Yes |
| Public IPv4 | No | 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 | No | Yes |
| MCP server | No | No | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | 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) | Not published | Yes | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | 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
In the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, run on 29 September 2026, boat finished 26.69 runs per second and Modal's default gVisor sandbox 12.79, so boat did about 2.1 times the work. Northflank has no result on that benchmark, so there is no comparable CPU score for it.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal measured on: Sandbox (gVisor), request = size, any region. Northflank has 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 | Modal, a month | Northflank, 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 | $15 · Starter · with limits | $32 · Developer Sandbox (free tier) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $178 · Starter · with limits | $108 · Developer Sandbox (free tier) · 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 | $2,229 · Starter · with limits | $1,322 · Developer Sandbox (free tier) · 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 | $792 · Team | $361 · Developer Sandbox (free tier) · 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 | $3,193 · Team · with limits | $688 · Developer Sandbox (free tier) · with limits | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for whichever is higher, the CPU and memory you request or what you use, and an idle sandbox pays until it is terminated. Starter is free with $30 of monthly credit; Team is $250 a month with $100 of credit.
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.
Northflank: boat plans start at $20 a month and the whole fee becomes 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 Modal a sandbox lives at most 24 hours, its root disk is wiped when it ends, and Docker needs the VM runtime, so the 50-agent fleet does not fit the default sandbox. On Northflank only attached volumes survive a pause, and it does not publish how many sandboxes can run at once, so 300 or 1,000 at a time is not confirmed. boat's limit is start speed: even the $2,000 plan queues starts above 90 a minute, so 1,000 short jobs at once do not all start together.
| Scenario | Modal | Northflank | boat |
|---|---|---|---|
| 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 |
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Modal when
you run huge bursts of short sandboxes, such as RL rollouts or code runs, or need GPUs up to B300 next to them.
- Huge bursts of short jobs. For RL rollouts and code runs that finish in minutes: Modal starts fast and runs up to 5,000 containers on Team.
- GPUs from T4 to B300. For agents that run models: Modal has the widest GPU range here, up to B300, on the same platform as its sandboxes.
- Memory snapshots. For restoring exact clones of a running program: Modal can snapshot a sandbox's memory, though this is still alpha.
Use Northflank when
your sandboxes must run for days with Docker inside, in many regions or inside your own cloud account.
- Sessions with no time limit. For agents that work for days: a Northflank sandbox runs until you pause it, with Docker inside its own microVM kernel.
- Your own cloud. For teams that must run in their own AWS, GCP or Azure account, or want apps, databases and sandboxes on one platform.
- Regions around the world. For users far from Europe and the US: Northflank also runs in Brazil, Australia and South Africa.
Where boat fits
Modal and Northflank both treat a sandbox's disk as throwaway: only Volumes or attached volumes keep files. If your agents work on one machine for hours or days and should find it as they left it, with a desktop and the agent driven from your code, look at boat. If you need GPUs or regions outside Europe, pick Modal or Northflank.
The whole machine comes back
On Modal a sandbox ends within 24 hours and on Northflank a pause wipes everything outside attached volumes, so the agent reinstalls its tools. boat saves the whole disk every minute, and a stopped sandbox costs nothing.
A desktop, a browser and agents inside
Both Modal and Northflank are headless, so a computer-use agent needs you to build an image with a desktop and stream it. boat has a 60fps desktop, Chromium, /dev/kvm and seven coding agents you prompt and steer by API.
Faster machines, real keys kept out
boat did about 2.1 times the CPU work of Modal's default sandbox in the same benchmark. Its credentials proxy keeps real keys out of the sandbox for any HTTPS API; on Modal you build a sidecar proxy, and Northflank injects headers only for hosts you list.
Use boat when your agents work on one machine for hours or days 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: boat vs Modal and boat vs Northflank.
Questions people ask
Is Modal cheaper than Northflank?
It depends on the shape. For one coding agent on workdays Modal is $15 a month against $32 on Northflank, but for one agent that never stops Modal is $178 against $108, and 50 parallel agents cost $2,229 against $1,322. boat is $20, $26 and $317 for those three.
Which is faster, Modal or Northflank?
Only Modal has a result on the public benchmark: 12.79 Node.js build-and-test runs per second at 4 vCPU / 8 GB. Northflank has no comparable measurement. boat did 26.69 in the same run.
Can Modal and Northflank run Docker?
Northflank CPU sandboxes run in Kata microVMs with their own kernel, so Docker can run inside. Modal needs its VM runtime for Docker; the default gVisor sandbox does not document it. Every boat sandbox runs Docker.
Which keeps files between sessions?
Neither keeps the whole disk. Modal sandboxes have no paused state and only Volumes keep files, and a Northflank pause keeps only attached volumes. boat keeps the whole disk on every stop.
Do both have GPUs?
Yes. Modal rents T4 to B300 and Northflank L4, A100, H100, RTX PRO 6000 and more. In the GPU eval jobs use case Northflank costs $693 a month against $1,187 on Modal. boat has no GPUs.
Try boat
Install the CLI, then run boat new.
7-day free trial