Daytona vs Sprites
Daytona starts each sandbox as a container you size yourself, and sells Linux VM, Windows and GPU classes on top. Sprites 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, or a GPU class with Nvidia and AMD cards. 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 the platform manages, and a 100 GB ext4 disk that syncs to object storage. It runs one managed Ubuntu image with Claude Code, Codex, Gemini CLI and Cursor preinstalled, gets an HTTPS URL that wakes it, and bills only for the CPU and memory it actually 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
- Regions
- Not selectable for Sprites
- 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. “15th cheapest of 367” means 14 of the other 366 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 | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Daytona fits fully with its Linux VM class for pause, fork and /dev/kvm, while Sprites is a compromise with no systemd and one public port; bochka has all of it on every machine. | 15th cheapest of 367 $4,111 a month | 66th of 367, with limits $546 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Daytona keeps an assistant running until you stop it, while a Sprite pauses about 30 seconds after work stops and drops its open connections unless a task holds it awake. | 24th cheapest of 366 $6,104 a month | 157th of 366, with limits $1,166 a month | 5th cheapest of 366 $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 up to 300 to 600 sandboxes a minute, and Sprites sleeps right after a run and bills only the CPU and memory it used. | 25th cheapest of 345 $271 a month | 93rd of 345, with limits $140 a month | 186th of 345, 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 publish how many can run at once; bochka fits this one as published. | 154th of 361, with limits $2,000 a month | 56th of 361, with limits $428 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 130th of 360, with limits $8,261 a month | 105th of 360, with limits $6,540 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 189th of 364, with limits $2,000 a month | 125th of 364, with limits $545 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Sprites fits CI as published, while Daytona caps a sandbox at 4 vCPU by default; Android or VM image builds need /dev/kvm, which bochka exposes and the Sprites docs do not mention. | 308th of 377, with limits $805 a month | 63rd cheapest of 377 $476 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A 24/7 dev box wants SSH and systemd: Daytona has SSH, Sprites tunnels SSH through its CLI and does not run systemd, and bochka has both. | 183rd of 368, with limits $245 a month | 213th of 368, with limits $27 a month | 18th cheapest of 368 $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, Sprites is headless, and bochka streams a 60fps desktop with Chromium. | 26th cheapest of 369 $1,198 a month | 85th of 369, with limits $136 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 93rd of 367, with limits $598 a month | 171st of 367, with limits $122 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 38th cheapest of 346 $404 a month | 229th of 346, with limits $206 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 202nd of 338, with limits $8,073 a month | 141st of 338, with limits $4,113 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 12th cheapest of 360 $2,000 a month | 210th of 360, with limits $223 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Only Daytona fits: it rents Nvidia and AMD GPUs by the hour, and neither Sprites nor bochka has GPUs. | 20th cheapest of 98 $1,190 a month | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Daytona | Sprites | bochka |
|---|---|---|---|
| Isolation | Container by default; Linux VM and Windows VM classes on request | Firecracker microVM with its own kernel | Every sandbox is a full VM with its own kernel, on dedicated AMD Ryzen 9 9950X hosts |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 21.52 runs/s on the Linux VM class; the default container class reported no result | Not measured | 26.69 runs/s |
| Machine size | You choose; 4 vCPU / 8 GiB per sandbox by default, raisable | Fixed 8 vCPU and 100 GB disk; memory managed and scaled by the platform | You choose; up to 16 vCPU / 32 GB on the $100 plan and above |
| Docker, systemd and nested virtualization | Docker in all classes; /dev/kvm only on Linux VMs, with KVM turned on for your organization | Root and Docker (with rough edges users report); no systemd, and no /dev/kvm in the docs | Docker, root, systemd and /dev/kvm on every machine |
| Idle behavior | Containers auto-stop after 15 idle minutes, VMs auto-pause after 60; the disk stays billed while stopped | Pauses about 30 seconds after activity stops, wakes on the next request in 100 to 500 ms | Runs until you stop it or its time to live ends; disk saved every minute, and a stopped sandbox costs nothing |
| Pause and fork | Linux VM and Windows: pause, resume and fork with memory kept; containers: no pause or fork | Checkpoints restore in place; no fork in the public API or CLI | Fork a running sandbox; 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 | Named snapshots (templates), shareable by code; no Dockerfile builds |
| Reaching the sandbox | HTTPS preview URLs on any port, token-protected or public; SSH; no raw TCP or public IP | One HTTPS URL to one HTTP port; other ports and SSH only through the sprite proxy CLI | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6; SSH |
| 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 | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Guides install agents and run them through process exec | Claude Code, Codex, Gemini CLI and Cursor preinstalled, run through exec or a console | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Desktop and computer use | VNC desktop (xfce4) and a computer-use API on Linux and Windows | Headless; no desktop or browser product | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| GPUs and Windows | Nvidia and AMD GPUs by the hour; Windows VM sandboxes | None | None; Wine for Windows apps |
| Regions | US and EU, plus dedicated regions or your own machines | Region not selectable | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | Daytona | Sprites | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | No | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | Yes | No | No |
| Windows | Yes | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's public run of 2026-09-29 at 4 vCPU / 8 GB, bochka did 26.69 Node.js build-and-test runs per second and Daytona's Linux VM class did 21.52, so builds take about a quarter longer on Daytona. Daytona's default container class reported no result. Sprites is not in that benchmark, so there is no comparable number for it.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Daytona measured on: Linux VM sandbox (same rates; KVM / nested virt per-org feature). Sprites has no published run in this suite yet, so there is no like-for-like number to compare.
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.
| Scenario | Daytona, a month | Sprites, a month | bochka, 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 | $2,000 · $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. You pay from a prepaid wallet: 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. Optional plans include fixed CPU, memory and storage allowances that are not credit.
Sprites: Plans start at $20 a month, and the whole fee is usage credit spent per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
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 also drops open connections on every pause, so an always-on agent needs a task hold of at most an hour that must be renewed. bochka fits the 300 user sandboxes but queues the 1,000-job burst and runs out of daily starts.
| Scenario | Daytona | Sprites | bochka |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
| None that bite | None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Daytona when
your agents need GPUs, Windows, your own Docker images, memory pause and fork, or a US region or your own machines.
- GPUs and Windows. Useful if your agents test models or need Windows: Daytona rents Nvidia and AMD GPUs by the hour and runs Windows VMs.
- 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 bochka fits
Look at bochka when your agents work for hours on real builds: installs, Docker, services and emulators on a full VM you can size. Daytona gives you that only on its VM class, and Sprites gives you a fixed machine without systemd that sleeps when nothing holds it awake. bochka also adds a desktop, many ports and an API to drive the agents inside from outside.
A full machine on every sandbox
On Daytona the default is a container sharing the host kernel, and /dev/kvm needs the VM class plus KVM turned on. On Sprites there is no systemd and no /dev/kvm in the docs. bochka has root, systemd, Docker and /dev/kvm everywhere.
Runs for hours, reachable from anywhere
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. bochka keeps running, with SSH, raw TCP 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 them through exec with no screen. bochka ships seven agents with a prompt, steer and events API, plus a 60fps desktop with Chromium for computer use.
Use bochka when your agents need a full, fast machine for hours: systemd, Docker, emulators, many ports, a desktop and browser, forks, and an API to drive the agents inside from outside. Compare it one to one: bochka vs Daytona and bochka vs Sprites.
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. bochka comes to $20, $26 and $317 for the same three.
Which is faster, Daytona or Sprites?
We cannot say: Sprites is not in the public benchmark we use. Daytona's Linux VM class did 21.52 runs per second at 4 vCPU / 8 GB, and bochka did 26.69 in the same run. A Sprite always has 8 vCPU, so a fair test needs a matching shape.
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 with some rough edges users report, does not run systemd, and its docs do not mention /dev/kvm. bochka has Docker, systemd and /dev/kvm on every machine.
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 bochka sandbox runs until you stop it.
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, and bochka has no GPUs or Windows guests either.
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. bochka runs only in the EU, in Germany, Finland and France, with EU data residency.
Try bochka
Install the CLI, then run bochka new.
Product preview