Northflank vs Beam
Northflank runs each CPU sandbox in a Kata microVM with its own kernel, in regions around the world or in your own cloud. Beam runs sandboxes as fast gVisor containers in the US, sells separate CPU VMs, and costs less in every scenario on this page.
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.
Beam
Beam is a serverless cloud for GPU inference, sandboxes and background jobs, built on its open-source runtime Beta9.
Beam runs functions, REST endpoints, task queues, pods, sandboxes and VMs on CPUs and GPUs, all from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor that starts in a second or two, lives until you terminate it or its time to live runs out, and can be saved as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd and a root disk that stays when it stops. Much of Beam is a GPU serverless platform for AI teams.
- Bring your own cloud
- Management fee per vCPU and GB of RAM, on top of your own cloud bill
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 | Beam: 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; Northflank keeps only attached volumes after a pause and a Beam sandbox ends with its time to live, while bochka keeps the whole disk. | 159th of 367, with limits $1,477 a month | 69th of 367, with limits $551 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 173rd of 366, with limits $1,365 a month | 115th of 366, with limits $651 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 Beam fits short code runs best of the three: its sandboxes start in a second or two, bill per second and go away when the timer ends. | 84th of 345, with limits $115 a month | 8th cheapest of 345 $117 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 Beam's Team plan allows 1,000 CPU containers at once, while Northflank does not publish how many sandboxes can run together; bochka adds hosting and a disk that persists for each user. | 89th of 361, with limits $815 a month | 3rd cheapest of 361 $290 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 Neither Northflank nor Beam is a full match for RL rollouts in our ranking, and both sit near the bottom of it. | 342nd of 360, with limits $1,762 a month | 341st of 360, with limits $939 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 | 13th cheapest of 364 $251 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 All three fit plain CI; jobs that build Android apps or VM images need /dev/kvm, which only bochka documents. | 38th cheapest of 377 $352 a month | 12th cheapest of 377 $171 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Beam VM keeps its 50 GiB root disk while stopped and bochka saves the whole disk every minute, while a paused Northflank sandbox keeps only its volumes. | 151st of 368, with limits $59 a month | 13th cheapest of 368 $21 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 Northflank nor Beam has a desktop or browser product, so you build and stream one yourself; bochka ships a 60fps Linux desktop with Chromium. | 151st of 369, with limits $371 a month | 111th of 369, with limits $237 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 | 195th of 367, with limits $176 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 | 200th of 346, with limits $131 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 | 42nd of 338, with limits $923 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 | 175th of 360, with limits $155 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 have GPUs, from L4 to H100 and up on Northflank and from T4 to H200 and B200 on Beam; bochka is CPU only. | 4th cheapest of 98 $693 a month | Cheapest of 98 $458 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 | Northflank | Beam | bochka |
|---|---|---|---|
| Isolation | Kata microVM with its own kernel for CPU sandboxes; gVisor for GPU | gVisor container by default; separate Beam VMs are CPU microVMs with their own 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 | A sandbox ends with its time to live unless you save an image or use a volume; a Beam VM keeps a 50 GiB root disk | The whole disk, saved every minute and on stop; stopped sandboxes cost nothing |
| Snapshots and fork | Filesystem snapshots of a running or stopping sandbox, opt-in; restore into a new one | Memory snapshot of a running sandbox with its processes, restored into new sandboxes | Automatic disk snapshots; fork a running sandbox with its disk |
| Nested virtualization | Not documented inside a sandbox | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Docker and systemd | Docker can run inside, since each sandbox has its own kernel | Docker inside sandboxes with docker_enabled; systemd only in Beam VMs | Docker, systemd and root, like a normal Ubuntu server |
| Lifetime | Runs until you pause or delete it; no idle auto-pause | Default 10 minutes; set -1 to run until you terminate it | No session cap on paid plans; you set the time to live |
| Desktop and browser | Headless; access by SDK, browser terminal or SSH | No desktop or browser product | 60fps Linux desktop, Chromium and computer use built in |
| Coding agents | Harnesses with Claude Code, Codex, Cursor, OpenCode or Pi; you reach them through a terminal or SSH | None preinstalled; you install and run them through process exec | Seven agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Header injection for listed hosts in the network policy API; otherwise env vars or files | Secrets are environment variables inside the sandbox | 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 separate load balancer | A public HTTPS URL per exposed port with no built-in auth; no raw TCP or dedicated IP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | Allow lists by IP, CIDR or domain, documented for your own cluster | Block all outbound traffic or allow up to 10 CIDR ranges, changeable while running | Open internet, no provider-side allowlist |
| GPUs | L4, A100, H100, RTX PRO 6000 and more | GPU sandboxes and serverless GPUs up to H100, H200 and B200 | No, CPU only |
| Regions | US, Europe, Asia, Australia, South America and Africa | US only; no other region is listed | EU only (Germany, Finland, France) |
| Self-hosting | Bring your own cloud, or the control plane in your VPC on Enterprise | Beta9 runtime is AGPL-3.0 and free to self-host; bring your own cloud for a fee | No |
Every feature Battleships tracks (43)
| Feature | Northflank | Beam | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Yes | Yes |
| Systemd | Not published | No | 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 | No | Yes |
| Automatic snapshots | Yes | No | 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 | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | Yes | No | No |
| Self-hosting | Yes | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | No | Yes | 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 | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for either Northflank or Beam: neither has a result on the StarSling hpc-sandbox-benchmarks test, so we cannot say which of the two is faster at CPU work. 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 Beam 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 | Beam, 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 | $5 · Developer | $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 | $22 · Developer | $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 | $410 · Team | $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 | $191 · Team | $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 | $259 · Team | $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.
Beam: Beam sandboxes bill per second for each CPU core (two vCPU) and GiB of RAM until you terminate them or their time to live ends, so an idle tail is billed too. Developer has no fee, Team costs $89 a month plus usage, and there are no egress fees.
Beam: 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, so packages installed anywhere else reset, and it does not publish how many sandboxes can run at once, so 300 or 1,000 at a time is not confirmed. Beam's Developer plan allows 30 CPU containers at once, so 50 parallel agents need the Team plan, and Beam publishes no disk price, so the scenarios count no disk cost for it. bochka's limit is in the burst scenario: even its $2,000 plan queues starts above 90 a minute.
| Scenario | Northflank | Beam | 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 Northflank when
you want every CPU sandbox in a microVM, sandboxes in regions outside the US, or one platform that also runs your apps and databases inside your own cloud.
- A microVM for every CPU sandbox. For agents that need a real kernel: every Northflank CPU sandbox runs in a Kata microVM, not a shared-kernel container.
- Regions around the world. For users far from the US: Northflank runs in Europe, Asia, Australia, South America and Africa as well.
- One platform, and your own cloud. For teams that want apps, databases and sandboxes on one platform, or inside their own AWS, GCP or Azure account.
Use Beam when
cost matters most, when your agents need GPUs and memory snapshots, when US hosting suits you, or when you want an open source runtime you can self-host.
- Lower cost in these scenarios. For teams watching the bill: Beam costs less than Northflank in all five scenarios on this page.
- Memory snapshots. For agents that should resume mid-task: Beam can snapshot a running sandbox with its processes and restore it into new ones.
- Open source runtime. For teams that want to run it themselves: Beam's Beta9 runtime is AGPL-3.0 and free to self-host.
Where bochka fits
Northflank and Beam both give an agent a headless Linux box and leave the agent, the desktop and most of the state to you. If your agents work on one machine for hours or days, installing tools, running Docker and emulators, and serving what they build, look at bochka. Each sandbox is a full VM whose whole disk comes back, with agents, a desktop and a credentials proxy built in.
The whole machine comes back
A paused Northflank sandbox keeps only its attached volumes, billed while paused, and a Beam sandbox ends with its time to live unless you save an image. Either way the agent reinstalls its tools. bochka saves the whole disk every minute, and stops are free.
Agents, a desktop and keys built in
Northflank Harnesses reach the agent only through a terminal or SSH, Beam preinstalls none, and neither has a desktop. Beam keeps secrets as env vars the agent can read. bochka drives seven agents from outside by API, streams a 60fps desktop, and proxies keys.
/dev/kvm and real hosting
Neither Northflank nor Beam documents /dev/kvm, so Android emulators and nested VMs have nothing to start on. Beam has no raw TCP, and Northflank needs a separate load balancer for it. bochka gives /dev/kvm, HTTPS on 50 ports and raw TCP.
Use bochka when your agents do real work over hours or days and should find the machine as they left it: installs, Docker, emulators, a desktop and a browser on a full VM, with the agent driven from your code. Compare it one to one: bochka vs Northflank and bochka vs Beam.
Questions people ask
Is Northflank cheaper than Beam?
No, Beam costs less in all five scenarios on this page. One agent that never stops is $22 a month on Beam against $108 on Northflank, and 50 agents in parallel are $410 against $1,322. bochka sits between them, at $26 and $317 for those two.
Which is faster, Northflank or Beam?
We cannot say: neither has a result on the StarSling hpc-sandbox-benchmarks CPU test. bochka did 26.69 runs per second on that test at 4 vCPU / 8 GB.
Is a Beam sandbox a VM like a Northflank sandbox?
Not by default. Beam sandboxes are gVisor containers, and Beam sells separate CPU VMs with their own kernel and systemd. Northflank runs every CPU sandbox in a Kata microVM, and every bochka sandbox is a full VM with /dev/kvm.
Can I run Docker in Northflank and Beam?
Yes. Northflank sandboxes have their own kernel, so Docker can run inside, and Beam supports Docker inside a sandbox with docker_enabled. bochka runs Docker in its full VM and also has systemd and /dev/kvm.
What happens to files when the sandbox stops?
On Northflank only attached volumes survive a pause. A Beam sandbox ends with its time to live, 10 minutes by default, unless you save an image or snapshot or attach a volume; a Beam VM keeps its root disk. bochka saves the whole disk every minute and on stop.
Is bochka SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.
Try bochka
Install the CLI, then run bochka new.
Product preview