Northflank vs Claude Managed Agents
Northflank gives you sandboxes: microVMs with their own kernel that run any image, on a platform that also has GPUs, many regions and your own cloud. Claude Managed Agents gives you a finished agent: Claude works in a small container that Anthropic runs, and you talk to it through an events API.
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.
Claude Managed Agents
Claude Managed Agents is Anthropic's ready-made agent harness: Claude runs as an autonomous agent in a cloud sandbox that Anthropic manages, and you talk to it through an events API.
This is an agent platform, not a sandbox you rent. You define an agent (model, prompt, tools, MCP servers, skills) and an environment, then start sessions, send messages as events and stream back what Claude does; the harness handles tool calls, prompt caching and compaction. Each session gets its own Ubuntu container, or runs its tools on a worker you host yourself. It is built for teams that want Claude doing long tasks without building their own agent loop or sandbox.
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 | Claude Managed Agents: 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 gets a microVM on Northflank but keeps only attached volumes across a pause, and a container of up to 8 GB of memory on Managed Agents; bochka keeps a full VM's whole disk. | 159th of 367, with limits $1,477 a month | 106th of 367, with limits $964 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Managed Agents lets an idle session sleep for free and wake on the next message, but its sandbox state lasts only 30 days; Northflank has no idle auto-pause, so it bills until you pause it. | 173rd of 366, with limits $1,365 a month | 219th of 366, with limits $2,511 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 fit Northflank's small per-second plans well, and Managed Agents bills runtime only while the agent is working. | 84th of 345, with limits $115 a month | 163rd of 345, with limits $756 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 can give each user HTTPS ports on a code.run domain; a Managed Agents sandbox has no inbound ports, so users cannot open what it runs. | 89th of 361, with limits $815 a month | 231st of 361, with limits $823 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 | 252nd of 360, with limits $3,978 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 | 244th of 364, with limits $320 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 with its microVMs and custom images; Managed Agents is not built for CI, and bochka adds /dev/kvm for Android and VM builds. | 38th cheapest of 377 $352 a month | 227th of 377, with limits $96 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Northflank gives you SSH into the sandbox, Managed Agents has no SSH at all; bochka adds a whole disk that survives every stop. | 151st of 368, with limits $59 a month | 224th of 368, with limits $48 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 Both are headless: Managed Agents has headless Chromium with Playwright, Northflank has no browser at all; bochka streams a 60fps Linux desktop. | 151st of 369, with limits $371 a month | 127th of 369, with limits $288 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 | 126th of 367, with limits $288 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 | 127th of 346, with limits $390 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 | 155th of 338, with limits $4,798 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 | 179th of 360, with limits $160 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 has GPU sandboxes from L4 to H100 and up; Managed Agents and bochka are 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 | Claude Managed Agents | bochka |
|---|---|---|---|
| What it is | A developer platform with sandboxes as one workload type, next to services, jobs, databases and GPUs | A hosted Claude agent: Anthropic's harness runs Claude in a sandbox and you send it events | A sandbox platform: each agent gets its own full Linux VM, with coding agents built in |
| Isolation | Kata microVM with its own kernel for CPU; gVisor for GPU | Isolated Linux container per session | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | Plans from 0.1 vCPU up to 20 vCPU / 40 GB, more on request; a resize restarts the sandbox | Up to 8 GB memory and 10 GB disk; vCPU not published; not configurable | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Docker and /dev/kvm | Docker inside, since each sandbox has its own kernel; /dev/kvm not documented | Docker listed as limited availability; /dev/kvm not documented | Root, Docker, systemd and /dev/kvm for Android emulators and VMs |
| What survives a stop | Only attached volumes, which bill while paused; the rest of the disk and all processes reset | Sandbox is checkpointed when a session goes idle; state is kept only 30 days after the sandbox is created | The whole disk, saved every minute and on stop, for as long as you keep the sandbox; stops are free |
| Snapshots and fork | Filesystem snapshots of a running or stopping sandbox, opt-in; restore into a new one | No fork or clone of a session or sandbox | Automatic disk snapshots; fork a running sandbox |
| Idle behavior | No idle auto-pause; a sandbox bills its plan until you pause it | An idle session is not billed and resumes on the next message | A stopped sandbox costs nothing and keeps its disk; it is started again by API |
| Inbound access | HTTPS ports on a code.run domain, private by default; SSH; public TCP and UDP need a load balancer | No inbound ports or SSH; reached only through the sessions and events API | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; SSH |
| Browser and desktop | Headless; no browser product | Headless Chromium with Playwright; no desktop or computer-use tool | 60fps Linux desktop with Chromium and computer use built in |
| Agents | Harnesses start Claude Code, Codex, Cursor, OpenCode or Pi; you reach them by terminal or SSH | Anthropic's harness with Claude models only, with SSE events, steering, memory stores and webhooks | Claude Code, Codex and five more preinstalled, driven from outside 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 | Vault secrets live in the sandbox as placeholders and are swapped in at egress, per host | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| GPUs | L4, A100, H100, RTX PRO 6000 and more | No | No |
| Where it runs | US, Canada, Brazil, UK, EU, Switzerland, Asia, Australia and South Africa; or your own cloud | US workspace geo only; tools can run on your own workers | EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Northflank | Claude Managed Agents | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | 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 | Yes | Yes |
| Idle auto-stop | No | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | Yes | No | 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 | Yes | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | Yes | No | No |
| Self-hosting | Yes | Yes | No |
| BYOC | Yes | Yes | 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 | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | No | Yes |
Performance
There is no comparable CPU measurement for either one: neither Northflank Sandboxes nor Claude Managed Agents has a result on the hpc-sandbox-benchmarks test, and Anthropic does not publish how many vCPUs a sandbox gets. 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 Claude Managed Agents 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 | Claude Managed Agents, 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 | $13 · Claude API (pay-as-you-go, usage tiers) · with limits | $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 | $53 · Claude API (pay-as-you-go, usage tiers) · 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 | $634 · Claude API (pay-as-you-go, usage tiers) · 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 | $361 · Developer Sandbox (free tier) · with limits | $360 · Claude API (pay-as-you-go, usage tiers) · 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 | $796 · Claude API (pay-as-you-go, usage tiers) · 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.
Claude Managed Agents: Managed Agents bills model tokens at API rates plus a flat session runtime fee, measured only while the session is running, including time spent waiting on the model. The tables show runtime only; tokens come on top and usually cost more.
Claude Managed Agents: 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 pause: only attached volumes keep their files, so packages installed anywhere else reset, and how many sandboxes can run at once is not published. Managed Agents is a different kind of product, an agent platform, with a sandbox size that is not published and Docker not confirmed, so no scenario counts as a clean fit for it. Neither confirms 300 or 1,000 machines at once. bochka fits the first four scenarios, but at 1,000 short jobs at once its $2,000 plan queues starts above 90 a minute.
| Scenario | Northflank | Claude Managed Agents | 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 need a plain sandbox that runs any image, GPUs next to the agent, regions outside Europe, or sandboxes inside your own cloud account.
- Run any code, on any size. For teams that want a plain sandbox: any image in a microVM, from 0.1 vCPU up to 20 vCPU / 40 GB.
- GPUs and regions. For agents that need a GPU or users far from the US: L4 to H100 cards and regions on most continents.
- Your own cloud, one platform. For teams that must run in their own AWS, GCP or Azure account, next to their services and databases.
Use Claude Managed Agents when
you want Claude itself to do long, mostly text and code tasks with no harness to build, idle time that costs nothing, and the option to run tools on your own workers.
- No agent loop to build. For teams that want Claude doing long tasks, with the harness, caching, compaction, memory and webhooks ready to use.
- Idle sessions sleep for free. For agents that wait a long time between messages: runtime is billed only while working, and the next message wakes them.
- Tools on your own workers. For teams with strict network rules: limit sandboxes to listed hosts, or run every tool call on your own machines.
Where bochka fits
If you are comparing these two because you want agents working on a real machine, bochka sits between them. It gives each agent a full VM like a sandbox platform, and ships the agents inside it so you drive them from your code like a hosted agent. It also keeps the whole disk and adds a desktop, which neither of them has.
The whole machine comes back
A Northflank pause wipes everything outside attached volumes, and a Managed Agents sandbox expires 30 days after it is created. bochka saves the whole disk every minute, stops are free, and you can fork a running sandbox.
Agents you drive from outside, any of them
Northflank Harnesses start Claude Code or Codex, but you reach them by terminal or SSH. Managed Agents has an API but runs only Claude. bochka preinstalls seven agents behind one prompt, steer and events API.
A desktop, ports and a real kernel
Both are headless, and Managed Agents has no inbound ports, Docker only in limited availability and up to 8 GB of memory. bochka streams a 60fps desktop, serves HTTPS on up to 50 ports and exposes /dev/kvm for emulators.
Use bochka when your agents need a real machine that lasts: Docker, emulators, a desktop and browser, ports you can open, a whole disk kept between runs, and Claude Code, Codex or other agents driven from your code. Compare it one to one: bochka vs Northflank and bochka vs Claude Managed Agents.
Questions people ask
Is Northflank cheaper than Claude Managed Agents?
For runtime alone, Managed Agents costs less in most scenarios here: one agent that never stops is $53 a month against $108 on Northflank. But Managed Agents also bills model tokens on top, which usually cost more than the runtime. bochka runs that same agent for $26 a month.
Which is faster, Northflank or Claude Managed Agents?
Neither has a result on the CPU benchmark used here, and Anthropic does not publish the vCPU count of its sandboxes. Northflank lets you pick a plan up to 20 vCPU. bochka did 26.69 runs per second at 4 vCPU / 8 GB.
Can Northflank and Claude Managed Agents run Docker?
A Northflank sandbox has its own kernel, so Docker can run inside. On Managed Agents, Docker is listed as limited availability. bochka gives each sandbox root, Docker, systemd and /dev/kvm.
Can I run Claude Code on each?
Northflank Harnesses can start Claude Code, Codex, Cursor, OpenCode or Pi, and you connect by terminal or SSH. Managed Agents runs Anthropic's own harness with Claude models, not Claude Code. bochka preinstalls Claude Code, Codex and five other agents with an API to drive them.
Do their sandboxes keep files between runs?
Northflank keeps only files on attached volumes when you pause. Managed Agents checkpoints an idle session's sandbox, but keeps its state only 30 days after the sandbox is created. bochka keeps the whole disk until you delete the sandbox.
Does either one have GPUs?
Northflank has GPU sandboxes under gVisor with cards from L4 to H100 and more. Managed Agents and bochka run on CPUs only.
Try bochka
Install the CLI, then run bochka new.
Product preview