Runloop vs Northflank
Runloop is built only for coding agents, with devboxes that can sleep when idle and wake on a request. Northflank is a broad cloud platform where sandboxes sit next to GPUs, databases and regions around the world.
The companies and products
Runloop
Runloop is a US platform of sandboxes, called devboxes, for building, running and testing AI coding agents.
You get Linux devboxes built from Dockerfile-style blueprints, disk snapshots, HTTPS tunnels, agent gateways that hide API keys, and Axons, event streams that drive agents such as Claude Code. Each devbox runs in a micro-VM on Runloop's own bare-metal hypervisor, with a container layer inside. It is built for teams shipping coding agents, plus evaluation and RL fine-tuning work on the Enterprise plan.
- Compliance
- SOC 2 Type 2
- Architectures
- x86_64 and arm64 base blueprints
- Own-cloud deploy
- Deploy to VPC on AWS, GCP and Azure (Enterprise)
- Regions
- Not documented or selectable
- Company
- Runloop AI, Inc.
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. “20th cheapest of 367” means 19 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 | Runloop: 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 Runloop fits fully and keeps a devbox's disk through suspend or snapshots, while on Northflank only attached volumes survive a pause; bochka keeps the whole disk on every plan. | 20th cheapest of 367 $8,152 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 Runloop can sleep an idle devbox and wake it on an HTTP request (Pro plan), while Northflank bills a sandbox until you pause it and then resets everything outside volumes. | 32nd cheapest of 366 $10,194 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 Runloop ranks higher than Northflank for many short code runs, and both rank above bochka, whose per-plan start limits queue very large bursts. | 44th cheapest of 345 $525 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 Both can give each of your users a machine; Northflank adds regions around the world, bochka adds HTTPS on up to 50 ports and a whole disk that survives. | 26th cheapest of 361 $3,301 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 Runloop ranks 4th of 360 for RL rollouts and sells RL fine-tuning on Enterprise; Northflank is only a compromise fit, at 342nd. | 4th cheapest of 360 $15,922 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 | 81st cheapest of 364 $2,562 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 fully and ranks above Runloop here; bochka ranks higher than both, with faster CPUs and free stops. | 121st cheapest of 377 $1,554 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 | 113th cheapest of 368 $410 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 Runloop ships a desktop and a browser your agent can control, while Northflank sandboxes are headless; bochka streams its desktop at 60fps. | 39th cheapest of 369 $2,306 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 | 40th cheapest of 367 $1,153 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 | 68th cheapest of 346 $781 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 | 266th of 338, with limits $15,611 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 | 10th cheapest of 360 $770 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 Northflank ranks 4th of 98 with GPU sandboxes from L4 to H100; Runloop and bochka run on CPUs only. | Can't run it | 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 | Runloop | Northflank | bochka |
|---|---|---|---|
| Isolation | Micro-VM on a custom bare-metal hypervisor, plus a container layer | Kata microVM with its own kernel for CPU; gVisor for GPU | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| CPU speed (Node.js build-and-test loop, 4 vCPU / 8 GB) | 8.29 runs a second | No comparable measurement | 26.69 runs a second |
| What survives a stop | Disk kept through suspend (Pro plan) or manual disk snapshots; shutdown ends the devbox | 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, on every plan; stopped sandboxes cost nothing |
| Long runs | Fixed lifetime 1 hour by default, 48 hours max; an idle policy replaces it | No maximum runtime documented; runs until you pause or delete it | No session cap on paid plans; default TTL 1 hour, changeable |
| Idle sleep and wake | Suspend after idle, wake on an HTTP request to the tunnel (Pro plan) | No idle auto-pause; bills the full plan until you pause it | No idle timer; TTL based |
| Nested virtualization | Not documented; Docker-in-Docker blueprints only | Not documented inside a sandbox | Yes: /dev/kvm, Android emulator, VMs inside |
| Docker inside | Yes, on the Docker-in-Docker blueprints, as root | Yes, each sandbox has its own kernel | Yes, with root and systemd |
| Desktop and browser | Desktop and browser your agent can control | Headless; access by SDK, browser terminal or SSH | 60fps Linux desktop, Chromium and computer use built in, embeddable in your app |
| Coding agents | Claude Code, Codex, OpenCode, Gemini CLI, DeepAgents, driven through Axons and Broker | Harnesses with Claude Code, Codex, Cursor, OpenCode or Pi; you reach the agent through a terminal or SSH | Seven agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Agent gateways for any API endpoint with bearer, header or basic auth | Header injection for listed hosts in the network policy API; otherwise env vars or files | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when one runs out |
| Inbound networking | One HTTPS tunnel per devbox, open or bearer token; SSH through a TLS proxy; no 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 by default, raw TCP, dedicated IPv6 or IPv4 |
| Egress rules | Hostname allowlist with wildcards, or block all | Network policies with allow lists by IP, CIDR or domain, documented for your own cluster | Open internet, no provider-side allowlist |
| GPUs | No | L4, A100, H100, RTX PRO 6000 and more, billed per hour | No |
| Regions and your own cloud | Regions not documented; Deploy to VPC on AWS, GCP or Azure (Enterprise) | US, Canada, Brazil, UK, EU, Switzerland, Asia, Australia and South Africa; your own AWS, GCP, Azure, Oracle or CoreWeave account | EU only (Germany, Finland, France), EU data residency |
Every feature Battleships tracks (43)
| Feature | Runloop | Northflank | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | 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) | Yes | Yes | Yes |
| Memory fork | No | 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 | Yes | 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 | Yes | No | Yes |
| MCP server | Yes | No | No |
| GPU | No | Yes | No |
| Windows | No | No | No |
| Arm64 | Yes | 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) | No | Yes | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Not published | Yes | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
On the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB (run 36498291449, 2026-09-29), bochka scored 26.69 runs a second and Runloop 8.29, about 3.2 times apart. Northflank Sandboxes has no result on that test, so there is no comparable CPU number for it. The test measures CPU work only, not start time or network speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. 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 | Runloop, 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 | $113 · Basic | $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 | $429 · Basic | $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 | $5,268 · Basic | $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 | $1,441 · Basic | $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,184 · Basic | $688 · Developer Sandbox (free tier) · with limits | $2,000 · $2000/mo · with limits |
Runloop: Runloop bills per second for the CPU and memory you allocate while a devbox starts, runs, suspends or resumes, and bills its disk for the devbox's whole life. Basic has no plan fee; Pro adds $250 a month that is not usage credit and unlocks suspend and resume.
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, billed per second while a sandbox runs. A stopped sandbox costs nothing and keeps its whole disk.
Limits in those scenarios
Northflank's per-hour price is lower than Runloop's in every scenario, but in the first four only attached volumes keep their files, so packages installed anywhere else reset, and it does not publish how many sandboxes can run at once. Runloop fits every scenario, though it publishes no egress price and its fixed lifetime setting tops out at 48 hours unless you use an idle policy. bochka's limit is in the burst scenario: even the $2,000 plan queues starts above 90 a minute, so 1,000 short jobs at once do not all start together.
| Scenario | Runloop | 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 Runloop when
you build coding agents and want devboxes that sleep when idle, a hostname allowlist, arm64, Dockerfile blueprints, or very large waves of RL rollouts.
- Sleep when idle, wake on a request. For agents that sit idle between tasks: Runloop can suspend a devbox, keep its disk, and wake it on an HTTP request (Pro plan).
- A hostname allowlist on its own cloud. For sandboxes that must only reach a fixed list of hosts: Runloop allows listed hostnames, with wildcards, or blocks everything.
- Big waves for RL and evals. For RL rollouts: Runloop starts large waves without published start limits and sells RL fine-tuning on Enterprise.
Use Northflank when
you need GPUs next to the agent, regions outside Europe and the US, or sandboxes in your own cloud account next to the rest of your apps.
- GPU sandboxes. For agents that train, fine-tune or run models: Northflank has GPU sandboxes from L4 to H100 and up.
- Regions around the world. For users far from Europe or the US: Northflank runs in Canada, Brazil, Asia, Australia and South Africa too.
- Your own cloud, and one platform. For teams that want sandboxes in their own cloud account, next to their services, jobs and databases on one platform.
Where bochka fits
If your agents work on one machine for hours or days, installing tools, building, testing and running Docker, look at bochka. It keeps the whole machine between runs on every plan, gives it a full kernel with /dev/kvm, and runs on CPUs measured at about 3.2 times Runloop's speed. Pick Runloop or Northflank instead if you need GPUs, arm64, regions outside Europe or your own cloud.
The whole machine comes back
On Runloop a devbox is gone once it shuts down, so keeping work means the Pro plan's suspend or your own snapshot code. On Northflank a pause wipes everything outside attached volumes. bochka saves the whole disk every minute.
A full Linux machine with /dev/kvm and raw TCP
Neither Runloop nor Northflank documents nested virtualization, so Android emulators and VMs do not start. Runloop reaches devboxes through HTTPS tunnels only, and Northflank needs a separate load balancer for public TCP.
Faster CPUs, measured
On the same Node.js build-and-test loop, bochka ran 26.69 runs a second and Runloop 8.29, so every install and test waits about three times as long on Runloop. Northflank has no result on that test.
Use bochka 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, on faster CPUs, with the agent driven from your code. Compare it one to one: bochka vs Runloop and bochka vs Northflank.
Questions people ask
Is Runloop cheaper than Northflank?
No, Northflank's per-second prices are lower in every scenario we priced: one agent that never stops is $108 on Northflank against $429 on Runloop. But Northflank keeps only attached volumes across a pause, so in those scenarios packages installed elsewhere reset. On bochka the same always-on agent is $26 a month.
Which is faster, Runloop or Northflank?
We can only say for Runloop: it scored 8.29 runs a second on the Node.js build-and-test benchmark at 4 vCPU / 8 GB. Northflank has no result on that test. bochka scored 26.69 on the same test.
Can Runloop and Northflank run Docker?
Yes. Runloop runs Docker on its Docker-in-Docker blueprints as root, and Northflank gives each CPU sandbox its own kernel. Neither documents /dev/kvm, so Android emulators and VMs inside are a bochka feature.
Does a sandbox keep its files when it stops?
On Runloop, the disk is kept while a devbox is suspended (Pro plan) or in a disk snapshot; shutdown deletes it. On Northflank, only files on attached volumes survive a pause. bochka keeps the whole disk on every stop, on every plan.
Does Runloop or Northflank have GPUs?
Northflank does, with GPU sandboxes under gVisor from L4 and A100 up to H100 and more. Runloop and bochka run on CPUs only.
Can I run them in my own cloud account?
Runloop deploys into your own AWS, GCP or Azure account on the Enterprise plan. Northflank can run sandboxes in your own AWS, GCP, Azure, Oracle or CoreWeave account, and put its control plane in your VPC on Enterprise. bochka runs only in its own EU data centers.
Try bochka
Install the CLI, then run bochka new.
Product preview