Northflank vs Docker Cloud Sandboxes
Both run each sandbox in a microVM with its own kernel. Northflank is a broad cloud platform with no session cap, GPUs and many regions, while Docker Cloud Sandboxes puts the sbx microVM from your laptop in the cloud, keeps memory on stop and ends each sandbox 24 hours after creation.
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.
Docker Cloud Sandboxes
Docker Cloud Sandboxes runs Docker's sbx coding-agent microVMs on Docker-managed compute instead of your laptop.
Each sandbox is a microVM with its own Linux kernel and its own Docker Engine, started from the same sbx CLI you use locally, with Claude Code, Codex and other agents ready to run. You can move a sandbox from your laptop to the cloud and back, publish HTTPS ports and SSH in. It launched on September 24, 2026, is billed pay-as-you-go on a personal Docker account, and is built for developers who want their local agent sandboxes to keep going off their machine.
- Launched
- September 24, 2026
- Session length
- 1 hour by default, extendable to 24 hours from creation
- Default quota
- 10 concurrent and 50 stored sandboxes per account
- Regions
- Not published
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 | Docker Cloud Sandboxes: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory runs agents for days and many at once; Docker ends each sandbox at 24 hours and allows 10 at a time, Northflank keeps only attached volumes on a pause, and bochka keeps the whole disk with no cap. | 159th of 367, with limits $1,477 a month | 280th of 367, with limits $4,928 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 all month cannot do it in one Docker session, and on Northflank its installs outside volumes reset on every pause. | 173rd of 366, with limits $1,365 a month | 276th of 366, with limits $5,110 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 and Docker: small machines billed by the second, with Docker also keeping memory between runs. | 84th of 345, with limits $115 a month | 119th of 345, with limits $233 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 Serving your own users needs more than Docker's default 10 sandboxes at once; Northflank does not publish its limit, and bochka runs 100 on the $20 plan. | 89th of 361, with limits $815 a month | 136th of 361, with limits $1,628 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 | 114th of 360, with limits $7,000 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 | 167th of 364, with limits $1,400 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 well; bochka adds /dev/kvm for Android emulators and VM builds, which neither Northflank nor Docker documents. | 38th cheapest of 377 $352 a month | 172nd of 377, with limits $672 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 stays on all month needs no session cap, which rules Docker out; on Northflank only attached volumes survive a pause. | 151st of 368, with limits $59 a month | 127th of 368, with limits $204 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 Computer-use agents need a screen; Northflank and Docker are both headless, while bochka has a 60fps Linux desktop with Chromium. | 151st of 369, with limits $371 a month | 268th of 369, with limits $1,400 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 | 277th of 367, with limits $700 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 | 262nd of 346, with limits $350 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 | 190th of 338, with limits $7,000 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 | 248th of 360, with limits $350 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; Docker 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 | Docker Cloud Sandboxes | bochka |
|---|---|---|---|
| Isolation | Kata microVM with its own kernel for CPU; gVisor for GPU | MicroVM with its own Linux kernel; hypervisor not named | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Session length | No documented cap; runs until you pause or delete it | 1 hour by default, at most 24 hours from creation | No cap on paid plans; you set the time to live |
| What survives a stop | Only attached volumes, which bill while paused; the rest of the disk and all processes reset | Memory and files; resume picks up where it left off, but snapshots unused for 7 days are deleted | The whole disk, saved every minute and on stop; stopped sandboxes cost nothing |
| Snapshots and fork | Filesystem snapshots of a running sandbox, opt-in; restore into a new one | Snapshot a running sandbox with disk or disk and memory, then restore it as a new one | Automatic disk snapshots; fork a running sandbox |
| Sandboxes at once | Limit not published | 10 by default; no published way to raise it | 100 on the $20 plan, up to 2,000 on higher plans, self-serve |
| Machine sizes | From 0.1 vCPU up to 20 vCPU / 40 GB, more on request | 1 vCPU / 2 GiB up to 16 vCPU / 32 GiB | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Nested virtualization | Not documented inside a sandbox | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Desktop and browser | Headless; access by SDK, browser terminal or SSH | Terminal sessions only | 60fps Linux desktop with Chromium and computer use |
| Coding agents | Harnesses with Claude Code, Codex, Cursor, OpenCode or Pi, reached by terminal or SSH | Claude Code, Codex, Copilot, OpenCode and more, attached to from the sbx CLI | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Keeping API keys out of the sandbox | Header injection for listed hosts in the network policy API | Cloud proxy sets the auth header for built-in AI services and custom hosts | 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 URL per published port, not protected by Docker sign-in; not a TCP tunnel | 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 | Allow and deny rules by host at a proxy, with allow-all, balanced and deny-all presets | Open internet, no provider-side allowlist |
| GPUs | L4, A100, H100, RTX PRO 6000 and more | No | No |
| Where it runs | US, Europe, Asia, Australia, South America and Africa, or your own cloud | Regions not published; same microVM also runs on your laptop | EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Northflank | Docker Cloud Sandboxes | 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 | 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 | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | No | Yes | 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 | Not published | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | Not published | 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 | Yes | 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 | No | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither Northflank nor Docker Cloud Sandboxes has a comparable CPU measurement: neither has a result on the hpc-sandbox-benchmarks test, and Docker does not say what hardware it uses. 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 Docker Cloud Sandboxes 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 | Docker Cloud Sandboxes, 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 | $49 · Docker Agentic Platform (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 | $204 · Docker Agentic Platform (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 | $2,464 · Docker Agentic Platform (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 | $700 · Docker Agentic Platform (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,400 · Docker Agentic Platform (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.
Docker Cloud Sandboxes: Docker bills per second for the size you pick, from $0.07 an hour for 1 vCPU / 2 GiB to $1.12 an hour for 16 vCPU / 32 GiB, with no monthly fee. A stopped sandbox costs nothing, and volumes and egress are free.
Docker Cloud Sandboxes: 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 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. Docker ends every sandbox 24 hours after creation, which rules out one agent that never stops, and its default of 10 at once rules out 50 agents, sandboxes for your users and 1,000 short jobs. bochka fits every scenario but the burst, where even the $2,000 plan queues starts above 90 a minute.
| Scenario | Northflank | Docker Cloud Sandboxes | bochka |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | 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, regions outside Europe, sandboxes in your own cloud account, or sandboxes that run past a day.
- No session cap. For agents that run for days: a Northflank sandbox keeps running until you pause or delete it.
- GPUs and regions. For agents that need a GPU or users far from Europe: Northflank has L4 to H100 cards and regions worldwide.
- Your own cloud, and one platform. For teams that must run in their own AWS, GCP or Azure account, next to their services and databases.
Use Docker Cloud Sandboxes when
you already run agents in sbx on your laptop and want a few of them to keep going in the cloud for up to a day, with memory kept across stops.
- Stop and fork with memory. For agents that pause between steps: a stopped Docker sandbox comes back with its memory and running processes.
- The same sandbox on your laptop. If you already run sbx locally, the cloud is the same microVM and CLI, and you can move work between them.
- Nothing billed while stopped. For bursty agents: a stopped Docker sandbox costs nothing, and volumes and egress are free.
Where bochka fits
If your agents work on one machine for hours or days, need a screen or emulators, and are driven from your own code, look at bochka. It keeps the whole disk on every free stop, has no session cap on paid plans, and runs 100 sandboxes at once on the $20 plan.
The whole machine comes back
On Northflank a pause wipes everything outside attached volumes, which bill while paused, so agents reinstall their tools. Docker keeps state on stop, but deletes snapshots unused for 7 days and ends each session at 24 hours.
A desktop, a browser and /dev/kvm inside
Both Northflank and Docker are headless and document no nested virtualization, so a computer-use agent or an Android emulator needs a desktop image and stream you build yourself. bochka ships a 60fps desktop with Chromium and /dev/kvm.
Agents you drive from outside
On Northflank you reach the agent through a terminal or SSH, and on Docker by attaching from the sbx CLI, so running many from your app means wrapping terminal text. bochka has one API to prompt, steer and follow seven agents.
Use bochka when your agents run for days or by the dozen, should find their machine as they left it, need Android emulators, a desktop or a browser, or have to be driven from your own app through an API. Compare it one to one: bochka vs Northflank and bochka vs Docker Cloud Sandboxes.
Questions people ask
Is Northflank cheaper than Docker Cloud Sandboxes?
In these scenarios Northflank's list price is lower: one agent that never stops is $108 a month on Northflank against $204 on Docker, and 50 agents in parallel are $1,322 against $2,464. bochka is lower than both there, at $26 and $317. Docker has a cost edge when sandboxes sit stopped, since stops, volumes and egress are free.
Which is faster, Northflank or Docker Cloud Sandboxes?
There is no comparable CPU measurement for either one. bochka did 26.69 runs per second on the hpc-sandbox-benchmarks Node.js test at 4 vCPU / 8 GB.
Can I run Docker inside each?
Yes. Each Northflank CPU sandbox and each Docker cloud sandbox has its own kernel, and Docker's comes with its own Docker Engine. bochka also runs Docker with root and systemd, and adds /dev/kvm for Android emulators and VMs.
Can a sandbox run longer than 24 hours?
On Northflank, yes: no session cap is documented, and a sandbox runs until you pause or delete it. A Docker cloud sandbox cannot go past 24 hours from creation. bochka has no session cap on paid plans.
What happens to my files when a sandbox stops?
On Northflank a pause keeps only attached volumes; the rest of the disk and all processes reset. Docker keeps memory and files, but deletes snapshots unused for 7 days. bochka saves the whole disk every minute and on stop, for free.
Does either have GPUs?
Northflank has GPU sandboxes under gVisor with cards from L4 to H100 and more. Docker Cloud Sandboxes and bochka are CPU only.
Try bochka
Install the CLI, then run bochka new.
Product preview