Key takeaways
- Sprites retain files across runs, but a cold wake loses process memory and checkpoints restore disk state rather than running processes.
- Connectors keep provider credentials in Fly.io's gateway, with separate policies for authorized Sprites and provider paths.
- Compute billing stops in warm and cold idle states; stored data and monthly plan fees can still cost money.
- New Sprites moved to Ubuntu 26.04 LTS in July, while some documentation still names the older base image.
FAQ
What is a Sprite?
A managed Linux environment on Fly.io with a Firecracker microVM, persistent filesystem, command execution, and checkpoint/restore APIs.
Are idle Sprites free?
Warm and cold idle states have no compute charge. Storage remains billable, and subscribed organizations still pay their monthly plan fee.
What does a checkpoint restore?
The writable filesystem overlay, including installed tools and on-disk data. Restore restarts the environment; it does not recover memory, open connections, or manually launched processes.
Can an agent use an API without receiving its secret?
Yes, through a configured Connector. Fly.io's gateway attaches the stored credential after checking access policy; permitted operations can still be misused, so provider scopes and endpoint rules matter.
Executive Summary
Sprites are Fly.io's managed Linux environments for agent development and code execution. Each has a Firecracker microVM, a persistent filesystem, and interfaces for running commands and restoring saved disk state. The product now also documents credential Connectors and controls for inbound and outbound network access.[1][2][3][4]
Persistence is the useful organizing idea, but it needs a precise definition. Files survive idle periods; process memory only survives a warm suspension, not a cold wake. Checkpoints save the writable filesystem and restore it by restarting the environment. They do not rewind external API actions or resume a process at its previous instruction.[5][2]
| Attribute | Verified September 15, 2026 |
|---|---|
| Provider | Fly.io; the former sprites.dev landing page redirects to Fly.io's Sprites page[6] |
| Deployment | Managed cloud Linux environments[7] |
| Base OS | Ubuntu 26.04 LTS for newly created Sprites, announced July 8, 2026[8] |
| Resources | 8 vCPUs, 100 GB filesystem ceiling, platform-managed memory that can grow under pressure[5] |
| GPU | Fly.io explicitly says Sprites do not offer attached GPUs[9] |
See the agent sandbox comparison for the category context.
Product Overview
Sprites support CLI and REST workflows, plus examples for JavaScript, Go, Python, and Elixir. The hosted MCP endpoint is https://sprites.dev/mcp; its OAuth flow selects an organization and access restrictions. Default MCP authorization limits newly created Sprite names and count, with broader access available through consent.[6][10]
| Capability | Operational meaning |
|---|---|
| Persistent workspace | Files, tools, repositories, and on-disk databases remain across wakes[5] |
| Checkpoints | Save and restore the writable overlay; automatic snapshots have retention pruning[2] |
| Services | Runtime-managed processes restart after a cold wake; manually started processes do not[5] |
| Tasks API | Renewable holds keep an active job from pausing; each hold lasts at most one hour[11] |
| HTTPS URL | Wakes a Sprite on request; private to the organization by default, with explicit public mode[4] |
| Connectors | Broker provider credentials outside the Sprite and restrict which Sprites and paths may use them[3] |
A documented CLI workflow is:
sprite create my-sprite
sprite exec -s my-sprite -- ls -la
sprite console -s my-sprite
These examples were reviewed, not executed against a paid account.[6]
Technical Architecture
Disk, memory, and storage changes
The January engineering article describes standard-image VM pools, object-backed storage, and a then-current JuiceFS-derived filesystem with SQLite metadata replicated through Litestream. It explicitly calls the design evolving. The current product page advertises a newer S3 Block Device backend in early access, enabled per organization. Treat the January implementation as historical context rather than a guarantee about every current Sprite.[12][6]
The lifecycle reference estimates warm resume at 100–500ms and cold wake at 1–2 seconds. These are vendor estimates, not measurements from this review. Cold wake discards memory; both pause types drop open TCP connections. A service definition can restart an application, while a renewable task hold keeps a current run active.[5][11]
The overview's broad statement about memory persistence is less precise than that lifecycle reference. Similarly, maintenance docs still name Ubuntu 25.10 despite the later 26.04 LTS announcement. For these conflicts, this profile follows the specific lifecycle documentation and dated OS announcement.[7][5][13][8]
Isolation and authorized access
A VM boundary separates execution environments. It does not stop code from using files or credentials deliberately granted to it, nor from making permitted API calls. Fly.io recommends separating the agent's trusted control process from the environment executing untrusted code.[1]
Outbound traffic is unrestricted by default. An optional externally managed DNS policy restricts allowed domains; under enforcement, raw IP access is constrained to allowed resolutions, private IPs are blocked, and tightened rules terminate newly forbidden connections. An empty rules list means no enforcement.[4]
Connectors are separate. They store the provider credential in the organization and authenticate gateway requests using Sprite identity. Access defaults to denial until policy grants it. Provider-path allow/block lists are configured through the API; an empty endpoint allowlist means no path restriction. Connectors currently buffer responses, so model streaming is not forwarded incrementally.[3]
Strengths
- Workspace setup can survive between tasks. Persistent disk avoids repeating every installation on each wake.[5]
- Environment changes have a recovery path. Checkpoints include installed packages, configuration, and on-disk data, and recent snapshots can be browsed without restoring.[2]
- Credentials need not live in the workload. Connectors support scoped gateway access, including customer-supplied API credentials.[3]
- Idle compute is metered differently from stored state. The warm and cold states stop compute charges while preserving the workspace.[6]
Cautions
- Retained disk is not retained execution. Design agents and services for restart, or maintain a task hold while work must continue. A forgotten renewing hold also keeps compute billable.[11]
- Checkpoint restore replaces current files. Save work before restoring; running sessions terminate, and automatic checkpoint history is pruned.[2]
- Network policy is opt-in. Review outbound rules, public URL settings, provider scopes, and connector endpoint access together.[4][3]
- Resource planning still matters. Storage does not autoscale beyond the documented 100 GB ceiling; memory is not a fixed published allocation to design around.[5]
- Persistent software needs upkeep. Existing Sprites and bundled agents may need separate upgrades; creating a new Sprite is not equivalent to maintaining an old one.[13][8]
- GPU workloads need another environment. The provider's current page explicitly excludes GPUs from Sprites.[9]
What Developers Say
Simon Willison's January 9, 2026 walkthrough tested the developer-sandbox workflow, persistent filesystem, port forwarding, and checkpoint commands. He also highlighted the API execution use case. This is a launch-era experience, not evidence for today's prices or image versions.[14]
In the January Hacker News thread, MrOrelliOReilly reported sparse docs and awkward setup; dtkav worried about idle status and billing. macNchz described production Fly.io applications built in 2024, while saying they had only started exploring the new Sprites API; that comment concerns the broader Fly.io platform, not production Sprites adoption.[15]
A more recent report from jnotts on September 11 describes repeated crashes while running two or three agent sessions. Support requested the Sprite name; the public thread reviewed here did not establish a root cause or resolution. This is one user's report, not a measured failure rate. This review did not operate a Sprite or independently test its reliability.[16]
Pricing & Licensing
Public USD usage rates checked September 15, 2026:[6]
| Resource | Rate |
|---|---|
| CPU | $0.07 per CPU-hour |
| Memory | $0.04375 per GB-hour |
| Hot storage | $0.000683 per GB-hour |
| Cold storage | $0.000027 per GB-hour |
Compute charges stop when warm or cold. Storage remains chargeable, and monthly plans are additional commitments with included allowances and standard-rate overages. “Free when idle” is therefore an incomplete description of the bill.[6]
| Example monthly plan | Active / warm limits | Included CPU-hours / RAM GB-hours / storage GB-months |
|---|---|---|
| Adventurer — $20 | 20 / 20 | 450 / 1,800 / 50 |
| Hero — $100 | 100 / 100 | 1,200 / 4,800 / 150 |
| Mythic — $2,000 | 2,000 / 2,000 | 7,200 / 28,000 / 900 |
The published plan table also lists intermediate tiers and custom Guild plans. These are capacity limits and allowances, not unlimited usage. Current FAQs confirm included support starts at Hero and Fly account credits cover usage rather than subscription fees.[17][6]
A $30 trial credit has one-grant-per-user and one-receipt-per-organization restrictions. Model-provider charges and managed connector credits are separate from sandbox resource charges.[6][3]
Competitive Positioning
Disclosure: Ry Walker is CEO of Tembo, which provides a platform for running coding agents in cloud environments.[18]
Sprites is a fit when a persistent project environment, restartable services, and direct execution APIs match the workload. Compare E2B, Daytona, and Modal against actual lifecycle, snapshot, credential, and billing requirements. Persistence alone is too broad a label to decide which environment fits a workload.
Tembo is a relevant alternative when the requirement includes selecting coding agents, connecting repositories and tickets, sharing sessions, and reviewing their output. Its published platform offers isolated VM sessions and managed or self-hosted deployment. Sprites supplies the execution environment and APIs; the choice is whether to assemble that workflow or use a platform that includes it. This is a comparison of product scope, not a claim that Tembo runs on Sprites.[18]
This is a managed Fly.io service. A CLI running on a laptop is a client for the cloud environment.[7][4]
Ideal Customer Profile
Best fit: agent builders and developers who want a durable workspace and can design for idle transitions, explicit access policy, and metered resource usage.
Poor fit: workloads requiring attached GPUs, storage beyond the documented ceiling, or guaranteed continuation of a manually started process after a cold wake.
Viability Assessment
New connector documentation, the July OS update, and current support activity show continued product work. They do not establish an adoption total, an independently tested durability guarantee, or a particular support response time. General Fly.io customer experience should not be treated as Sprites-specific proof.[3][8][16]
Bottom Line
Sprites offers a useful persistent execution environment with credential brokering and recovery controls. Its operating model is clearer when disk persistence, process lifetime, network authority, and billing are evaluated separately.
Recommended for: persistent agent workspaces and execution services designed around the documented lifecycle.
Not recommended for: assuming checkpoints save memory, idle means a zero total bill, or default network access is restricted.
Outlook: evaluate the new storage backend's rollout and verify workload reliability and monthly cost with a measured pilot.
Research by Ry Walker Research • methodology
Sources
- [1] Fly.io agent execution architecture
- [2] Sprites Checkpoints
- [3] Sprites Connectors
- [4] Sprites Networking
- [5] Sprites Lifecycle and Persistence
- [6] Sprites product and pricing page
- [7] Sprites Overview
- [8] Fly.io: Sprites now run Ubuntu 26.04 LTS
- [9] Fly.io Sprites comparison — GPU availability
- [10] Sprites Remote MCP Server
- [11] Keeping a Sprite Running
- [12] The Design & Implementation of Sprites
- [13] Sprite Maintenance
- [14] Simon Willison: Fly's new Sprites.dev
- [15] Hacker News: Design and Implementation of Sprites
- [16] Fly.io community: Sprite keeps dying, unresponsive, cannot restart
- [17] Fly.io: More Sprites Plans!
- [18] Tembo current product positioning