Morph Cloud vs Northflank
Morph Cloud gives each agent a full VM that can pause with its memory, branch into many copies and wake on the next request. Northflank runs sandboxes in Kata microVMs as one part of a bigger cloud platform, with GPUs, regions around the world and the option to run in your own cloud.
The companies and products
Morph Cloud
Morph Cloud sells full virtual machines for AI agents that can be snapshotted, branched and restored with their memory, which it calls Infinibranch.
You get MorphVM instances as low-level building blocks and Devboxes as ready workspaces on top of them, with SSH, preview URLs and a tmux API for running coding agents you install yourself. Everything is billed in MCUs, where one MCU is 1 vCPU, 4 GB of RAM or 16 GB of disk for an hour. It is built for teams that fan agents out from one saved state, and it also sells managed GitHub Actions runners and a shared filesystem.
- Regions
- Not published
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. “16th cheapest of 345” means 15 of the other 344 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 | Morph Cloud: 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 A coding agent installs packages all over the machine; Northflank keeps only attached volumes across a pause, Morph keeps the machine if you pause it, and bochka saves the whole disk every minute. | 198th of 367, with limits $2,288 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 | 235th of 366, with limits $3,014 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 Morph Cloud ranks 16th here: a machine pauses with its memory, costs almost nothing while paused and wakes on the next request, which Northflank does not do. | 16th cheapest of 345 $154 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 Morph Cloud ranks 12th and bochka ranks 1st; Northflank's limit on how many sandboxes run at once is not published, so 300 at a time is not confirmed. | 12th cheapest of 361 $905 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 Morph's memory branching suits rollouts that all start from the same running state; Northflank snapshots files only, so each copy boots fresh. | 86th of 360, with limits $4,847 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 | 38th cheapest of 364 $675 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 Morph also sells managed GitHub Actions runners, Northflank runs builds and jobs on its platform, and bochka adds /dev/kvm for Android emulators and VM builds. | 39th cheapest of 377 $355 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 | 85th cheapest of 368 $116 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 Neither ships a desktop with a browser and a computer use API; bochka has a 60fps desktop with Chromium in every sandbox. | 182nd of 369, with limits $595 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 On both Morph and Northflank you install and run the browser yourself in your image; bochka has Chromium ready inside every sandbox. | 214th of 367, with limits $250 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 | 239th of 346, with limits $234 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 | 154th of 338, with limits $4,750 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 | 214th of 360, with limits $228 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 here with GPU sandboxes from L4 to H100 and up; Morph Cloud and bochka have no GPUs. | 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 | Morph Cloud | Northflank | bochka |
|---|---|---|---|
| Isolation | Full VM with its own kernel | Kata microVM with its own kernel for CPU; gVisor for GPU | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| What survives a stop | A paused VM keeps its disk, memory and processes; a plain stop deletes the instance | 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 |
| Snapshots and fork | Snapshot and branch a running VM with its memory, into many copies in under 250 ms | Filesystem snapshots of a running or stopping sandbox, opt-in; restore into a new one | Automatic disk snapshots; fork a running sandbox with its disk |
| Wake on request | Yes; a paused VM resumes on the next HTTP request, SSH or exec call | No; no idle auto-pause, a sandbox bills until you pause it | No; a stopped sandbox is started by API |
| Nested virtualization | Experimental | Not documented inside a sandbox | Yes, /dev/kvm for Android emulators and VMs |
| Guest systems | Linux, with experimental Windows and macOS (x86) | Linux | Linux |
| GPUs | No | L4, A100, H100, RTX PRO 6000 and more | No |
| Desktop and browser | Browser-based remote desktop; you install the browser and any computer use agent yourself | Headless; access by SDK, browser terminal or SSH | 60fps Linux desktop with Chromium and a computer use API |
| Coding agents | You install the agent, then drive it through a tmux API that sends keys and reads the screen | 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 | Responses Proxy for model APIs; other secrets are handed to the machine | Header injection for listed hosts in the network policy API; otherwise secrets are env vars or files | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Inbound access | Named HTTP services with optional API key auth; SSH through Morph's gateway; no raw TCP | 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 |
| Regions | Not published | US, Europe, Asia, Australia, South America and Africa; fixed per project | EU only (Germany, Finland, France), with zero data retention |
| Your own cloud | No; hosted only | Run in your own AWS, GCP, Azure and others, or the control plane in your VPC on Enterprise | No |
| Managed CI runners | GitHub Actions runners in three sizes, billed from the same MCU balance | Jobs and builds on the same platform as your services | No; run your own runner inside a sandbox |
Every feature Battleships tracks (43)
| Feature | Morph Cloud | Northflank | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | 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 | 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 | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | No | No | No |
| GPU | No | Yes | No |
| Windows | Yes | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | Yes | No |
| BYOC | No | 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 | Not published | Yes | No |
| SOC 2 | Not published | Yes | No |
| HIPAA | Not published | Yes | No |
| EU data residency | Not published | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Morph Cloud or Northflank: neither is in the hpc-sandbox-benchmarks run. 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. Morph says it restores a snapshot in under 250 ms, which measures start time, not CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Morph Cloud and Northflank 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 | Morph Cloud, 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 | $32 · Developer | $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 | $121 · Team | $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 | $1,459 · Scale | $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 | $325 · Scale | $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 | $869 · Scale | $688 · Developer Sandbox (free tier) · with limits | $2,000 · $2000/mo · with limits |
Morph Cloud: Morph bills MCUs at $0.05 each: per hour, a machine uses the largest of its vCPUs, its RAM in 4 GiB steps or its disk in 16 GiB steps. Team ($40 a month) and Scale ($250 a month) are prepaid MCU bundles at a discount, and a paused VM bills only its snapshot storage.
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. 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. On Morph, disk above 16 GiB per vCPU raises the bill, egress prices are not published, and the Developer pool of 64 vCPU holds only 16 machines at 4 vCPU. bochka's limit is the burst scenario: even the $2,000 plan queues starts above 90 a minute, so 1,000 short jobs do not all start together, while Morph Scale fits.
| Scenario | Morph Cloud | 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 Morph Cloud when
your agents branch from one running state with its memory, sleep between requests and wake on demand, or need experimental Windows and macOS guests.
- Branch a running machine with its memory. For agents that fan out from one running state: Morph copies a VM with its memory into many branches in under 250 ms.
- Pause and wake on request. For agents that sleep between requests: a paused VM bills only its snapshot and wakes on the next HTTP, SSH or exec call.
- Windows and macOS guests. For agents that must work in other systems: Morph lists experimental Windows and macOS (x86) guests next to Linux.
Use Northflank when
you need GPUs next to the agent, regions outside Europe and the US, or sandboxes inside your own cloud account 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 up, billed per hour.
- Regions around the world. For users far from Europe or the US: Northflank runs in Asia, Australia, South America and Africa too.
- Your own cloud, and one platform. For teams that must run in their own AWS, GCP or Azure account, or want apps, databases and sandboxes together.
Where bochka fits
Both Morph Cloud and Northflank hand you a machine and leave the agent, the desktop and the key handling to you. If your agents work on one machine for hours or days, need a browser or a desktop, or call APIs with real keys, bochka ships those inside every sandbox and keeps the whole disk between runs.
Coding agents you drive from outside
On Morph you install the agent and drive it by sending keys to tmux; on Northflank you reach a Harness through a terminal or SSH. Either way you build the control layer. bochka preinstalls seven agents with a prompt, steer and events API.
The whole disk comes back, and stops are free
A Northflank pause wipes everything outside attached volumes, and a plain stop on Morph deletes the instance unless you pause or snapshot it first. bochka saves the whole disk every minute and on stop, and a stopped sandbox costs nothing.
A desktop, a browser and keys kept outside
Northflank is headless and Morph has you install the browser and computer use loop yourself. bochka ships a 60fps desktop with Chromium, plus a credentials proxy for any HTTPS API, where Morph's proxy covers model APIs only.
Use bochka when your agents work on one machine for hours or days and should find it as they left it, with coding agents driven from your code, a desktop with Chromium, real keys kept outside and hosting on many ports in the EU. Compare it one to one: bochka vs Morph Cloud and bochka vs Northflank.
Questions people ask
Is Morph Cloud cheaper than Northflank?
It depends on the scenario. One coding agent on workdays is $32 a month on both; one agent that never stops is $121 on Morph against $108 on Northflank, though Morph drops if the VM pauses when idle. Sandboxes for your users are $325 on Morph against $361 on Northflank, and bochka is lower than both in four of the five scenarios.
Which is faster, Morph Cloud or Northflank?
Neither has a CPU result on the hpc-sandbox-benchmarks test, so there is no fair speed comparison. bochka did 26.69 runs per second on it at 4 vCPU / 8 GB. Morph's under 250 ms snapshot restore is a start time, not a CPU score.
Can Morph Cloud and Northflank run Docker?
Yes. Morph is a full VM with Docker in Docker and local Kubernetes, and Northflank gives each CPU sandbox its own kernel in a Kata microVM. bochka runs Docker and systemd too, and adds /dev/kvm for Android emulators and VMs.
Does a Northflank sandbox keep its files like a Morph VM?
Only files on attached volumes survive a Northflank pause; the rest of the disk and all processes reset. A paused Morph VM keeps its memory and processes, but a plain stop deletes it. bochka keeps the whole disk on every stop.
Which one has GPUs?
Northflank has GPU sandboxes under gVisor with cards from L4 to H100 and more. Morph Cloud and bochka run on CPUs only.
Can I run Claude Code or Codex on each?
Yes. On Morph you install the agent in a Devbox and drive it through a tmux API, and Northflank Harnesses start it for you behind a terminal or SSH. bochka preinstalls seven agents and adds an API to prompt, steer and follow them.
Try bochka
Install the CLI, then run bochka new.
Product preview