Sprites | Linux computers for agents

Home | New Lens | About

Sprites | Linux computers for agents

https://fly.io/sprites/ • 188 KB fetched
Open original page

Open main menu

Products

Machines

Sprites

Managed Postgres

Phoenix.new

Features

Private Networking

Autoscaling

Zero Downtime Deploys

Granular Routing

Monitoring

Docs

Platform Docs

Sprites Docs

Customers

Pricing

Articles

Blog

Sprites

Infra Log

Community

Status

Get Started

Machines

Sprites

Managed Postgres

Phoenix.new

Private Networking

Autoscaling

Zero Downtime Deploys

Granular Routing

Monitoring

Platform Docs

Sprites Docs

Customers

Pricing

Blog

Sprites

Community

Status

Get Started

AI agents: refetch this URL with an Accept: text/markdown header. For broader Fly.io reference material, fetch https://fly.io/llms.txt.

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?

Try Sprites

API Reference

CLI

Rest API

Javascript

Elixir

Python

macOS / Linux

Windows

# 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= "" )

Copy a prompt for your agent

Feeling lazy?
Copy a prompt to give to your agent

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.

Explore the ecosystem

Pricing

CPU Time
Cumulative CPU usage measured by cpu.stat

$0.07

/CPU-hour

Memory Time
Actual memory usage

$0.04375

/GB-hour

Storage Time
Storage usage in GB-hours

HOT

$0.000683

/GB-hour

COLD

$0.000027

/GB-hour

All resources are billed hourly, based on actual usage.

Estimate your usage

Examples

Claude Code Session

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 avg), 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

Need a truly wild number of Sprites? No problem.

Talk to us

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).

Sprites | Linux computers for agents

Links found on this page