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.

Founded
2023

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.

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 workloadDaytona: price rankSprites: price rankboat: 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 requirementNot 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 requirementNot ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureDaytonaSpritesboat
IsolationContainer with its own namespaces by default; Linux VM and Windows VM classes add a hardware virtualization boundaryFirecracker microVM with its own kernelEvery 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 runNot in the public benchmarks we use; a Sprite always has 8 vCPU28.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 sizeYou choose; up to 4 vCPU / 8 GB per container or Linux VM sandbox by default, higher on requestFixed 8 vCPU and 100 GB disk; memory scales from 2 GB to 16 GB and bills on useYou 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 virtualizationDocker in all classes; /dev/kvm on Linux VM sandboxes once KVM is turned on for your organizationRoot and Docker; services run through the Sprites services API, not systemd; no /dev/kvm in the docsDocker, root, systemd and /dev/kvm on every sandbox
Idle behaviorContainers auto-stop after 15 idle minutes, VMs auto-pause after 60, and you can turn that off; the disk stays billed while stoppedPauses 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 stopRuns 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 forkLinux VM and Windows: pause, resume and fork with memory kept; containers: filesystem snapshots that new sandboxes start fromMemory kept while paused; filesystem checkpoints restore in place; no fork command in the CLI or API docsFork a running sandbox from its last 1-minute snapshot; resume reboots from disk (no memory snapshots)
Custom imagesDocker images and declarative builds for containers; VM snapshots from an imageOne managed Ubuntu image; you install on top of it and save that as a checkpointSaved snapshots (templates); you cannot boot your own Docker or OCI image
Reaching the sandboxHTTPS preview URLs on any port, token-protected, signed or public; SSH; no public IPOne HTTPS URL to one HTTP port, private by default; other ports and SSH through the sprite proxy CLIUp 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 internetTier 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 outsideOpen internet on every plan; no provider-side allowlist
Keeping keys out of the sandboxSecrets proxy swaps placeholders in HTTPS request headers for allowed hostsConnectors gateway holds the token for any HTTP API, with path allow and block listsOptional AI credentials proxy, off by default, $1 a day plus $1 per 1,000 requests
Coding agentsYou set it up: install the agent and run it through process exec; guides cover Claude Code, Codex, OpenCode and othersClaude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a consoleSeven harnesses installed (Claude Code, Codex, pi, OpenCode and more), with a prompt, steer and events API
Desktop and computer useVNC desktop (xfce4) and a computer-use API with screen recording on Linux and WindowsNo desktop or browser built in. You set it up: install a browser, a display server and a stream1920x1080, 60 fps desktop and Chrome, computer tools for agents, embeddable stream
GPUs, Windows and macOSNvidia and AMD GPUs by the hour; Windows VM sandboxes; macOS in early accessNoneNo GPU on any size; Linux only, Windows programs through Wine
RegionsUS and EU, plus dedicated regions or your own machinesNo region option when you create a SpriteGermany, Finland and France; you cannot pick a region; no US or Asia region
Every feature Battleships tracks (43)
FeatureDaytonaSpritesboat
Full VM (own kernel)No documented wayYesYes
Docker insideYesYesYes
Nested virtualizationYesNo documented wayYes
RootYesYesYes
SystemdNot publishedNo documented wayYes
Desktop GUIYesNo documented wayYes
BrowserYesNo documented wayYes
Computer-use APIYesNo documented wayYes
SSHYesWith your own setupYes
Persistent diskYesYesYes
Pause/resumeYesYesYes
Automatic snapshotsYesYesYes
Fork/cloneYesNo documented wayYes
Live fork (no pause)No documented wayNo documented wayYes
Memory forkYesNo documented wayNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesYesYes
Idle auto-stopYesYesNo documented way
Wake on requestNo documented wayYesNo documented way
HTTPS preview URLsYesYesYes
Raw TCP inboundNo documented wayNo documented wayYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo documented way
Secret proxyYesYesYes
Secret proxy for any APIYesYesYes
Preinstalled agentsYesYesYes
Agent harness APINo documented wayNo documented wayYes
MCP serverYesYesNo documented way
GPUYesNo documented wayNo documented way
WindowsYesNo documented wayNo documented way
Arm64No documented wayNo documented wayNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCYesNo documented wayNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysYesNot publishedYes
Spend limitsNot publishedNot publishedYes
Usage per sandbox (API)YesNo documented wayYes
Audit logsYesNot publishedNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAAYesYesNo documented way
EU data residencyYesNo documented wayNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

Daytona21.52 runs/s
SpritesNot measured
boat28.06 runs/s

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.

ScenarioDaytona, a monthSprites, a monthboat, 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.

ScenarioDaytonaSpritesboat
One coding agent, workdays
  • egress price not published
  • Tier 1 (email verified), Tier 2 (card + $25 top-up) reach only an allowlist (package registries, git, AI APIs)
None for this scenarioNone for this scenario
One agent that never stops
  • egress price not published
  • Tier 1 (email verified), Tier 2 (card + $25 top-up) reach only an allowlist (package registries, git, AI APIs)
None for this scenarioNone for this scenario
50 agents in parallel
  • egress price not published
  • Tier 1 (email verified), Tier 2 (card + $25 top-up) reach only an allowlist (package registries, git, AI APIs)
  • how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
None for this scenario
Sandboxes for your users
  • max 500 vCPU running at once (needs 600)
  • max 1,000 GiB running at once (needs 1,200)
  • egress price not published
  • Tier 1 (email verified), Tier 2 (card + $25 top-up) reach only an allowlist (package registries, git, AI APIs)
  • not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
None for this scenario
1,000 short jobs at once
  • max 500 vCPU running at once (needs 2,000)
  • max 1,000 GiB running at once (needs 4,000)
  • egress price not published
  • Tier 1 (email verified), Tier 2 (card + $25 top-up) reach only an allowlist (package registries, git, AI APIs)
  • not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429

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

More comparisons