Daytona vs Sprites
Daytona starts each sandbox as a container you size yourself, and offers Linux VM, Windows, GPU and early-access macOS classes on top. Sprites, from Fly.io, gives every agent a fixed 8 vCPU Firecracker microVM that pauses when work stops and wakes on the next request.
The companies and products
Daytona
Daytona is a cloud for running AI-generated code: you create sandboxes from code through its API and SDKs.
By default a Daytona sandbox is a Linux container with its own namespaces and reserved vCPU, memory and disk. You can also pick a Linux VM class (pause, fork, memory snapshots, /dev/kvm), a Windows VM class, a GPU class with Nvidia and AMD cards, or macOS sandboxes in early access. It is built for teams that run agent code, code interpreters and evals through Python, TypeScript, Ruby, Go or Java SDKs.
Sprites
Sprites is Fly.io's product for agents: persistent Linux computers you create by API or CLI, which sleep when idle and wake on the next request.
Each Sprite is a Firecracker microVM with 8 vCPU, memory that scales from 2 GB to 16 GB as needed, and a 100 GB ext4 disk backed by object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled. It gets an HTTPS URL that wakes it, and it bills only for the CPU and memory it uses while awake. It is built for coding agents, dev environments and user code that sit idle most of the time.
- Isolation
- Firecracker microVM per Sprite
- Free start
- $30 trial credit per organization
Which use cases each one fits
For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “19th cheapest of 365” means 18 of the other 364 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.
| Use case and its workload | Daytona: price rank | Sprites: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Daytona fits with its Linux VM class for pause, fork and /dev/kvm. Sprites is a compromise: services run through its services API, not systemd, and it has one public HTTPS URL. boat has systemd, /dev/kvm and up to 50 URLs on every sandbox. | 19th cheapest of 365 $4,111 a month | 101st of 365, with limits $546 a month | 5th cheapest of 365 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Daytona keeps an assistant running until you stop it. A Sprite pauses about 30 seconds after work stops and drops open connections, so a long agent needs a Tasks API hold of up to an hour that you renew. boat runs until auto-stop, which you can turn off on a paid plan. | 31st cheapest of 361 $6,104 a month | 214th of 361, with limits $1,166 a month | 6th cheapest of 361 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Both suit short code runs: Daytona creates 300 to 600 sandboxes a minute by tier, and a Sprite sleeps right after a run and bills only the CPU and memory it used. boat's start limits make big bursts a compromise. | 31st cheapest of 336 $271 a month | 99th of 336, with limits $140 a month | 189th of 336, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month 300 sandboxes of 2 vCPU need 600 vCPU, more than Daytona's Tier 4 pool of 500, and Sprites does not confirm 300 running at once on pay as you go. On boat it fits two seats of the $100 plan. | 153rd of 349, with limits $2,000 a month | 61st of 349, with limits $428 a month | 3rd cheapest of 349 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 134th of 349, with limits $8,261 a month | 114th of 349, with limits $6,540 a month | 39th of 349, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 192nd of 359, with limits $2,000 a month | 130th of 359, with limits $545 a month | 10th cheapest of 359 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Sprites fits CI, while Daytona caps a sandbox at 4 vCPU / 8 GB by default. Android or VM image builds need /dev/kvm, which boat exposes and the Sprites docs do not mention. | 309th of 374, with limits $805 a month | 63rd cheapest of 374 $476 a month | 2nd cheapest of 374 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Sprites fits a dev box that sits idle: it sleeps and wakes on request. On Sprites you set up SSH yourself with openssh-server and the sprite proxy CLI. Daytona has SSH and bills a stopped disk. boat has SSH and systemd, and bills its full size while running. | 200th of 371, with limits $245 a month | 120th cheapest of 371 $27 a month | 19th cheapest of 371 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Daytona has a VNC desktop and a computer-use API on Linux and Windows. A Sprite has no desktop built in; you install a display server, a browser and a stream yourself. boat streams a 60 fps desktop with Chrome. | 29th cheapest of 367 $1,198 a month | 132nd of 367, with limits $136 a month | 7th cheapest of 367 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 114th of 356, with limits $598 a month | 236th of 356, with limits $122 a month | 7th cheapest of 356 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 42nd cheapest of 343 $404 a month | 279th of 343, with limits $206 a month | 6th cheapest of 343 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 203rd of 327, with limits $8,073 a month | 139th of 327, with limits $4,113 a month | 73rd of 327, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 18th cheapest of 351 $2,000 a month | 243rd of 351, with limits $223 a month | 3rd cheapest of 351 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Daytona fits: it rents Nvidia and AMD GPUs by the hour. Sprites and boat have no GPUs. | 19th cheapest of 102 $1,190 a month | Not ranked: misses a requirement | Not ranked: misses a requirement |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Not ranked: misses a requirement | Not ranked: misses a requirement | Not ranked: misses a requirement |
Key features
| Feature | Daytona | Sprites | boat |
|---|---|---|---|
| Isolation | Container with its own namespaces by default; Linux VM and Windows VM classes add a hardware virtualization boundary | Firecracker microVM with its own kernel | Every sandbox is a full VM with its own kernel, on hosts dedicated to boat; vCPUs are shared |
| CPU speed (V8 Web Tooling Benchmark, 4 vCPU / 8 GB, StarSling run of 3 October 2026) | 21.52 runs/s on the Linux VM class; the default container class has no result in this run | Not in the public benchmarks we use; a Sprite always has 8 vCPU | 28.06 runs/s, second of 15 (AMD Ryzen 9 9950X host); the run cannot separate it from Daytona's VM class (shared rank 2) |
| Machine size | You choose; up to 4 vCPU / 8 GB per container or Linux VM sandbox by default, higher on request | Fixed 8 vCPU and 100 GB disk; memory scales from 2 GB to 16 GB and bills on use | You choose: 2 to 16 vCPU and 4 to 32 GB; 16 vCPU needs the $100 plan; disk fixed per size (51 to 251 GB) |
| Docker, systemd and nested virtualization | Docker in all classes; /dev/kvm on Linux VM sandboxes once KVM is turned on for your organization | Root and Docker; services run through the Sprites services API, not systemd; no /dev/kvm in the docs | Docker, root, systemd and /dev/kvm on every sandbox |
| Idle behavior | Containers auto-stop after 15 idle minutes, VMs auto-pause after 60, and you can turn that off; the disk stays billed while stopped | Pauses about 30 seconds after activity stops; wakes on the next request in 100 to 500 ms with memory, or 1 to 2 s after a cold stop | Runs until auto-stop (1 hour by default, up to 30 days, or off on paid plans) and bills its full size, busy or idle; no compute charge while stopped |
| Pause and fork | Linux VM and Windows: pause, resume and fork with memory kept; containers: filesystem snapshots that new sandboxes start from | Memory kept while paused; filesystem checkpoints restore in place; no fork command in the CLI or API docs | Fork a running sandbox from its last 1-minute snapshot; resume reboots from disk (no memory snapshots) |
| Custom images | Docker images and declarative builds for containers; VM snapshots from an image | One managed Ubuntu image; you install on top of it and save that as a checkpoint | Saved snapshots (templates); you cannot boot your own Docker or OCI image |
| Reaching the sandbox | HTTPS preview URLs on any port, token-protected, signed or public; SSH; no public IP | One HTTPS URL to one HTTP port, private by default; other ports and SSH through the sprite proxy CLI | Up to 50 HTTPS URLs, token-gated by default; SSH; public IPv6; raw ports over IPv6, and over IPv4 only on sandboxes with their own IPv4 |
| Outbound internet | Tier 1 and 2 reach only registries, git hosts and AI APIs; open internet and allowlists from Tier 3 ($500 top-up) | Open internet, with an optional DNS-based domain allowlist set from outside | Open internet on every plan; no provider-side allowlist |
| Keeping keys out of the sandbox | Secrets proxy swaps placeholders in HTTPS request headers for allowed hosts | Connectors gateway holds the token for any HTTP API, with path allow and block lists | Optional AI credentials proxy, off by default, $1 a day plus $1 per 1,000 requests |
| Coding agents | You set it up: install the agent and run it through process exec; guides cover Claude Code, Codex, OpenCode and others | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | Seven harnesses installed (Claude Code, Codex, pi, OpenCode and more), with a prompt, steer and events API |
| Desktop and computer use | VNC desktop (xfce4) and a computer-use API with screen recording on Linux and Windows | No desktop or browser built in. You set it up: install a browser, a display server and a stream | 1920x1080, 60 fps desktop and Chrome, computer tools for agents, embeddable stream |
| GPUs, Windows and macOS | Nvidia and AMD GPUs by the hour; Windows VM sandboxes; macOS in early access | None | No GPU on any size; Linux only, Windows programs through Wine |
| Regions | US and EU, plus dedicated regions or your own machines | No region option when you create a Sprite | Germany, Finland and France; you cannot pick a region; no US or Asia region |
Every feature Battleships tracks (43)
| Feature | Daytona | Sprites | boat |
|---|---|---|---|
| Full VM (own kernel) | No documented way | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No documented way | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | No documented way | Yes |
| Desktop GUI | Yes | No documented way | Yes |
| Browser | Yes | No documented way | Yes |
| Computer-use API | Yes | No documented way | Yes |
| SSH | Yes | With your own setup | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | No documented way | Yes |
| Live fork (no pause) | No documented way | No documented way | Yes |
| Memory fork | Yes | No documented way | No documented way |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No documented way |
| Wake on request | No documented way | Yes | No documented way |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No documented way | No documented way | Yes |
| Public IPv4 | No documented way | No documented way | No documented way |
| Egress allowlist | Yes | Yes | No documented way |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No documented way | No documented way | Yes |
| MCP server | Yes | Yes | No documented way |
| GPU | Yes | No documented way | No documented way |
| Windows | Yes | No documented way | No documented way |
| Arm64 | No documented way | No documented way | No documented way |
| Self-hosting | No documented way | No documented way | No documented way |
| BYOC | Yes | No documented way | No documented way |
| Open source | No documented way | No documented way | No documented way |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | No documented way | Yes |
| Audit logs | Yes | Not published | No documented way |
| SSO | Yes | Yes | No documented way |
| SOC 2 | Yes | Yes | No documented way |
| HIPAA | Yes | Yes | No documented way |
| EU data residency | Yes | No documented way | No documented way |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's run of 3 October 2026 (run 37073680030), the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, boat did 28.06 runs per second (second of 15) and Daytona's Linux VM class did 21.52. Both share rank 2, so the run cannot separate them. Daytona's default container class has no result in this run. Sprites is not in the public benchmarks we use, so we cannot say how it compares; a Sprite always has 8 vCPU, so a fair test needs a matching shape. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host; boat also places sandboxes on Ryzen 7 9700X hosts, which this run did not measure. Providers ran on different hardware in different regions.
V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Daytona measured on: Linux VM sandbox (same rates; KVM / nested virt per-org feature). Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. Sprites is not in the public benchmarks we use, so we cannot say which is faster.
Pricing in five scenarios
Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario. Start limits, per-start fees and plan minimums are in the price, boat's included.
| Scenario | Daytona, a month | Sprites, a month | boat, a month |
|---|---|---|---|
| One coding agent, workdays 4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days | $56 · Tier 3 ($500 top-up) | $23 · Pay-as-you-go | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $245 · Tier 3 ($500 top-up) | $92 · Pay-as-you-go | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $2,682 · Tier 3 ($500 top-up) | $1,120 · Pay-as-you-go | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits | $314 · Pay-as-you-go · with limits | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits | $1,134 · Pay-as-you-go · with limits | $8,800 · $2000/mo · with limits |
Daytona: Daytona bills per second for the vCPU, memory and disk you reserve, and keeps billing the disk while a sandbox is stopped. The first 5 GiB of disk are free, and new accounts get $200 of free compute. You pay from a prepaid wallet with no plan fee: open internet needs a $500 top-up (Tier 3), and the biggest pool needs $2,000 every 30 days (Tier 4).
Sprites: Sprites bills CPU time at $0.0385 per CPU-hour and actual memory at $0.021875 per GB-hour, only while the Sprite is awake, plus storage on the bytes you write. Pay as you go has no plan fee. Optional plans include fixed CPU, memory and storage allowances that are not credit.
Sprites: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. A 4 vCPU / 8 GB sandbox costs $0.036 an hour, billed per second, busy or idle. A stopped sandbox has no compute charge, but saved snapshots above the included count and the AI credentials proxy still charge. The $20 plan includes 200 starts a day; extra starts cost $0.03 to $0.07.
Limits in those scenarios
Daytona limits the total vCPU and memory running at once, up to 500 vCPU on Tier 4, so 300 sandboxes for your users (600 vCPU) and 1,000 short jobs at once (2,000 vCPU) need a custom limit. Sprites does not publish how many machines can run at once on pay as you go and creates 10 a minute without a plan, so both of those scenarios are unconfirmed there. A Sprite drops open connections on every pause, so an always-on agent needs a task hold of up to an hour that you renew. boat has its own limits. The 1,000-job burst needs about 6,667 starts a day; the $2,000 plan includes 2,400, charges for starts above 90 a minute, and refuses starts above 270 a minute with 429. boat never queues a start. A stopped boat sandbox keeps its disk for at least 14 days, and a machine failure loses what was written after the last good snapshot.
| Scenario | Daytona | Sprites | boat |
|---|---|---|---|
| One coding agent, workdays |
| None for this scenario | None for this scenario |
| One agent that never stops |
| None for this scenario | None for this scenario |
| 50 agents in parallel |
|
| None for this scenario |
| Sandboxes for your users |
|
| None for this scenario |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Daytona when
your agents need GPUs, Windows, macOS, your own Docker images, memory pause and fork, or a US region or your own machines.
- GPUs, Windows and macOS. Useful if your agents test models or need another OS: Daytona rents Nvidia and AMD GPUs, runs Windows VMs and has macOS in early access.
- Pause and fork with memory. Daytona's VM classes pause and fork with memory kept, so a copy picks up exactly where the first one was.
- Your own images, US region, your own machines. Daytona builds sandboxes from your Docker images and runs in the US, the EU or on machines you bring.
Use Sprites when
your agents or apps sit idle most of the day and should wake on a request, and you want to pay only for the CPU and memory they really use.
- Sleeps when idle, wakes on request. Useful for agents that sit idle most of the day: a Sprite stops billing compute and wakes on the next request.
- Pays for real use. Sprites bills the CPU time and memory a machine actually uses while awake, not the size it could reach.
- Open internet with a domain allowlist. Every Sprite gets open internet from the start, and you can limit it to chosen domains without a large top-up.
Where boat fits
Look at boat when your agents work for hours on real builds: installs, Docker, services and emulators on a full VM you can size. On Daytona you get /dev/kvm on the VM class, and a Sprite is a fixed 8 vCPU machine that sleeps when nothing holds it awake. boat adds a desktop, up to 50 ports and an API to drive the agents inside. boat bills its full size while running, so a mostly idle machine can cost less on Sprites.
A full machine on every sandbox
On Daytona the default is a container, and /dev/kvm needs the VM class plus KVM turned on. On Sprites, services run through its services API, not systemd, and the docs do not mention /dev/kvm. boat has root, systemd, Docker and /dev/kvm on every sandbox.
Runs for hours, reachable from outside
A Sprite pauses 30 seconds after work stops and drops open connections, so a long agent needs a task hold renewed every hour, and it exposes one HTTP port. A boat sandbox runs until auto-stop, which you can set up to 30 days or turn off, with SSH and HTTPS on up to 50 ports.
Agents you drive from outside, on a desktop
Daytona has you install agents and run them as processes, and Sprites runs its preinstalled agents through exec. boat installs seven agents with a prompt, steer and events API, plus a 60 fps desktop with Chrome for computer use.
Use boat when your agents need a full machine for hours: systemd, Docker, emulators, many ports, a desktop and browser, forks, and an API to drive the agents inside, at $0.036 an hour from a $20 plan. Compare it one to one: boat vs Daytona and boat vs Sprites.
boat's own limits
- Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
- Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
- A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
- Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
- boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
- Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
- Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
- Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source
Questions people ask
Is Daytona cheaper than Sprites?
Not in our scenarios. One coding agent on workdays comes to $56 a month on Daytona and $23 on Sprites, one agent that never stops is $245 against $92, and 50 agents in parallel are $2,682 against $1,120. boat comes to $20, $26 and $317 for the same three. Sprites bills used CPU and memory, so a mostly idle workload can cost less there than these estimates.
Which is faster, Daytona or Sprites?
We cannot say: Sprites is not in the public benchmarks we use. Daytona's Linux VM class did 21.52 runs per second on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB in StarSling's run of 3 October 2026. boat did 28.06 in the same run, on an AMD Ryzen 9 9950X host; the run cannot separate boat from Daytona's VM class.
Can I run Docker on Daytona and Sprites?
Yes on both. Daytona runs Docker in all classes and offers /dev/kvm on its Linux VM class once KVM is turned on for your organization. Sprites runs Docker as root; services run through its services API instead of systemd, and its docs do not mention /dev/kvm. boat has Docker, systemd and /dev/kvm on every sandbox.
Does a sandbox keep running when I am not using it?
A Sprite pauses about 30 seconds after activity stops and wakes on the next request; to keep it working you hold it awake with a task for up to an hour at a time. Daytona containers auto-stop after 15 idle minutes and VMs auto-pause after 60, and you can turn that off. A boat sandbox runs until auto-stop: 1 hour by default, up to 30 days, or off on a paid plan.
Do Daytona or Sprites have GPUs and Windows?
Daytona has both: Nvidia and AMD GPUs from RTX 4090 to B300, and Windows VM sandboxes. Sprites has neither. boat has no GPU and runs only Linux, with Wine for Windows programs.
Where do Daytona and Sprites run?
Daytona offers US and EU regions, plus dedicated regions and your own machines. Sprites does not let you choose a region. boat sandboxes run in Germany, Finland and France, you cannot pick a region, and snapshot copies can be stored outside the EU.
Try boat
Install the CLI, then run boat new.
7-day free trial