# Fly.io alternatives for agent sandboxes: Sprites and Machines ranked by cost Runtime is the cheapest Fly.io alternative for agent sandboxes: 81% less than Sprites and 55% less than Machines per job. **Runtime runs the same Firecracker microVMs as Fly.io and bills only the CPU an agent uses.** 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $0.64 on Runtime, $3.31 on Fly Sprites and $1.44 on a Fly Machine: $267 a month saved against Sprites at 100,000 runs, or $80 against Machines. Rates checked 23 September 2026. ## Why do teams look beyond Fly.io? Fly.io offers two ways to run agent code, and each has its own reason to move. **From Fly Machines**, the general-purpose VMs: - **The whole size, every second.** A Machine bills its size for as long as it is started, busy or not. An agent that spends most of a minute waiting on a model pays for two idle vCPUs. - **The root disk is temporary.** Files outlive a Machine only on a volume, and suspend is a separate mechanism for keeping memory. - **Shared CPUs do not burst far.** A `shared-cpu-2x` with 4 GB costs about $0.50 for the example, but its vCPUs are guaranteed 6.25% of a core each, so a new one would not fit 20 CPU-seconds into the minute. **From Fly Sprites**, the sandboxes built for agents: - **Memory is the expensive part.** $0.04375 per GB-hour of memory in use is about six times Runtime's $0.0075 per reserved GiB-hour, and it makes up $2.92 of the $3.31 example. - **Memory is Fly's to manage.** A Sprite's memory is not a fixed figure to plan against, and it is dropped when the Sprite goes cold, at a time you do not choose. - **It stays awake after use.** A Sprite keeps running for about 30 seconds after its last activity unless you delete it. ## Which alternatives are cheapest? The job is the same on every row, at list rates: 1,000 runs of a 2 vCPU, 4 GiB sandbox for 60 seconds each, with 20 CPU-seconds of work in every run. Both Fly.io products appear, the Sprite eleventh and the Machine fourth. Working for each row is on [pricing](/docs/pricing#published-rate-comparison), and it leaves out plan fees, storage, network, free credits and negotiated deals. | # | 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 (one you are replacing) | 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) (one you are replacing) | 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, both Fly.io products and two other rivals. The Sprite is assumed to use all 4 GB for the whole minute; the Machine is a `performance-2x` with 4 GB in `iad`. ``` 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 Sprites CPU 1,000 × 20 s / 3,600 × $0.07 = $0.39 Memory 1,000 × 60 s / 3,600 × 4 × $0.04375 = $2.92 Total $3.31 Machines Size 1,000 × 60 s / 3,600 × $0.0861 = $1.44 Cloudflare CPU 1,000 × 20 s × $0.000020 = $0.40 Memory 1,000 × 60 s × 6 × $0.0000025 = $0.90 Disk 1,000 × 60 s × 12 × $0.00000007 = $0.05 Total $1.35 E2B CPU 1,000 × 60 s / 3,600 × 2 × $0.0504 = $1.68 Memory 1,000 × 60 s / 3,600 × 4 × $0.0162 = $1.08 Total $2.76 ``` When the work fills both CPUs, busy for the whole minute, the job is $1.33 on Runtime against $5.25 on Sprites, $1.44 on Machines, $3.35 on Cloudflare and $2.76 on E2B. For a month of 100,000 waiting runs the bill is $63.89 on Runtime, $330.56 on Sprites and $143.50 on Machines. A Sprite bills the memory it actually uses, so a job that uses 1 GB pays $1.12 there in total. ## What each alternative gives a Fly.io user ### 1. Runtime: a Sprite's billing model at lower rates Firecracker microVMs, like both Fly.io products. CPU is measured, as on a Sprite, but at $0.025 per vCPU-hour rather than $0.07, with a floor of a twentieth of a vCPU; memory is a size you set, at $0.0075 per reserved GiB-hour. A paused sandbox keeps its processes for the retention you choose, 1 to 365 days, and a new one returned its first Python result in 351 ms at the median on 24 September 2026 ([speed](/docs/speed)). ### 2. Northflank: below a Machine's price, busy or not $0.01667 per vCPU-hour and $0.00833 per GB-hour, allocated, puts this job at $1.11 either way. Sandboxes are services with deployment plans, in Northflank's regions or inside your own AWS, GCP or Azure account. ### 3. Cloudflare Sandbox: close to users everywhere Each container has its own VM and starts near users across Cloudflare's network, called from a Worker on the Workers Paid plan. Active CPU is $0.072 per vCPU-hour with at least 3 GiB per vCPU, and a sandbox asleep after 10 idle minutes has lost its files unless they were in R2. ### 4. Morph: branching with memory $0.05 per MCU-hour, where one MCU is 1 vCPU, 4 GB of memory or 16 GB of disk. Infinibranch clones a running machine, memory included, into hundreds of replicas, where a Machine keeps memory only through suspend. ### 5. Vercel Sandbox: one more region than Machines Active CPU at $0.128 an hour and memory at $0.0212 per GB-hour in `iad1`, on Firecracker, in 19 regions. Stopping keeps the filesystem; processes restart. ### 6. CodeSandbox SDK: big fixed sizes A Nano VM of 2 cores and 4 GB is $0.1486 an hour, rounded up to the minute, and sizes reach 64 cores and 128 GB. ### 7. E2B: Firecracker with an open runtime Allocated at $0.0504 per vCPU-hour and $0.0162 per GiB-hour. Pro, at $150 a month, allows 24-hour sessions against Hobby's one, and the Apache-2.0 runtime can be self-hosted. ### 8. Daytona: GPUs and Windows The same rates as E2B, a container as the default sandbox, and GPU sandboxes and Windows machines in the US and the EU. ### 9. Blaxel: standby without asking Like a Sprite, a Blaxel sandbox goes to standby on its own, in its case when connections close, and resumes in about 25 ms. Active memory costs $0.0000115 per GB-second, CPU included. ### 10. Modal Sandboxes: GPUs and functions gVisor isolation, with CPU billed at $0.1419 per physical core-hour on the higher of request and use, alongside Modal's functions and scheduled jobs. ### 11. Runloop: public benchmarks Devboxes, a container inside a microVM, at $0.108 per CPU-hour and $0.0252 per GB-hour plus disk, set up for SWE-Bench and other public benchmarks. ## How to switch from Fly.io From Sprites, the calls map one to one. Sprites: ```js import { SpritesClient } from "@fly/sprites"; const client = new SpritesClient(process.env.SPRITE_TOKEN); const sprite = await client.createSprite("my-sprite"); const result = await sprite.execFile("python3", ["-c", "print(6 * 7)"]); console.log(result.stdout); await sprite.delete(); ``` Runtime: ```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 Sprite that pauses itself becomes a sandbox with `idlePauseSeconds`; the next request wakes it, usually in about half a second: ```python check from withruntime import Sandbox sbx = Sandbox.create(idle_pause_seconds=600) sbx.update(idle_pause_seconds=1800) # 0 turns it off sbx.stop() ``` From Machines, where you create one Machine per job through the Machines API, create a Runtime sandbox instead and stop it when the job ends. Or leave it to a coding agent: the instruction in [migration](/docs/migrate) has it swap the calls on a branch, test on the free trial and report the monthly difference. `npx withruntime switch --from fly`, run before you first add credit, has that first top-up matched up to $100. On the isolation both platforms share, see [Firecracker](/glossary/firecracker) and [microVM vs container](/compare/microvm-vs-container). ## Sources All rival rates were checked 23 September 2026, and the Fly.io pricing page was read again on 25 September 2026. - [Fly.io pricing](https://fly.io/pricing/) - [Northflank pricing](https://northflank.com/pricing) - [Together Code Sandbox](https://docs.together.ai/docs/together-code-sandbox) - [E2B pricing](https://e2b.dev/pricing) - [Runloop pricing](https://www.runloop.ai/pricing) - [Morph Cloud pricing](https://cloud.morph.so/web/pricing) - [Blaxel pricing](https://blaxel.ai/pricing) Facts on this page were checked on 25 September 2026. - [Cloudflare Containers pricing](https://developers.cloudflare.com/containers/pricing/) - [Vercel Sandbox pricing](https://vercel.com/docs/sandbox/pricing) - [Modal pricing](https://modal.com/pricing) - [Daytona pricing](https://www.daytona.io/pricing) - Runtime [pricing](/docs/pricing), [speed](/docs/speed) and the [Fly.io comparison](/docs/fly-alternative)