Northflank vs GitHub Codespaces
Northflank is a cloud platform where sandboxes are one workload you start from an SDK, with GPUs, many regions and your own cloud. GitHub Codespaces is a dev environment for a GitHub repository, opened in VS Code or the browser, that stops after 12 hours at most.
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.
GitHub Codespaces
GitHub Codespaces is GitHub's cloud development environment: a ready-to-code Linux machine for a repository, opened in the browser, VS Code or the GitHub CLI.
Codespaces is a different kind of product from bochka: a dev environment for people working on a GitHub repository, not a sandbox API for agents. Each codespace is a Docker container built from the repo's dev container config, running on its own newly built VM on Azure, with 2 to 32 cores. It is built for developers and teams who want every contributor to start from the same setup, with prebuilds, port forwarding and GitHub billing.
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 | GitHub Codespaces: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month On Northflank only attached volumes survive a pause, and on Codespaces the agent is stopped at 12 hours; bochka keeps the whole disk and runs until you stop it. | 159th of 367, with limits $1,477 a month | 274th of 367, with limits $4,618 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 fits neither well: Northflank resets everything outside volumes on a pause, and a codespace stops after 12 hours at most. | 173rd of 366, with limits $1,365 a month | 309th of 366, with limits $6,970 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 are where Northflank's small per-second plans fit best, while each codespace builds a dev container on a new VM first. | 84th of 345, with limits $115 a month | 288th of 345, with limits $619 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 Northflank is built to hand sandboxes to your own users from code, while codespaces are made for GitHub users on a repository; neither publishes how many can run at once. | 89th of 361, with limits $815 a month | 281st of 361, with limits $1,964 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 | 282nd of 360, with limits $9,489 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 | 295th of 364, with limits $1,519 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 is a full match for CI runners and Codespaces is not, since it has no fork or snapshot API; bochka adds /dev/kvm for Android emulators and free stops. | 38th cheapest of 377 $352 a month | 314th of 377, with limits $909 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Codespaces gives each developer a polished VS Code box but stops it after 12 hours, and Northflank keeps only volumes on a pause; bochka is a full VM that keeps running and keeps its disk. | 151st of 368, with limits $59 a month | 130th of 368, with limits $270 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 has a graphical desktop: Northflank sandboxes are headless and a codespace has an editor and a terminal, while bochka streams a 60fps desktop with Chromium. | 151st of 369, with limits $371 a month | 267th of 369, with limits $1,367 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 | 275th of 367, with limits $678 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 | 310th of 346, with limits $922 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 | 280th of 338, with limits $18,637 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 | 267th of 360, with limits $445 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; Codespaces lists no GPU machine types and bochka is 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 | GitHub Codespaces | bochka |
|---|---|---|---|
| Kind of product | Developer platform for services, jobs and databases, with sandboxes as one workload type | Cloud dev environment for a GitHub repository, opened in VS Code, the browser or the GitHub CLI | Sandbox API: full VMs you create, fork and drive from code |
| Isolation | Kata microVM with its own kernel for CPU; gVisor for GPU | A Docker container on its own newly built VM, with its own virtual network | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| How long it runs | No documented session cap; it bills until you pause it, with no idle auto-pause | Stops after 30 idle minutes by default (up to 240) and after 12 hours at most, even while in use | Runs until you stop it, with no session cap on paid plans; a stopped sandbox costs nothing |
| What survives a stop | Only attached volumes, which bill while paused; the rest of the disk and all processes reset | Saved files are kept and storage is billed; stopped codespaces are deleted after 30 days by default | The whole disk, saved every minute and on stop |
| Snapshots and fork | Filesystem snapshots of a running or stopping sandbox, opt-in; restore into a new one | No copy or snapshot endpoint; new codespaces start from a repo, branch, pull request or prebuild | Automatic disk snapshots; fork a running sandbox into copies |
| Docker and nested virtualization | Own kernel, so Docker runs inside; /dev/kvm not documented | Docker and sudo inside the dev container; /dev/kvm not documented | Docker, root, systemd and /dev/kvm on every machine |
| Desktop and browser | Headless; access by SDK, browser terminal or SSH | VS Code, JupyterLab and a terminal; no graphical desktop | 60fps Linux desktop, Chromium and computer use built in |
| Coding agents | Harnesses with Claude Code, Codex, Cursor, OpenCode or Pi, reached through a terminal or SSH | GitHub Copilot as a VS Code extension; other agents you install and run yourself | 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 copied into the codespace as environment variables | 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 URL per forwarded port, private, organization or public; no public IP | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | Network policies with allow lists by IP, CIDR or domain, documented for your own cluster | Open internet; GitHub says there is no way to restrict it | Open internet, no provider-side allowlist |
| Starting point | Any container image, deployed from the SDK, CLI or dashboard | Dev container config in the repository, with prebuilds built by GitHub Actions | Named snapshots as templates, shareable by code; no Dockerfile builds |
| GPUs | L4, A100, H100, RTX PRO 6000 and more | No GPU machine types | No |
| Regions | US, Canada, Brazil, UK, EU, Switzerland, Asia, Australia and South Africa; your own cloud too | US East, US West, Europe West and Southeast Asia | EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Northflank | GitHub Codespaces | 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 | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | No | Yes | 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 | No | 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 | No | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | Yes | No | 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 | Yes | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for either Northflank Sandboxes or GitHub Codespaces: neither has a result on the hpc-sandbox-benchmarks test. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's run of 2026-09-29, 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 GitHub Codespaces 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 | GitHub Codespaces, 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 | $51 · Personal account: GitHub Free | $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 | $270 · Personal account: GitHub Free · 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 | $3,019 · Personal account: GitHub Free | $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 | $850 · Personal account: GitHub Free · 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,889 · Personal account: GitHub Free · 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.
GitHub Codespaces: Codespaces bills $0.09 per core-hour while a codespace is active, plus $0.07 per GB-month for storage while it exists, stopped too. There is no 4-core machine with 8 GB, so 4 vCPU / 8 GB jobs are priced on the 4-core 16 GB machine, and only personal accounts get a free monthly quota.
GitHub Codespaces: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. 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. On Codespaces it is the 12-hour cap, so the always-on scenario needs a restart script and running processes end at each stop; GitHub also does not publish how many codespaces can run at once, so 300 user sandboxes or 1,000 jobs at a time are not confirmed on either. bochka's limit is in the burst scenario: even the $2,000 plan queues starts above 90 a minute.
| Scenario | Northflank | GitHub Codespaces | 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
your code starts sandboxes for users or agents and you need GPUs, regions outside Europe, or the sandboxes inside your own cloud next to the rest of your apps.
- GPU sandboxes. For agents that train or run models: Northflank has GPU sandboxes from L4 to H100, and Codespaces has none.
- Sandboxes you drive from code, with no 12-hour stop. For products that start many sandboxes: Northflank has an SDK and no documented session cap, while a codespace stops at 12 hours.
- Many regions and your own cloud. For teams far from Europe or tied to their own AWS, GCP or Azure account: Northflank runs in both.
Use GitHub Codespaces when
your developers want a ready VS Code environment for a GitHub repository, opened from a branch or pull request, and their sessions fit in 12 hours.
- Built into GitHub. For teams that live on GitHub: open a ready codespace from any repo, branch or pull request, set up by its dev container.
- Files kept across a stop. For people who stop and resume work: a stopped codespace keeps its saved files, while Northflank keeps only attached volumes.
- Free hours for personal accounts. For occasional personal work: a GitHub Free account includes 120 core-hours and 15 GB-month of storage each month.
Where bochka fits
If what you are really running is coding or computer-use agents that work for hours or days, bochka sits between the two. It is a sandbox API like Northflank, but each machine keeps its whole disk like a codespace, runs with no session cap, and ships the agent, a desktop and a browser inside.
The machine comes back as the agent left it
A Northflank pause wipes everything outside attached volumes, which bill while paused, and a codespace stops at 12 hours and ends its processes. bochka keeps the whole disk, saves it every minute and forks running sandboxes.
/dev/kvm and a desktop on every machine
Neither documents /dev/kvm, so Android emulators and microVMs are out, and neither has a graphical desktop. On both you would build an image with a desktop, a browser and a way to stream it.
Agents driven from outside, keys kept outside
Northflank Harnesses and Codespaces both reach the agent through a terminal or SSH, and Codespaces puts API keys in environment variables. bochka gives you a prompt, steer and events API and a credentials proxy.
Use bochka when your agents work on one machine for hours or days and should find it as they left it: whole disk, Docker, /dev/kvm, a desktop and a browser, with the agent driven from your code. Compare it one to one: bochka vs Northflank and bochka vs GitHub Codespaces.
Questions people ask
Is Northflank cheaper than GitHub Codespaces?
In every scenario we priced, yes: one agent that never stops is $108 a month on Northflank against $270 on Codespaces, and 50 agents in parallel are $1,322 against $3,019. On bochka the same two come to $26 and $317 a month.
Which is faster, Northflank or GitHub Codespaces?
We cannot say: neither has a result on the CPU benchmark we use. bochka did 26.69 runs per second on that Node.js build-and-test test at 4 vCPU / 8 GB.
Can I run an AI agent 24/7 on Northflank or Codespaces?
On Northflank, yes: no session cap is documented and a sandbox runs until you pause it, though a pause resets everything outside volumes. A codespace stops after 12 hours at most, even while in use, so it needs a restart script. bochka runs until you stop it and keeps the whole disk.
Can Northflank and Codespaces run Docker?
Yes, both run Docker inside: Northflank sandboxes have their own kernel, and a codespace has Docker and sudo in its dev container. Neither documents /dev/kvm, so Android emulators and microVMs are not a supported setup; every bochka machine has /dev/kvm.
Which keeps my files when it stops?
A stopped codespace keeps its saved files, and is deleted after 30 days by default. A paused Northflank sandbox keeps only attached volumes. bochka saves the whole disk every minute and on stop, and a stopped sandbox costs nothing.
Do Northflank or Codespaces have GPUs?
Northflank has GPU sandboxes with cards from L4 and A100 up to H100 and more. Codespaces lists no GPU machine types, and bochka runs on CPUs only.
Try bochka
Install the CLI, then run bochka new.
Product preview