--- title: "Sprites: Linux computers for agents" description: "Sprites are full Linux computers designed for agents instead of people. As persistent or disposable as you want, with full environment checkpointing and restore." --- # Sprites: Linux computers for agents Sprites are full Linux computers designed for agents, not sandboxes. 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. A Sprite keeps its disk, snapshots in a second, answers on its own URL, sleeps when idle and wakes with everything where it was. Sign up: https://flyio-ui-ex-staging-2.fly.dev/app/sign-up?s=sprites — new organizations get $30 in trial credit. API reference: https://sprites.dev/api. Docs: https://docs.sprites.dev/ ## Quickstart Install the CLI (macOS and Linux, then Windows), log in, create a Sprite, run a command in it, connect to its console: ``` curl https://sprites.dev/install.sh | bash iwr https://sprites.dev/install.ps1 -useb | iex sprite login sprite create my-sprite sprite exec -s my-sprite -- ls -la sprite console -s my-sprite ``` ## API Every Sprite is a resource under `https://api.sprites.dev/v1/sprites/`, authenticated with a bearer token: ``` # 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"}' ``` ## SDKs JavaScript (`@fly/sprites`): ``` 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); ``` Go (`github.com/superfly/sprites-go`): ``` 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) ``` Python (`sprites-py`): ``` # 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="") ``` Elixir (`superfly/sprites-ex`): ``` # 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) ``` ## How Sprites work ### Persistence A real disk that survives sleep. Install once and it is there every run. - **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 at https://fly.io/early-access ### Checkpoints Snapshot the whole filesystem in about a second. Restore when something goes wrong. - **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. - **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 Every Sprite has its own HTTPS URL, and a request wakes it. - **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 GitHub, OpenRouter, Slack or any API without the credential ever entering the Sprite. - **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 Official plugins for every serious coding agent, plus SDKs and native integrations. The ecosystem, by agent and language: https://flyio-ui-ex-staging-2.fly.dev/sprites/ecosystem ## Pricing All resources are billed hourly, based on actual usage. A Sprite is billable only while it's running; warm and cold Sprites are not billed for compute. | Resource | Measured as | Rate | | --- | --- | --- | | CPU time | Cumulative CPU usage measured by cpu.stat | $0.07 / CPU-hour | | Memory time | Actual memory usage | $0.04375 / GB-hour | | Hot storage | Bills while the Sprite is awake (≈ $0.50 / GB-month) | $0.000683 / GB-hour | | Cold storage | Bills for as long as you keep it (≈ $0.02 / GB-month) | $0.000027 / GB-hour | Two worked examples: - **Claude Code session.** A 4-hour coding session with bursts to 100% of 8 CPUs and 8 GB RAM, averaging 30% of 2 CPUs and 1.5 GB: 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.** - **Web app.** 30 hours of wake time per month (~5 concurrent users average), averaging 10% of 2 CPUs and 1 GB RAM: 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.** Estimate your own usage: https://flyio-ui-ex-staging-2.fly.dev/calculator/. Plans with included hours, every tier and what each includes: https://flyio-ui-ex-staging-2.fly.dev/pricing.md Need a truly wild number of Sprites? Talk to us: hello@fly.io ## 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: https://docs.sprites.dev/working-with-sprites/#idle-detection **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 exceeded` on 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 finalised 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. ## More - Documentation: https://docs.sprites.dev/ · API reference: https://sprites.dev/api - Setting up an agent-ready development environment on a Sprite: https://flyio-ui-ex-staging-2.fly.dev/sprites/agent-ready.md - Authenticating — the Sprites CLI, tokens, the MCP server: https://flyio-ui-ex-staging-2.fly.dev/auth.md - Release notes: https://flyio-ui-ex-staging-2.fly.dev/sprites/release-notes/ - Fly.io overview: https://flyio-ui-ex-staging-2.fly.dev/index.md · Fly Machines, for running what the agent builds: https://flyio-ui-ex-staging-2.fly.dev/machines.md - Status https://status.flyio.net/ · Community https://community.fly.io/ · Support https://fly.io/docs/about/support/