Modal vs Fly Sprites: pricing, isolation and limits

Modal bills requested CPU under gVisor; Fly Sprites bill CPU and memory as used, cheaper for idle agents, costlier for busy ones.

Runtime runs the same job for 84% less than Modal and 81% less than Sprites. 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost $3.97 on Modal, $3.31 on Sprites and $0.64 on Runtime. Runtime bills measured CPU like Sprites, at about a third of Sprites' rate, and memory at about a sixth, in a Firecracker microVM with its own kernel. Rates checked 23 September 2026.

At a glance

Modal bills a physical core, which is two vCPUs.

	Modal Sandboxes	Fly Sprites	Runtime
Isolation	gVisor, a user-space kernel that intercepts system calls	Firecracker microVM	Firecracker microVM, own kernel
CPU	$0.1419 per physical core-hour (2 vCPUs), request or use	$0.07 per CPU-hour of measured CPU	$0.025 per vCPU-hour of measured CPU, with a small floor
Memory	$0.0240 per GiB-hour, request or use	$0.04375 per GB-hour of memory in use	$0.0075 per reserved GiB-hour
Size	CPU and memory requested per sandbox	Memory managed by Fly; a 100 GB disk	vCPUs and memory chosen per sandbox
Plan fee	Starter $0 with $30 a month of compute; Team $250 a month	None required; optional monthly plans	None; prepaid credit from $10
Free start	$30 of compute a month on Starter	$30 of trial credit, once	50 sandbox hours, no card
When idle	Runs until its timeout, 5 minutes by default, 24 hours at most	Sleeps itself; memory kept at first, the disk kept always	Pause keeps files and memory; paid retention 1–365 days
Saving state	Filesystem snapshots	Checkpoints of the whole filesystem in about a second	Snapshots and forks with memory and running processes
Interfaces	Modal's SDK, with an App outside Modal	API, CLI, MCP server; JavaScript, Python, Go, Elixir SDKs	API, CLI, MCP server, JavaScript and Python SDKs

Which is cheaper, Modal or Sprites?

It depends on how busy the sandbox is, because the two count different things. Modal bills the larger of what a sandbox requested and what it used, so a 2 vCPU sandbox pays for its whole core while it waits on a model. Sprites bill CPU only while it works, at $0.07 a CPU-hour, and memory only while it is in use, at $0.04375 a GB-hour.

For 1,000 one-minute runs, 2 vCPU, 4 GiB	Modal	Sprites	Runtime
20 CPU-seconds each (an agent waiting)	$3.97	$3.31	$0.64
Both CPUs busy the whole time	$3.97	$5.25	$1.33

Memory decides most of the Sprites bill: 4 GB for a minute costs more there than on Modal. A Sprite that uses only 1 GB costs $1.12 for the same runs. Runtime bills measured CPU at $0.025 a vCPU-hour and reserved memory at $0.0075 a GiB-hour, so it is the cheapest of the three at both ends.

Cost for the same job

1,000 runs of a 2 vCPU, 4 GiB sandbox (one physical core on Modal; the Sprite is assumed to use all 4 GB for the whole minute). Each run lasts 60 seconds and keeps the CPU busy for 20 CPU-seconds.

TextModal    CPU    1,000 × 60 s × 1 core × $0.00003942 = $2.37         Memory 1,000 × 60 s × 4 × $0.00000667      = $1.60         Total                                         $3.97Sprites  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.31Runtime  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

At 100,000 runs a month that is $396.60 on Modal, $330.56 on Sprites and $63.89 on Runtime. With both CPUs busy for the whole minute, it is $1.33 on Runtime against $3.97 on Modal and $5.25 on Sprites, so Runtime is cheaper however busy the sandbox is. A Sprite stays awake for about 30 seconds after its last activity unless you delete it. Storage, network, plan fees and free credits are left out.

What happens when the agent goes quiet?

• Modal keeps the sandbox running, and billing its request, until its timeout or idle_timeout. Past 24 hours, state moves to a new sandbox through a filesystem snapshot.
• Sprites sleep by themselves. A Sprite keeps its memory at first, drops it when it goes cold at a time Fly chooses, and keeps its disk always. A sleeping Sprite's disk costs $0.02 per GB a month.
• Runtime pauses when you say, or after idlePauseSeconds, and keeps files, memory and running processes for the retention you set, 1 to 365 days. The next request wakes it.

Pythonfrom withruntime import Sandboxsbx = Sandbox.create(idle_pause_seconds=600)sbx.update(idle_pause_seconds=1800)  # 0 turns it offsbx.stop()

See how to pause and resume a sandbox.

Which one to pick

• Pick Modal for GPU sandboxes, or sandboxes beside Modal functions, web endpoints and scheduled jobs.
• Pick Sprites for a persistent Linux computer per agent with a 100 GB disk, very cheap sleep, and SDKs in Go and Elixir as well as JavaScript and Python.
• Pick Runtime for measured CPU at about a third of Sprites' rate, memory sized to the job at a sixth, and memory kept on pause for as long as you choose, in a microVM per sandbox.

Switch from either one

The calls map one to one. From Modal, modal.Sandbox.create(app=...) becomes Sandbox.create(), sb.exec(*args) becomes exec and Sandbox.from_name becomes Sandbox.getOrCreate(name). From Sprites, client.createSprite(name) becomes Sandbox.create() (or getOrCreate to find it by name) and sprite.execFile(cmd, args) becomes an argument array:

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();}

Or give your coding agent the one instruction in migration: it switches the project on a branch, tests it on the free trial and reports the monthly saving. npx withruntime switch --from modal (or --from fly) before your first top-up matches that top-up with credit, up to $100. The full side-by-sides are Runtime vs Modal and Runtime vs Fly.io.

Sources

Modal pricing, Modal Sandboxes and Sprites pages rechecked 25 September 2026; the rest checked 23 September 2026.

• Modal pricing, Modal resources and billing, Modal Sandboxes
• Fly.io pricing, Sprites, Sprites documentation, lifecycle and persistence
• Runtime pricing

Facts on this page were checked on 25 September 2026.