Sprites | Linux computers for agents
Sandboxes aren't enough
Sprites are full Linux computers designed for agents. They're exactly as persistent and disposable as you want them to be, connect securely to external services via Connectors, and have full environment checkpointing and restore. Let's upgrade your agent's accommodations, shall we?
Install the Sprites CLI
curl https://sprites.dev/install.sh | bash
iwr https://sprites.dev/install.ps1 -useb | iex
Log in
sprite login
Create a new sprite
sprite create my-sprite
Run a command in it
sprite exec -s my-sprite -- ls -la
Connect to the console
sprite console -s my-sprite
# Create a new sprite
curl -X PUT https://api.sprites.dev/v1/sprites/my-sprite \
-H "Authorization: Bearer $SPRITES_TOKEN"
# Execute a command
curl -X POST https://api.sprites.dev/v1/sprites/my-sprite/exec \
-H "Authorization: Bearer $SPRITES_TOKEN" \
-d '{"command": "echo hello"}'
import { SpritesClient } from '@fly/sprites';
const client = new SpritesClient(process.env.SPRITES_TOKEN!);
// Get a Sprite reference
const sprite = client.sprite('my-sprite');
// Run a command!
const { stdout } = await sprite.exec('echo hello');
console.log(stdout);
import "github.com/superfly/sprites-go"
client := sprites.New("your-auth-token")
// Get a sprite handle
sprite := client.Sprite("my-sprite")
// Run a command - just like exec.Command!
cmd := sprite.Command("echo", "hello", "world")
output, err := cmd.Output()
if err != nil {
log.Fatal(err)
}
fmt.Printf("Output: %s", output)
# Add to mix.exs
{:sprites, github: "superfly/sprites-ex"}
# Create a sprite
client = Sprites.new(System.get_env("SPRITE_TOKEN"))
Sprites.create(client, System.get_env("SPRITE_NAME"))
# Run Python
sprite = Sprites.sprite(client, System.get_env("SPRITE_NAME"))
{output, _} = Sprites.cmd(sprite, "python", ["-c", "print(2+2)"])
IO.write(output)
# Install: pip install sprites-py
import os
from sprites import SpritesClient
# Create a sprite
client = SpritesClient(os.environ["SPRITE_TOKEN"])
client.create_sprite(os.environ["SPRITE_NAME"])
# Run Python
sprite = client.sprite(os.environ["SPRITE_NAME"])
output = sprite.command("python", "-c", "print(2+2)").output()
print(output.decode(), end="")
How Sprites work
A full Linux computer that keeps its disk, snapshots in a second, answers on its own URL, and reaches the outside world without holding a secret.
- Persistence
A real disk that survives sleep. Install once and it is there every run. - Checkpoints
Snapshot the whole filesystem in about a second. Restore when something goes wrong. - Sprite URLs
Every Sprite has its own HTTPS URL, and a request wakes it. - Connectors
Reach GitHub, OpenRouter, Slack, or any API without the credential ever entering the Sprite.
Persistence
- Tiered storage Reads and writes hit a fast local cache, and your data lives durably in object storage behind it. That's what lets a Sprite sleep, move between machines, and come back with its filesystem intact.
- Same disk for every run
Your files, installs, and data are on the same paths every run; the environment comes back exactly as you left it. - Max compatibility
It's a normal POSIX filesystem, so anything that reads or writes to disk just works, no special API or SDK. - Room to work
The volume is 100 GB, and you're billed on the storage you actually use rather than a size you have to pick up front. No sizing or resizing a volume. - S3 Block Device
A newer storage backend, in early access. It presents an object storage bucket to the kernel as a real block device and runs ext4 on top, which is what makes checkpoints block-level snapshots instead of file copies. Opt in per organization. Request early access
Checkpoints
- Live checkpoints
Taking one doesn't interrupt the Sprite. It keeps running while the snapshot is captured underneath it. - Copy-On-Write
Runs copy-on-write, capturing only what changed, so a checkpoint is cheap to take and cheap to keep. - The whole disk, not the process
Captures your entire writable filesystem: every file, package, and on-disk database you've added on top of the base image. It's a snapshot of the disk, so restoring rewinds your files rather than resuming a paused process mid-instruction. - Automatic by default
You don't have to remember to take them. A Sprite checkpoints itself after a stretch of continuous work, when it goes idle, and on graceful shutdown, keeping a tiered history rather than every snapshot forever. - Quick restores
Restore to any checkpoint to roll the filesystem back to that exact point, and the restore survives a reboot partway through. - Manage them within the environment
Create, list, and restore checkpoints from inside the Sprite via the sprite-env CLI or the management API.
Sprite URLs
- URLs for external access
Every Sprite has its own independent URL, with TLS handled for you, for reaching services running inside it. - Activate sprite
An incoming request to a Sprite's URL wakes it automatically, so it's ready to serve even after it has paused. - Just listen on 8080
Bind your app to port 8080 and the proxy routes public traffic straight to it, no extra config. - Public access, if you want
Keep a URL private to your org, or flip it fully public to the internet with a single setting.
Connectors
- Reach external services by connection, not by key
Your agent calls out through a connector (a provider and a connection ID), and the connector makes the outbound call. The code running in the Sprite doesn't need the provider credential in hand to use it. - OpenRouter, Slack, GitHub
Connect the services an agent actually reaches for: models through OpenRouter, a Slack workspace to report into, a GitHub account to read and push code with. Authorize once and the connection is there for every run. - Any HTTP API, really
Nothing about connectors is specific to those. Point one at any HTTP API, including an internal service behind your own auth, and the agent calls it the same way it calls anything else. - Check a connection before you trust it
Every connection type can be tested from the control plane, so you find out a credential is wrong when you set it up rather than halfway through an agent run.
Works with your agent. Yes, that one too.
Official plugins for every serious coding agent, plus SDKs and native integrations.
[Claude Code](/content/sprites/ecosystem "Claude Code"/index.html)[Codex](/content/sprites/ecosystem "Codex"/index.html)[Cursor](/content/sprites/ecosystem "Cursor"/index.html)[Antigravity](/content/sprites/ecosystem "Antigravity"/index.html)[Grok Build](/content/sprites/ecosystem "Grok Build"/index.html)[Cortex Code](/content/sprites/ecosystem "Cortex Code"/index.html)[DeepSeek Harness](/content/sprites/ecosystem "DeepSeek Harness"/index.html)[OpenCode](/content/sprites/ecosystem "OpenCode"/index.html)[OpenClaw](/content/sprites/ecosystem "OpenClaw"/index.html)[π](/content/sprites/ecosystem "Pi"/index.html) [VS Code](/content/sprites/ecosystem "VS Code"/index.html) [Herdr](/content/sprites/ecosystem "Herdr"/index.html) [Any MCP client](/content/sprites/ecosystem "Any MCP client"/index.html) [Agent Plugins v1](/content/sprites/ecosystem "Agent Plugins v1"/index.html) [OpenClaw](/content/sprites/ecosystem "OpenClaw"/index.html) Hermes (Nous Research)
Pricing
| Resource | Price |
|---|---|
| CPU Time | $0.07 /CPU-hour |
| Memory Time | $0.04375 /GB-hour |
| Storage Time | HOT: $0.000683 /GB-hour |
| COLD: $0.000027 /GB-hour |
All resources are billed hourly, based on actual usage.
Examples
| Resource | Units Used | Cost |
|---|---|---|
| CPU | 2.4 CPU-hrs | $0.17 |
| Memory | 6 GB-hrs | $0.26 |
| Hot Storage | 5 GB × 4 hrs | $0.01 |
| Cold Storage | 10 GB × 4 hrs | $0.00 |
| Total | $0.44 |
| Resource | Units Used | Cost |
|---|---|---|
| CPU | 6 CPU-hrs | $0.42 |
| Memory | 30 GB-hrs | $1.31 |
| Hot Storage | 3 GB × 30 hrs | $0.06 |
| Cold Storage | 5 GB × 732 hrs | $0.10 |
| Total | $1.89 / month |
FAQ
What does Sprites actually charge for?
CPU, RAM, and hot storage, metered per hour of active use: CPU at $0.07/CPU-hour, RAM at $0.04375/GB-hour, and hot storage at $0.000683/GB-hour (≈ $0.50/GB-month). Nothing is charged per sprite. A sprite that exists but does nothing costs nothing beyond its storage.
When is a sprite billable?
Sprites have three states: running (billed), warm (not billed), and cold (not billed). Running → warm happens within seconds of the idle monitor seeing no activity. Warm → cold can take much longer, but that doesn't matter for cost, since warm isn't billed either. So if you're seeing compute charges, your sprites are genuinely active.
My sprites aren't going idle. What's keeping them awake?
Four things reset the idle timer: an in-flight HTTP/API request, output to a session or exec'd process's stdout (redirecting to a file or detaching tmux doesn't count), an open TCP connection, or an active task (
sprite-env tasks create, max 1 hour, renewable). More in the idle-detection docs.I'm on a plan. Why am I still seeing usage charges?
Plans bundle an allowance of CPU-hours, RAM GB-hours, and storage GB, not unlimited usage. Anything above the allowance bills at standard rates on top of the plan fee. Example: Hero ($100/mo) includes 1,200 CPU-hours, 4,800 RAM GB-hours, and 150 GB of storage; a real Hero account that used 1,554 CPU-hours and 28,386 RAM GB-hours in a month had a genuine overage.
What's the $30 trial credit, and why didn't my second org get one?
Each user can grant one $30 trial credit, and each org can receive at most one. So if you activate a second org yourself, you've already spent your grant and that org gets nothing. An org activated by a user who's never granted one still gets it.
Which plan will cost me least?
Compare your billable units against each plan's included hours; a bigger plan isn't automatically cheaper. One customer's usage was close to Mythic's 28,000 included RAM GB-hours, but at $2,000/mo the plan cost more than the overage it saved. RAM is almost always the line that dominates, so reducing per-sprite memory usually beats upgrading.
What concurrency limits come with my plan?
Limits are per-org and scale with the plan. Hero allows 100 concurrently running sprites and 100 warm sprites; cold sprites are unlimited, and higher tiers raise those ceilings. If you hit the ceiling you'll see
max sprites per org exceededon provision. That's a limit, not an extra charge; nothing bills for being blocked.
Sprite creation rate is also tiered: 10 sprites/minute on pay-as-you-go, rising with plan tier from 60/minute on Adventurer up to 240/minute on Mythic.
The usage meter in the Sprites dashboard doesn't match my invoice.
The invoice is authoritative. Bills are only finalized at month end, and we'll reconcile against the underlying billing data and credit any discrepancy before then.
Is bandwidth or egress billed for Sprites?
No. Sprites bandwidth isn't metered today. (Any egress lines on your invoice come from Machines, not Sprites.)
Will my Fly.io account credits pay for my Sprites plan?
No. Credits apply to Sprites usage only. The monthly subscription fee is billed separately and isn't covered.
Does my Sprites plan include support?
From Hero upward, yes. Hero, Champion, and Legend include Standard email support; Epic and Mythic include Premium. Pay-as-you-go and the plans below Hero (Adventurer, Veteran) have community support. You don't need to buy a separate support subscription on top. If you're paying for both, tell us and we'll sort it out.