# CodeSandbox SDK alternatives: agent sandboxes ranked by cost Runtime is the cheapest CodeSandbox SDK alternative, 74% less per job, billed by the second with no plan for concurrency. **Runtime runs the CodeSandbox SDK's workload for 74% less, in the same kind of Firecracker microVM.** 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $0.64 on Runtime and $2.48 on a CodeSandbox Nano VM, $184 a month saved at 100,000 runs, with no plan needed for more than 10 sandboxes at once. Rates checked 23 September 2026. ## Why do teams look beyond the CodeSandbox SDK? The CodeSandbox SDK, now documented by Together (CodeSandbox is a Together company), sells VMs in fixed sizes paid for in credits. The reasons to move are in how that bills: - **A size, not usage.** A Nano VM is 10 credits an hour at $0.01486 a credit for as long as it runs, whether the CPU is busy or the agent is waiting on a model. - **Rounded up to the minute.** A VM that runs for 3 minutes and 25 seconds is billed as 4. A 40-second tool call is billed as a minute. - **Fixed shapes.** You pick the size that covers your largest need. On Runtime you set vCPUs and memory for each sandbox and pay for no more. - **Concurrency costs a plan.** The free Build plan runs 10 VMs at once; more needs the Scale plan, $170 a month for 250. A paid Runtime account starts at 100 sandboxes at once with no plan fee, raised on request. ## Which alternatives are cheapest? Each provider gets the same job at its list rates: 1,000 runs of 60 seconds on a 2 vCPU, 4 GiB sandbox, busy for 20 CPU-seconds apiece. For CodeSandbox that means a Nano VM, 2 cores and 4 GB, which comes seventh. [Pricing](/docs/pricing#published-rate-comparison) lays out every row's arithmetic, with no plan fees, storage, network, free credits or negotiated prices in it. | # | Provider | Isolation | CPU billed on | 1,000 runs | | --- | ------------------------------------------------------ | ------------------------------------------ | --------------------------------------- | ---------: | | 1 | **Runtime** | Firecracker microVM, own kernel | Measured CPU, with a small floor | **$0.64** | | 2 | Northflank | 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 (the one you are replacing) | 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, CodeSandbox and the two other providers that bill a machine by its size: ``` 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 CodeSandbox Size 1,000 × 60 s / 3,600 × $0.1486 = $2.48 Machines Size 1,000 × 60 s / 3,600 × $0.0861 = $1.44 Morph Size 1,000 × 60 s / 3,600 × 2 MCU × $0.05 = $1.67 ``` A VM priced by size costs the same whatever the CPU does, so with both CPUs busy for the whole minute the figures are $1.33 on Runtime, $2.48 on CodeSandbox, $1.44 on Machines and $1.67 on Morph, and the waiting agent is where the saving is largest. At 100,000 runs a month, waiting, it is $63.89 on Runtime and $247.67 on CodeSandbox. Each run here is a whole minute, so CodeSandbox's rounding adds nothing. Make it 40 seconds and CodeSandbox still bills $2.48, while Runtime bills the 40 seconds. ## What each alternative means for a CodeSandbox user ### 1. Runtime: per-second billing, sized to the job A Firecracker microVM per sandbox, like a CodeSandbox VM, billed each second: $0.025 per vCPU-hour of measured CPU, with a twentieth of a vCPU as the floor, and $0.0075 per reserved GiB-hour. You pick vCPUs and memory separately. Snapshots and forks carry files, memory and running processes, and a named sandbox that pauses when idle works as a per-user workspace. ### 2. Northflank: allocation at low rates $0.01667 per vCPU-hour and $0.00833 per GB-hour, with each resource chosen on its own. A sandbox is a service with a deployment plan, deployable into your AWS, GCP or Azure account. ### 3. Cloudflare Sandbox: fine-grained active CPU Active CPU at $0.072 per vCPU-hour in 10 ms steps, far finer than a rounded-up minute, but with at least 3 GiB per vCPU. It is driven from a Worker on the Workers Paid plan, from $5 a month. ### 4. Fly Machines: the closest billing model Also a fixed size, but counted by the second instead of the minute. `performance-2x` with 4 GB costs $0.0861 an hour in `iad`, across 18 regions. ### 5. Morph: branching, plus shareable devboxes $0.05 per MCU-hour, one MCU covering 1 vCPU, 4 GB of memory or 16 GB of disk. Infinibranch forks a running machine into hundreds of replicas, and Morph Devboxes are shareable workspaces that hold memory while idle. ### 6. Vercel Sandbox: thousands at once $0.128 per active CPU-hour and $0.0212 per GB-hour in `iad1`, on Firecracker, with room for 10,000 sandboxes at once on Pro against CodeSandbox's 250 on Scale. ### 7. E2B: allocation billing on microVMs $0.0504 per vCPU-hour and $0.0162 per GiB-hour, by the second. Sessions reach 24 hours on Pro at $150 a month, 1 hour on Hobby; the runtime is Apache-2.0. ### 8. Daytona: GPUs and Windows machines E2B's rates, containers by default with VMs as their own class, GPU sandboxes and Windows machines. ### 9. Blaxel: memory-only pricing with standby $0.0000115 per GB-second while active, cores included. Standby starts when connections close, and a sandbox is back in about 25 ms. ### 10. Fly Sprites: a big disk that persists $0.07 per measured CPU-hour and $0.04375 per GB-hour of memory in use, with a 100 GB disk that stays with the Sprite. ### 11. Modal Sandboxes: GPU functions nearby gVisor at $0.1419 per physical core-hour, charged on request or use, whichever is larger. ### 12. Runloop: devboxes for benchmarks $0.108 per CPU-hour and $0.0252 per GB-hour, plus disk, with SWE-Bench and other public benchmarks. ## How to switch from the CodeSandbox SDK A one-off run is a create, an `exec` and a stop: ```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(); } ``` A CodeSandbox VM kept per user or per project becomes a named Runtime sandbox. `get_or_create` returns the sandbox with that name, woken if it is paused, or creates it: ```python check from withruntime import Sandbox dev = Sandbox.get_or_create("dev", idle_pause_seconds=900) dev.exec("git pull || true") ``` To have it done for you, give a coding agent the single instruction in [migration](/docs/migrate); it replaces the calls on a branch, tries them on the free trial and states the monthly saving. After some runs, `npx withruntime compare --from codesandbox` prices your own sandboxes at the CodeSandbox SDK's published rates. On workspaces, see [per-user dev environments](/use-cases/per-user-dev-environments) and [preview agent-built apps](/use-cases/preview-agent-built-apps). ## Sources Rival rates were checked 23 September 2026; the Together Code Sandbox page was read again on 25 September 2026. - [Together Code Sandbox](https://docs.together.ai/docs/together-code-sandbox) - [Fly.io pricing](https://fly.io/pricing/) - [Cloudflare Containers pricing](https://developers.cloudflare.com/containers/pricing/) Facts on this page were checked on 25 September 2026. - [E2B pricing](https://e2b.dev/pricing) - [Morph Cloud pricing](https://cloud.morph.so/web/pricing) - [Runloop pricing](https://www.runloop.ai/pricing) - [Modal pricing](https://modal.com/pricing) - [Vercel Sandbox pricing](https://vercel.com/docs/sandbox/pricing) - [Daytona pricing](https://www.daytona.io/pricing) - [Northflank pricing](https://northflank.com/pricing) - [Blaxel pricing](https://blaxel.ai/pricing) - Runtime [pricing](/docs/pricing) and the [CodeSandbox comparison](/docs/codesandbox-alternative)