Daytona vs Northflank
Daytona is a sandbox cloud built for agent code: containers by default, with Linux VM, Windows and GPU classes on top. Northflank is a broad developer platform whose CPU sandboxes run in Kata microVMs, with GPUs, many regions and your own cloud, but only attached volumes survive a pause.
The companies and products
Daytona
Daytona is a cloud for running AI-generated code: you create sandboxes from code through its API and SDKs.
By default a Daytona sandbox is a Linux container with its own namespaces and reserved vCPU, memory and disk. You can also pick a Linux VM class (pause, fork, memory snapshots, /dev/kvm), a Windows VM class, or a GPU class with Nvidia and AMD cards. It is built for teams that run agent code, code interpreters and evals through Python, TypeScript, Ruby, Go or Java SDKs.
- Founded
- 2023
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. “15th cheapest of 367” means 14 of the other 366 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 | Daytona: price rank | Northflank: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Daytona fits a coding agent that installs packages anywhere on the machine, while on Northflank only attached volumes survive a pause; bochka keeps the whole disk on a full VM. | 15th cheapest of 367 $4,111 a month | 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 assistant that lives on its machine for weeks needs its files to stay put, which Daytona and bochka do and Northflank only does inside volumes. | 24th cheapest of 366 $6,104 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 Daytona fits short code runs well, creating hundreds of sandboxes a minute; Northflank's small per-second plans cost less but still only keep files in volumes. | 25th cheapest of 345 $271 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 300 sandboxes of 2 vCPU need 600 vCPU, more than Daytona's Tier 4 pool of 500, and Northflank does not publish how many can run at once; bochka fits on its $100 plan. | 154th of 361, with limits $2,000 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 | 130th of 360, with limits $8,261 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 | 189th of 364, with limits $2,000 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 Northflank fits CI jobs that throw their disk away, and Daytona caps one sandbox at 4 vCPU by default; bochka adds /dev/kvm and free stops. | 308th of 377, with limits $805 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 | 183rd of 368, with limits $245 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 Daytona has a VNC desktop and a computer-use API on Linux and Windows, while Northflank sandboxes are headless; bochka streams a 60fps desktop. | 26th cheapest of 369 $1,198 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 Northflank has no browser product, so you install one in your image; bochka has Chromium ready in every sandbox. | 93rd of 367, with limits $598 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 | 38th cheapest of 346 $404 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 | 202nd of 338, with limits $8,073 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 | 12th cheapest of 360 $2,000 a month | 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: Daytona up to B300 and AMD MI355X, Northflank from L4 to H100 and up; bochka has no GPUs. | 20th cheapest of 98 $1,190 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 | Daytona | Northflank | bochka |
|---|---|---|---|
| Isolation | Container by default; Linux VM and Windows VM classes have their own kernel | Kata microVM with its own kernel for CPU sandboxes; gVisor for GPU | Every sandbox is a full VM with its own kernel |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 21.52 runs/s on the Linux VM class; the default container class reported no result | No comparable measurement | 26.69 runs/s |
| What survives a stop | The whole disk is kept and billed while stopped; archived containers are free | Only attached volumes, which bill while paused; the rest of the disk and all processes reset | The whole disk, saved every minute and on stop; a stopped sandbox costs nothing |
| Pause, snapshots and fork | Linux VM and Windows: pause, resume and fork with memory kept; containers cannot pause or fork | Opt-in filesystem snapshots of a running sandbox, restored into a new one; no memory snapshots | Automatic disk snapshots; fork a running sandbox; resume reboots from disk |
| Docker and nested virtualization | Docker in all classes; /dev/kvm only on Linux VMs, once KVM is turned on for your organization | Docker inside; /dev/kvm not documented inside a sandbox | Docker, root, systemd and /dev/kvm on every machine |
| Desktop and computer use | VNC desktop (xfce4) and a computer-use API on Linux and Windows | Headless; access by SDK, browser terminal or SSH | 60fps Linux desktop and Chromium, computer use and browser control, embeddable stream |
| Coding agents | Guides install agents and run them through process exec | Harnesses start Claude Code, Codex, Cursor, OpenCode or Pi; you reach them by terminal or SSH | Seven agents preinstalled, driven from outside with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets proxy swaps placeholders in HTTPS request headers for allowed hosts | Header injection for listed hosts in the network policy API; otherwise env vars or files | AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Reaching the sandbox | HTTPS preview URLs on any port, token-protected or public; SSH; no raw TCP or public IP | HTTPS ports on a code.run domain, private by default; public TCP and UDP need a separate load balancer | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Outbound internet | Tier 1 and 2 reach only registries, git hosts and AI APIs; Tier 3 and up get open internet plus allowlists | Open internet, with network policies by IP, CIDR or domain | Open internet on every plan; no provider-side allowlist |
| Sandbox size | Up to 4 vCPU / 8 GB by default, raisable per region | Plans from 0.1 vCPU up to 20 vCPU / 40 GB; a resize restarts the sandbox | Up to 16 vCPU / 32 GB on the $100 plan and above |
| GPUs | Nvidia RTX 4090 up to B300 and AMD MI355X, on-demand or preemptible | L4, A100, H100, RTX PRO 6000 and more, billed per hour | None |
| Windows | Windows VM sandboxes in three sizes | Linux only | No Windows guests; Wine for Windows apps |
| Regions and your own cloud | US and EU, plus dedicated regions or your own machines | US, Canada, Brazil, UK, EU, Switzerland, Asia, Australia and South Africa; your own AWS, GCP or Azure | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Daytona | Northflank | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | 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) | 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 | No | Yes | 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 | Yes | No | No |
| GPU | Yes | Yes | No |
| Windows | Yes | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | 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 StarSling's public run of 2026-09-29, at 4 vCPU / 8 GB, bochka did 26.69 Node.js build-and-test runs per second and Daytona's Linux VM class did 21.52. Daytona's default container class reported no result in that run. Northflank has no result on this benchmark, so there is no CPU number to compare it with.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Daytona measured on: Linux VM sandbox (same rates; KVM / nested virt per-org feature). 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 | Daytona, a month | Northflank, 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 | $56 · Tier 3 ($500 top-up) | $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 | $245 · Tier 3 ($500 top-up) | $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,682 · Tier 3 ($500 top-up) | $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 | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits | $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 | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits | $688 · Developer Sandbox (free tier) · with limits | $2,000 · $2000/mo · with limits |
Daytona: Daytona bills per second for the vCPU, memory and disk you reserve, and keeps billing the disk while a sandbox is stopped. You pay from a prepaid wallet: open internet needs a $500 top-up (Tier 3), and the biggest pool needs $2,000 every 30 days (Tier 4).
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: Plans start at $20 a month, and the whole fee is usage credit spent per second while sandboxes run. A stopped sandbox costs nothing and keeps its whole disk.
Limits in those scenarios
On Northflank the limit that bites in every scenario is what survives a stop: only attached volumes keep their files, so packages installed anywhere else reset, and it does not publish how many sandboxes can run at once. Daytona limits the total vCPU running at once, 500 vCPU on Tier 4, so 300 sandboxes for your users (600 vCPU) and 1,000 short jobs at once (2,000 vCPU) need a custom limit. Daytona also opens the internet only from Tier 3. bochka fits every scenario but the burst, where starts above 90 a minute are queued.
| Scenario | Daytona | Northflank | bochka |
|---|---|---|---|
| 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 |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Daytona when
you need Windows desktops, sandboxes that pause with their memory, or GPUs next to agent code, and the default container isolation is enough or you choose the VM class.
- The whole disk stays. For agents that install tools all over the machine: a stopped Daytona sandbox keeps its whole disk, not just mounted volumes.
- Windows and memory pause. For Windows desktops or sandboxes that resume with their memory: Daytona's VM classes pause, fork and come back where they were.
- Built for agent code. For code interpreters and evals: Daytona creates hundreds of sandboxes a minute and ships a desktop and computer-use API.
Use Northflank when
you want a microVM per sandbox on a platform that also runs your apps, in regions around the world or inside your own cloud, and your agents keep their work in volumes.
- A microVM by default. For running untrusted code without picking a class: every Northflank CPU sandbox gets its own kernel in a Kata microVM.
- Regions and your own cloud. For users far from Europe or the US, or teams that must run in their own AWS, GCP or Azure account.
- One platform for everything. For teams that also want their services, jobs, databases and GPUs on the same platform as their sandboxes.
Where bochka fits
If your agents work on one machine for hours or days, look at bochka. Every sandbox is a full VM that keeps its whole disk, with Docker, /dev/kvm, a desktop and coding agents built in, which neither Daytona nor Northflank gives you all at once.
A full VM that keeps its disk
Daytona keeps the disk but defaults to a container that shares the host kernel. Northflank gives a microVM but wipes everything outside volumes on a pause. bochka gives every sandbox its own kernel and saves the whole disk every minute.
A faster CPU in the same test
In the same benchmark, bochka did 26.69 runs per second and Daytona's Linux VM class did 21.52, so builds and tests take about a quarter longer there. Northflank has no comparable result at all.
Agents and a desktop you drive from code
On Daytona you install agents and run them as processes; on Northflank you reach Harnesses by terminal or SSH and sandboxes are headless. bochka ships seven agents with a prompt, steer and events API, plus a 60fps desktop.
Use bochka when your agents do real work for hours on one machine: installs, Docker and emulators on a full, faster VM that keeps its whole disk, with a desktop and coding agents you drive from your code. Compare it one to one: bochka vs Daytona and bochka vs Northflank.
Questions people ask
Is Daytona cheaper than Northflank?
In the scenarios we priced, Northflank's bill is lower: one agent that never stops is $108 a month on Northflank against $245 on Daytona, and 50 agents in parallel are $1,322 against $2,682. But Northflank keeps files only in volumes, so it does not fully fit those scenarios. bochka comes to $26 and $317.
Which is faster, Daytona or Northflank?
There is no comparable CPU number for Northflank. In StarSling's public run, Daytona's Linux VM class did 21.52 runs per second and bochka did 26.69 at 4 vCPU / 8 GB.
Are Daytona and Northflank sandboxes containers or VMs?
Daytona's default is a Linux container, with Linux VM and Windows VM classes that have their own kernel. Northflank runs CPU sandboxes in Kata microVMs and GPU sandboxes under gVisor. On bochka, every sandbox is a full VM.
Do Daytona and Northflank keep files when a sandbox stops?
Daytona keeps the whole disk and bills it while stopped. Northflank keeps only attached volumes; the rest of the disk and all processes reset on a pause. bochka keeps the whole disk and a stopped sandbox costs nothing.
Can Daytona and Northflank run Docker?
Yes, both can run Docker inside a sandbox. Daytona exposes /dev/kvm only on its Linux VM class once KVM is turned on for your organization, and Northflank does not document it. bochka has Docker and /dev/kvm on every machine.
Which one has GPUs and regions outside Europe?
Both rent GPUs by the hour and run in the US as well as the EU; Northflank also runs in Asia, Australia, South America and Africa. bochka has no GPUs and runs only in the EU.
Try bochka
Install the CLI, then run bochka new.
Product preview