# Fly Sprites vs Prime Sandboxes: measured or allocated

Sprites charge measured CPU and memory in use; Prime charges allocation while running. Memory decides it: $3.31 on Sprites, $1.52 on Prime for the benchmark.

**Runtime costs 81% less than Sprites and 58% less than Prime on that
benchmark:** 1,000 one-minute runs of a 2 vCPU, 4 GiB sandbox with 20
CPU-seconds of work each, which come to $3.31, $1.52 and $0.64.

## At a glance

|           | Fly Sprites                                 | Prime Sandboxes                                | Runtime                                                  |
| --------- | ------------------------------------------- | ---------------------------------------------- | -------------------------------------------------------- |
| Isolation | Firecracker microVM                         | Hardware-virtualized microVM, own guest kernel | Firecracker microVM, own kernel                          |
| CPU       | $0.07 per CPU-hour of measured CPU          | $0.02 per vCPU-hour while running              | $0.025 per vCPU-hour of measured CPU, with a small floor |
| Memory    | $0.04375 per GB-hour of memory in use       | $0.0125 per GiB-hour                           | $0.0075 per reserved GiB-hour                            |
| Lifetime  | Persistent, pauses itself; 100 GB disk kept | Default timeout 60 minutes, up to unlimited    | Leases extended, `persistent`, pauses up to 365 days     |
| Built for | A personal computer that stays              | RL rollouts by the thousand                    | Agents and evals                                         |

## One cheap meter each

Sprites' CPU line is cheap because it is measured; Prime's is cheap because
the rate is low. Memory is where Sprites lose, at $0.04375 per GB-hour against
Prime's $0.0125. Runtime measures CPU and charges less for memory than both.

## Cost for the same job

The benchmark, 60 seconds a run, with 4 GB in use on Sprites and a 5 GiB disk
on Prime:

```
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

Prime    CPU    1,000 × 60 s / 3,600 × 2 × $0.02              = $0.67
         Memory 1,000 × 60 s / 3,600 × 4 × $0.0125            = $0.83
         Disk   1,000 × 60 s / 3,600 × 5 × $0.0002            = $0.02
         Total                                                  $1.52

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
```

If both CPUs were busy for the whole minute, the job would cost $5.25 on Sprites, $1.52 on Prime and $1.33 on Runtime.

## Which one to pick

- **Fly Sprites** for one persistent machine per developer or agent, with a
  large disk.
- **Prime Sandboxes** for training runs with thousands of short environments.
- **Runtime** for the lowest price busy or waiting, and forks today.

See [Runtime vs Fly.io](/docs/fly-alternative) and
[Runtime vs Prime Sandboxes](/docs/prime-sandboxes-alternative).

## Sources

Fly Sprites rates checked 23 September 2026; Prime Sandboxes rates checked 25 September 2026.

- [Fly.io pricing](https://fly.io/pricing/), [Sprites](https://fly.io/sprites/)
- [Prime Sandboxes overview](https://docs.primeintellect.ai/sandboxes/overview), [Prime Sandboxes launch](https://www.primeintellect.ai/blog/sandboxes)
- Runtime [pricing](/docs/pricing)

Facts on this page were checked on 25 September 2026.