# Northflank alternatives: agent sandboxes ranked by cost Runtime is the cheapest Northflank alternative for agents that wait, 42% less per job, and a sandbox is one API call. **Runtime costs 42% less than Northflank for an agent that spends its time waiting on a model, and a sandbox is one call.** 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $0.64 on Runtime and $1.11 on Northflank, $47 a month saved at 100,000 runs, because Runtime bills the CPU your code uses rather than every vCPU it holds. Rates checked 23 September 2026. ## Why do teams look beyond Northflank? Northflank runs services and databases, and its sandboxes are services too. Its allocated rates are the lowest in the table below, so the reasons to move are about what an agent actually does: - **Agents mostly wait.** Northflank bills the vCPUs and memory a sandbox holds for as long as it runs. An agent that spends 40 of every 60 seconds waiting for a model pays for idle CPUs. Runtime measures CPU, so waiting costs a floor of a twentieth of a vCPU. - **A sandbox is a service.** Northflank creates each sandbox as a service with a deployment plan. `Sandbox.create()` on Runtime returns a running sandbox, with no service, project or plan to set up. - **Memory costs more per unit.** $0.00833 per GB-hour on Northflank against $0.0075 per GiB-hour on Runtime, and a GiB is about 7% larger than a GB. - **State between steps.** A paused Runtime sandbox wakes with its processes still running, kept for 1 to 365 days, and a fork copies a running sandbox with its memory. ## Which alternatives are cheapest? Every provider runs the same job at list rates: 1,000 runs of a 2 vCPU, 4 GiB sandbox, 60 seconds apiece, with the code using 20 CPU-seconds of each run. Northflank's low allocated rates put it second, behind only Runtime. [Pricing](/docs/pricing#published-rate-comparison) spells out each row, with plan fees, storage, network, credits and negotiated prices left aside. | # | Provider | Isolation | CPU billed on | 1,000 runs | | --- | ---------------------------------------------- | ------------------------------------------ | --------------------------------------- | ---------: | | 1 | **Runtime** | Firecracker microVM, own kernel | Measured CPU, with a small floor | **$0.64** | | 2 | Northflank (the one you are replacing) | microVMs for CPU work, gVisor for GPU work | Allocated vCPUs | $1.11 | | 3 | Cloudflare Sandbox (2 vCPU, 6 GiB, 12 GB disk) | A container in its own VM | Active CPU | $1.35 | | 4 | Fly Machines, `performance-2x` with 4 GB | Firecracker microVM | The machine's size while started | $1.44 | | 5 | Morph, 2 MCUs | Full virtual machines | The machine's size in MCUs | $1.67 | | 6 | Vercel Sandbox, `iad1` (4 GB) | Firecracker microVM, own kernel | Active CPU | $2.12 | | 7 | CodeSandbox SDK, a Nano VM | Firecracker microVM | The VM's size, by the minute rounded up | $2.48 | | 8 | E2B | Firecracker microVM, own kernel | Allocated vCPUs | $2.76 | | 9 | Daytona | Containers by default; VM class separate | Allocated vCPUs | $2.76 | | 10 | Blaxel (4 GB) | Lightweight virtual machines | Included with memory, active time | $2.76 | | 11 | Fly Sprites (4 GB in use) | Firecracker microVM | Measured CPU | $3.31 | | 12 | Modal Sandboxes (1 physical core) | gVisor, a user-space kernel | Requested or used, whichever is higher | $3.97 | | 13 | Runloop, a `MEDIUM` devbox | microVM, with a container inside | Allocated CPUs while running | $5.33 | ## Cost for the same job The working for Runtime, Northflank, the next cheapest allocated VM (Fly Machines) and Modal, which, like Northflank, offers GPU sandboxes: ``` Runtime CPU 1,000 × 20 s / 3,600 × $0.025 = $0.14 Memory 1,000 × 60 s / 3,600 × 4 × $0.0075 = $0.50 Total $0.64 Northflank CPU 1,000 × 60 s / 3,600 × 2 × $0.01667 = $0.556 Memory 1,000 × 60 s / 3,600 × 4 × $0.00833 = $0.555 Total $1.11 Machines Size 1,000 × 60 s / 3,600 × $0.0861 = $1.44 Modal CPU 1,000 × 60 s × 1 core × $0.00003942 = $2.37 Memory 1,000 × 60 s × 4 × $0.00000667 = $1.60 Total $3.97 ``` The comparison turns on how busy the code is. Kept busy for the whole minute on both CPUs, the job costs $1.33 on Runtime, $1.11 on Northflank, $1.44 on Machines and $3.97 on Modal, the only case on this page where Northflank wins: its allocated vCPU rate is below Runtime's measured one, so work that never lets the CPUs rest is cheaper there. Runtime stays cheaper until a run keeps its two vCPUs busy for about 88 of their 120 CPU-seconds, 73% of the time. Waiting, 100,000 runs a month cost $63.89 on Runtime and $111.10 on Northflank. ## Where each alternative stands against Northflank ### 1. Runtime: billed on the CPU an agent uses A Firecracker microVM with its own kernel per sandbox, charged $0.025 per vCPU-hour of measured CPU, never under a twentieth of a vCPU, and $0.0075 per reserved GiB-hour. It is shaped around agents: sign-in is a browser approval rather than a pasted key, and read-only keys, a daily spending limit per key and `maxCostMicros` on each create keep one inside its budget. ### 2. Cloudflare Sandbox: active CPU in 10 ms steps $0.072 per vCPU-hour of active CPU, metered in 10 ms steps, with 3 GiB per vCPU at minimum. It runs from a Worker on the Workers Paid plan and starts near users across Cloudflare's network. ### 3. Fly Machines: the nearest billing model Like Northflank, a size billed while started. `performance-2x` with 4 GB is $0.0861 an hour in `iad`, its performance vCPUs being whole cores held for the Machine, in 18 regions. ### 4. Morph: live branching $0.05 per MCU-hour, where an MCU is 1 vCPU, 4 GB of memory or 16 GB of disk. Infinibranch forks a running machine, memory and all, into hundreds of replicas. ### 5. Vercel Sandbox: made for Vercel apps Firecracker at $0.128 per active CPU-hour and $0.0212 per GB-hour in `iad1`, in 19 regions and up to 10,000 sandboxes at once on Pro. ### 6. CodeSandbox SDK: sizes by credit The Nano VM (2 cores, 4 GB) is $0.1486 an hour in credits, rounded up to the minute, with VMs up to 64 cores and 128 GB. ### 7. E2B: self-hostable microVMs $0.0504 per vCPU-hour and $0.0162 per GiB-hour. Its runtime is Apache-2.0, so it can run on your own servers, much as Northflank can run in your cloud. ### 8. Daytona: GPUs and Windows The rates E2B charges, containers by default, GPU sandboxes and Windows machines in the US and the EU. ### 9. Blaxel: goes idle by itself $0.0000115 per GB-second of active time, CPU included. Standby begins when connections close, and a sandbox resumes in about 25 ms. ### 10. Fly Sprites: Fly.io's measured-CPU sandbox $0.07 per measured CPU-hour and $0.04375 per GB-hour of memory in use. A Sprite pauses itself and keeps a 100 GB disk. ### 11. Modal Sandboxes: gVisor with GPUs gVisor isolation, as on Northflank's GPU sandboxes, at $0.1419 per physical core-hour on whichever is higher of request and use, next to Modal's functions and scheduled jobs. ### 12. Runloop: devboxes in your cloud A container inside a microVM at $0.108 per CPU-hour and $0.0252 per GB-hour plus disk. Like Northflank it can deploy into your own cloud account. ## How to switch from Northflank There is no service or deployment plan to translate. A sandbox is created, used and stopped, in TypeScript or Python: ```ts import { Sandbox } from "withruntime"; const box = await Sandbox.create({ funding: "trial" }); try { console.log((await box.exec("python3 -c 'print(6 * 7)'", { check: true })).stdout); } finally { await box.stop(); } ``` ```python from withruntime import Sandbox with Sandbox.create(funding="trial") as box: print(box.exec("python3 -c 'print(6 * 7)'", check=True).stdout) ``` To see which side of the busy line your own work falls on, run it on Runtime for a few days, then price the same sandboxes at Northflank's published rates: ```bash no-run npx withruntime compare --from northflank ``` A coding agent can also run the whole move: paste the instruction from [migration](/docs/migrate), and it changes the project on a branch, tests it on the free trial and reports the monthly saving. For where measured CPU saves most, see [coding agent sandbox](/use-cases/coding-agent-sandbox) and [run untrusted LLM code](/use-cases/run-untrusted-llm-code). ## Sources Rival rates were checked 23 September 2026; Northflank's pricing page was read again on 25 September 2026. - [Northflank pricing](https://northflank.com/pricing) - [Daytona pricing](https://www.daytona.io/pricing) Facts on this page were checked on 25 September 2026. - [Together Code Sandbox](https://docs.together.ai/docs/together-code-sandbox) - [Vercel Sandbox pricing](https://vercel.com/docs/sandbox/pricing) - [E2B pricing](https://e2b.dev/pricing) - [Blaxel pricing](https://blaxel.ai/pricing) - [Morph Cloud pricing](https://cloud.morph.so/web/pricing) - [Runloop pricing](https://www.runloop.ai/pricing) - [Modal pricing](https://modal.com/pricing) - [Fly.io pricing](https://fly.io/pricing/) - [Cloudflare Containers pricing](https://developers.cloudflare.com/containers/pricing/) - Runtime [pricing](/docs/pricing) and the [Northflank comparison](/docs/northflank-alternative)