# Runtime vs Fly.io Runtime runs agent code in Firecracker microVMs, like Fly.io. It costs **73% less than Sprites** for an agent that mostly waits on a model. **The saving:** 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox cost **$0.64 on Runtime, $2.40 on Fly Sprites and $1.53 on a Fly Machine**. At 100,000 runs a month that is $63.89 against $240.14 on Sprites, **$176 a month saved**, or against $152.78 on Machines, $89 saved. Comparing more than two? [Fly.io alternatives for agent sandboxes](/compare/fly-io-alternatives) ranks the other providers by the cost of the same job. ## Where Runtime is better - **Lower rates.** Measured CPU costs $0.025 a vCPU-hour, 35% below Sprites' $0.0385. Reserved memory costs $0.0075 per GiB-hour, 66% below Sprites' $0.021875 per GB-hour of memory in use. - **Idle time bills only storage.** A Runtime sandbox pauses itself after 300 seconds with nothing happening in it. It keeps its memory and processes. While paused, it pays $0.08 per GB (10⁹ bytes) of saved state a month. - **An uptime promise that pays itself.** Paid accounts are promised 99% API uptime each month. A month below it returns 10% of that month's charges as credit. No claim is needed ([Uptime Promise](/legal/sla)). - **You pay for the CPU you use.** A Machine bills its whole size for every second it is started, busy or not. Runtime bills measured CPU, so time spent waiting on a model costs only a small floor, a twentieth of a vCPU. - **Memory survives a pause, for as long as you choose.** A paused Runtime sandbox keeps its processes while you have credit. A Sprite drops its memory when it goes cold, at a time you do not choose. A Machine's root disk is temporary. - **Sized to the job.** You set vCPUs and memory for each sandbox and are billed for no more. A Sprite's memory is managed by Fly and is not a fixed figure to plan against. - **Keys the sandbox never sees.** Store an API key once. The sandbox holds a placeholder. Runtime's proxy adds the value only to HTTPS requests to the hosts you name. A prompt injection has nothing to leak ([security](./security)). - **Your credit matched.** Credit you add within 30 days of signing up is matched, up to $1,000 in total ([welcome match](./pricing#welcome-match)). - **Your agent sets itself up.** It runs `npx withruntime sandboxes run -- ...`, shows you a link, and starts once you approve in the browser. No API key goes into a prompt or a config file. The [MCP server](./mcp) reuses the same connection. - **Safe retries.** Every write takes an idempotency key, and the SDKs retry with it automatically. A lost response never creates a second sandbox. **Also included:** a code interpreter, network allow and deny lists, custom images, volumes backed up daily, snapshots and forks with memory, private previews, a Linux desktop, metrics, webhooks, OpenTelemetry export, S3, R2 and GCS bucket mounts, MCP servers from a catalog, identity tokens for AWS and Google Cloud and free single sign-on. Paid accounts add custom domains, TCP ports, dedicated outbound addresses and WireGuard private networks. See [products](./products). ## At a glance This compares Runtime with Fly.io's two ways to run agent code: Sprites, its sandboxes for agents, and Machines, its general-purpose VMs. Fly.io's figures come from its public pricing and documentation, checked 25 October 2026, with Machines at the rates of its Ashburn (`iad`) region. | | Runtime | Fly Sprites | Fly Machines | | -------------- | ---------------------------------------------------------------- | --------------------------------------------------------- | -------------------------------------------------------------------------------------- | | Isolation | Firecracker microVM, own kernel | Firecracker microVM | Firecracker microVM | | CPU billing | $0.025 per vCPU-hour of measured CPU, with a small floor | $0.0385 per CPU-hour of measured CPU | By size while started; 2 performance vCPUs and 4 GB $0.0916704 an hour | | Memory billing | $0.0075 per reserved GiB-hour | $0.021875 per GB-hour of memory in use | Included in the size; more at $6 per GB a month | | Size | Up to 16 vCPUs and 64 GiB paid, chosen apart | Memory managed by Fly, 100 GB disk | Up to 16 performance vCPUs and 128 GB | | Plan fee | None; prepaid credit from $10 | None required; optional monthly plans | None; pay as you go | | Free start | 100 free hours of a 1 GB machine in the first 30 days, no card | $30 of trial credit | Not stated on the pricing page | | When idle | Pause keeps files and memory; kept while you have credit | Pauses itself; memory kept at first, the disk kept always | Root disk is temporary; volumes keep files; suspend, 2 GB or less | | Interfaces | API, CLI, MCP server, JavaScript, Python, Go, Ruby and Java SDKs | API, CLI, MCP server; JavaScript, Python, Go, Elixir SDKs | Machines API and flyctl | ## Cost for the same job Take 1,000 runs of a 2 vCPU, 4 GiB sandbox. Each run lasts 60 seconds and keeps the CPU busy for 20 CPU-seconds. This is an agent that spends most of its time waiting for a model. The Sprite is assumed to use all 4 GB for the whole minute. The Machine is a `performance-2x` with 4 GB. ``` 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.0385 = $0.21 Memory 1,000 × 90 s / 3,600 × 4 × $0.021875 = $2.19 Total $2.40 Machines Size 1,000 × 60 s / 3,600 × $0.0916704 = $1.53 ``` - **Saving:** 73% against Sprites ($1.76 per 1,000 runs) and 58% against Machines ($0.89 per 1,000 runs). - **Per month:** at 100,000 runs, $63.89 on Runtime against $240.14 on Sprites and $152.78 on Machines. - **Busier work:** with both CPUs busy for the whole minute, $1.33 on Runtime, $3.47 on Sprites and $1.53 on Machines. A Sprite bills the memory it actually uses. So a job that uses 1 GB pays $0.76 in total. Every figure here includes the 30 seconds or so a Sprite stays awake and billed after its run. A Machine's performance vCPUs are whole cores kept for it. Runtime's default shared CPU is not. Runtime's `cpu: "reserved"` keeps every vCPU for you too. A `shared-cpu-2x` Machine with 4 GB costs about $0.50 for the same runs. Its shared vCPUs are guaranteed 6.25% of a core each and start with a small burst allowance, so a new one would not fit 20 CPU-seconds into the minute. Storage, network, plan fees, taxes and free credits are left out of all three. On Runtime, inbound traffic is free. Each account's first 100 GiB out a month is free. After that, outbound traffic costs $0.02 per GB (10⁹ bytes). See [pricing](./pricing) for Runtime's terms. ## How to switch Give your coding agent the one instruction in [migration](./migrate). It replaces the Fly.io calls on a branch, tests them on the free usage, and tells you what you save each month. Your old code stays on the main branch until you merge. ### From 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(sum([125, 250, 375]))"]); console.log(result.stdout); await sprite.delete(); ``` Runtime: ```ts import { Sandbox } from "withruntime"; const box = await Sandbox.create(); try { await box.files.write("/workspace/invoice.py", "print(sum([125, 250, 375]))\n"); console.log((await box.exec(["python3", "/workspace/invoice.py"], { check: true })).stdout); } finally { await box.stop(); } ``` ### From Machines Code that calls the Machines API keeps its calls. Only the address changes. Run Runtime's Machines API server next to your code: ```sh no-run npx withruntime fly-api # answers on http://127.0.0.1:4280 as your Runtime login ``` Then point your client at it. Leave the rest of your code as it is: ```sh no-run export FLY_API_HOSTNAME=http://127.0.0.1:4280 # Fly's curl examples export FLY_FLAPS_BASE_URL=http://127.0.0.1:4280 # fly-go, Fly's Go client ``` On 18 October 2026 we ran the 22 curl examples on Fly's [Machines API pages](https://fly.io/docs/machines/api/machines-resource/) exactly as written, and fly-go 0.11.6 unchanged, against Runtime this way. A Node service can serve the calls itself. `machinesApi()` from `withruntime/fly` is a fetch handler. Your Fly token is never sent anywhere. flyctl and fly-go can also call the Runtime API directly, with no local server. Each Machine is then a Runtime Container with one copy. Set all three of flyctl's API addresses, so that no request is sent to Fly: ```sh no-run export FLY_FLAPS_BASE_URL=https://api.withruntime.com export FLY_API_BASE_URL=https://api.withruntime.com export FLY_UIEX_BASE_URL=https://api.withruntime.com export FLY_API_TOKEN=rtcloud_... # a Runtime API key fly machine run nginx:1.27 -a web --detach ``` `fly machine run`, `list`, `stop`, `start` and `destroy` work unchanged. Other HTTP clients use `https://api.withruntime.com/compat/fly` as their base URL. With `npx withruntime fly-api`, each Machine is a Runtime sandbox, started from its image and built once. `init`, `env`, `files`, `metadata`, leases and the restart policy work. The image's command is its main process. Suspend keeps the main process running. Stop keeps the disk. Fly resets a stopped Machine's root disk. Start runs the main process again. `services`, `mounts`, `checks` and regions other than `iad` are refused, naming Runtime's alternative. The full map is in [migration](./migrate). ## When Fly.io may fit better - **Regions.** Machines run in 17 regions. Runtime runs in one US region. - **Very cheap sleep.** A sleeping Sprite's disk costs $0.02 per GB-month, its cold storage rate ([Fly.io pricing](https://fly.io/pricing/), read 4 October 2026). Runtime's paused storage, which also keeps memory, costs $0.08 per GB (10⁹ bytes) a month. - **A wider platform today.** Machines, volumes and Managed Postgres sit in the same account. ## Sources Prices checked 25 October 2026; Machine suspend rechecked 26 October 2026. - [Fly.io pricing](https://fly.io/pricing/) for Machines and Sprites - [Sprites](https://fly.io/sprites/) and its pricing questions - [Sprites documentation](https://docs.sprites.dev/) and [lifecycle and persistence](https://docs.sprites.dev/concepts/lifecycle/) - [Machine CPU performance](https://fly.io/docs/machines/cpu-performance/) - [Machine suspend and resume](https://docs.fly.io/reference/suspend-resume/) - [Fly Volumes](https://fly.io/docs/volumes/overview/) - [Fly.io regions](https://fly.io/docs/reference/regions/) - Runtime [pricing](./pricing), [security](./security) and [products](./products)