Northflank vs Replit
Northflank is a cloud platform where your code starts sandboxes in microVMs, next to services, databases and GPUs. Replit is an AI app builder: you describe an app, Replit Agent writes it, and Replit hosts it.
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.
Replit
Replit is an AI app builder and hosting platform: you describe an app in chat, Replit Agent writes it, and Replit publishes it.
You work in a browser workspace where Replit Agent sets up the project, writes the code, tests it and fixes problems, with system packages managed by Nix. When the app is ready you publish it as an Autoscale, Static, Scheduled or Reserved VM deployment, with Postgres and object storage next to it. It is built for people and teams who want a working app, not for programs that need to create many machines by API, so this page compares the parts where the two overlap.
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 | Replit: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory starts many agents from code: Northflank can do that with its SDK but resets everything outside attached volumes, Replit drives only Replit Agent one app at a time, and boat keeps the whole disk. | 159th of 367, with limits $1,477 a month | 181st of 367, with limits $2,000 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 one machine needs its files to stay; on Replit that means a Reserved VM billed all month, on Northflank only volumes survive a pause. | 173rd of 366, with limits $1,365 a month | 202nd of 366, with limits $2,033 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 best of the three, and Northflank ranks 84th here against Replit at 228th. | 84th of 345, with limits $115 a month | 228th of 345, with limits $146 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 a sandbox from its SDK; Replit would need one published app per user, and neither publishes how many can run at once. | 89th of 361, with limits $815 a month | 233rd of 361, with limits $825 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 | 258th of 360, with limits $4,226 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 | 265th of 364, with limits $685 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 fully fits CI runners and ranks 38th, Replit's Nix setups do not document Docker, and boat adds /dev/kvm with free stops. | 38th cheapest of 377 $352 a month | 275th of 377, with limits $425 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Replit workspace is a good place to code by hand but has no Docker or systemd; a Northflank sandbox keeps only its volumes when paused. | 151st of 368, with limits $59 a month | 165th of 368, with limits $109 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 Northflank sandboxes are headless and Replit's VNC pane shows a desktop to a person with no computer-use API; boat ships a 60fps desktop and Chromium. | 151st of 369, with limits $371 a month | 190th of 369, with limits $619 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 | 229th of 367, with limits $317 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 | 234th of 346, with limits $217 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 | 150th of 338, with limits $4,378 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 | 208th of 360, with limits $215 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 ranks 4th here; Replit and boat have no GPUs. | 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 | Replit | boat |
|---|---|---|---|
| Kind of product | Developer platform for services, jobs, databases and GPUs, with sandboxes as one workload type | AI app builder with browser workspaces and app hosting | Sandboxes you create, stop and fork by API, SDK or CLI |
| Isolation | Kata microVM with its own kernel for CPU sandboxes; gVisor for GPU sandboxes | Not documented; the security page says strong logical separation between users | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Creating machines from code | JavaScript and Python SDK, CLI and dashboard | MCP server tools to create, update and publish apps; no API to start many machines | API, SDK and CLI to create, stop, resume and fork many sandboxes |
| What survives a stop | Only attached volumes, which bill while paused; the rest of the disk and all processes reset | Workspace files and Agent checkpoints; published apps should not rely on their filesystem | The whole disk, saved every minute and on stop; a stopped sandbox costs nothing |
| Docker and nested virtualization | Docker can run on the sandbox's own kernel; /dev/kvm not documented | System packages come from Nix; the docs do not describe Docker, systemd or /dev/kvm | Docker, root, systemd and /dev/kvm on every machine |
| Coding agents | Harnesses with Claude Code, Codex, Cursor, OpenCode or Pi, reached through a terminal or SSH | Replit Agent, which you can also drive from an MCP client | 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 | Replit manages keys for OpenAI, Anthropic, Google and OpenRouter models; other keys are app secrets | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Desktop and computer use | Headless; access by SDK, browser terminal or SSH | VNC pane that streams a desktop to your browser; no computer-use API | 60fps Linux desktop, Chromium and computer use built in, embeddable stream |
| Inbound access | HTTPS ports on a code.run domain, private by default; public TCP and UDP need a load balancer | Published apps on HTTPS domains and custom domains; SSH into the workspace on paid plans | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH |
| Outbound rules | Network policies with allow lists by IP, CIDR or domain | No outbound allow list documented | Open internet, no provider-side allowlist |
| Hosting that sleeps when idle | No idle auto-pause; a sandbox bills until you pause it | Autoscale starts on the first request and costs nothing while idle | No wake on request; you stop and resume sandboxes yourself, and stops are free |
| GPUs | L4, A100, H100, RTX PRO 6000 and more, billed per hour | No | No |
| Regions | US, Canada, Brazil, UK, EU, Switzerland, Asia, Australia and South Africa; fixed per project | Published apps in North America, Europe, Asia, South America or Australia on Core and up; data mainly in the US | EU only: Germany, Finland, France |
| Your own cloud | Run on AWS, GCP, Azure and others, or the control plane in your VPC on Enterprise | No | No |
Every feature Battleships tracks (43)
| Feature | Northflank | Replit | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Not published | Yes |
| Systemd | Not published | No | Yes |
| Desktop GUI | No | Yes | 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 | Yes | Yes |
| Fork/clone | Yes | Yes | 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 | Yes | Yes |
| Raw TCP inbound | Yes | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | No | 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 | Not published | 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 | Yes | 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
Neither Northflank nor Replit has a result on the hpc-sandbox-benchmarks test, so we cannot say which of the two is faster. boat 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 Replit 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 | Replit, a month | boat, 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 | $122 · Pro $100 (annual) · 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 | $122 · Pro $100 (annual) · 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 | $1,330 · Pro $1,000 (annual) · 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 | $403 · Pro $250 (annual) · 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 | $825 · Pro $1,000 (annual) · 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.
Replit: Replit plans (Core $20, Pro from $100) turn into monthly credits for Agent work and hosting. A Reserved VM, the only kind that stays on, has a fixed monthly price per size and bills whether busy or idle; Autoscale charges only while it serves.
Replit: 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. Replit is marked as not a fit in every scenario because one Reserved VM is one published app that runs all month, and it does not document Docker inside. Neither publishes how many machines can run at once, so 300 sandboxes for your users or 1,000 jobs at once are not confirmed on either. On boat, the 1,000-job burst is queued above 90 starts a minute.
| Scenario | Northflank | Replit | boat |
|---|---|---|---|
| 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
your code needs to start sandboxes by SDK, with GPUs next to the agent, regions outside Europe, or everything inside your own cloud account.
- Sandboxes your code starts. For teams building agent products: Northflank starts microVM sandboxes from its SDK or CLI, where Replit has no API for many machines.
- GPU sandboxes. For agents that train or run models: Northflank has GPU sandboxes from L4 to H100 and up, and Replit has none.
- Your own cloud, many regions. For teams that must run in their own AWS, GCP or Azure account, or close to users in Africa or Brazil.
Use Replit when
you want Replit Agent to build a web app from a description and host it for you, with a database and hosting that sleeps when idle.
- An app built and hosted for you. For people who want a working app from a description: Replit Agent builds, tests and publishes it for you.
- Hosting that costs nothing when idle. For web apps with uneven traffic: Autoscale wakes on the first request and costs nothing while idle.
- Databases next to the app. For small apps that need data: Postgres and App Storage come built into each Replit app.
Where boat fits
If what you are really running is coding or computer-use agents, look at boat. Northflank gives you sandboxes but resets them outside volumes and leaves the agent control layer to you, and Replit is built to make apps, not to start machines for agents. boat gives each agent a full VM that keeps its disk, with agents, a desktop and keys handled from outside.
The whole machine comes back
A Northflank pause wipes everything outside attached volumes, which bill while paused, so agents reinstall tools. A Replit published app should not rely on its filesystem. boat saves the whole disk every minute, and stops are free.
Root, Docker, KVM and a desktop
Northflank sandboxes are headless with no documented /dev/kvm, so a browser agent needs a desktop image you build and stream. Replit uses Nix packages with no documented Docker or systemd, and its VNC pane has no computer-use API.
Agents driven from outside
Northflank Harnesses start the agent, but you reach it through a terminal or SSH, so you build the control layer. Replit's MCP server drives only Replit Agent. boat has a prompt, steer and events API, plus a credentials proxy for any HTTPS API.
Use boat 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, with the agent driven from your code. Compare it one to one: boat vs Northflank and boat vs Replit.
Questions people ask
Is Northflank cheaper than Replit?
In all five scenarios we priced, yes, though neither fits as is. One agent that never stops is $108 a month on Northflank against $122 on Replit, and 1,000 short jobs at once come to $688 on Northflank against $825 on Replit. On boat that always-on agent is $26 a month.
Which is faster, Northflank or Replit?
We cannot say: neither has a result on the public CPU benchmark we use. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB on it.
Can Northflank or Replit run Docker?
A Northflank CPU sandbox has its own kernel in a Kata microVM, so Docker can run inside. Replit sets up environments with Nix packages and its docs do not describe Docker. boat has Docker, systemd and /dev/kvm on every machine.
Is Replit a sandbox for AI agents like Northflank?
Not in the usual sense. Replit is an app builder where Replit Agent writes and publishes apps, and there is no API to start many machines. Northflank and boat both let your code create sandboxes.
Do Northflank and Replit keep files between runs?
A paused Northflank sandbox keeps only its attached volumes. Replit keeps workspace files and Agent checkpoints, but published apps should not rely on their filesystem. boat keeps the whole disk on every stop.
Which has GPUs?
Northflank has GPU sandboxes with cards from L4 to H100 and more. Replit and boat run on CPUs only.
Try boat
Install the CLI, then run boat new.
7-day free trial