Runtime

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.

Estimated compute cost

81% less than Fly Sprites55% less than Fly Machines53% less than Cloudflare Sandbox77% less than E2B

2 vCPUs · 4 GiB · 60 s a run · 20 CPU-seconds busy

1,000

Compute only, at list rates checked 23 September 2026 (Fly.io pricing, Cloudflare Containers pricing, E2B pricing). Plan fees, network, taxes and free credits are left out. The worked example below shows the arithmetic.

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, 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.

TextRuntime     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.64Sprites     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.31Machines    Size   1,000 × 60 s / 3,600 × $0.0861       = $1.44Cloudflare  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.35E2B         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).

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:

JavaScriptimport { 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:

TypeScriptimport { 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:

Pythonfrom withruntime import Sandboxsbx = Sandbox.create(idle_pause_seconds=600)sbx.update(idle_pause_seconds=1800)  # 0 turns it offsbx.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 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 and 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.

Claim 50 hours free