Daytona vs Docker Cloud Sandboxes
Daytona runs sandboxes as containers by default, with Linux VM, Windows and GPU classes and no session cap. Docker Cloud Sandboxes gives every sandbox its own microVM, the same one you run on your laptop, but each one ends 24 hours after creation and you get 10 at a time by default.
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
Docker Cloud Sandboxes
Docker Cloud Sandboxes runs Docker's sbx coding-agent microVMs on Docker-managed compute instead of your laptop.
Each sandbox is a microVM with its own Linux kernel and its own Docker Engine, started from the same sbx CLI you use locally, with Claude Code, Codex and other agents ready to run. You can move a sandbox from your laptop to the cloud and back, publish HTTPS ports and SSH in. It launched on September 24, 2026, is billed pay-as-you-go on a personal Docker account, and is built for developers who want their local agent sandboxes to keep going off their machine.
- Launched
- September 24, 2026
- Session length
- 1 hour by default, extendable to 24 hours from creation
- Default quota
- 10 concurrent and 50 stored sandboxes per account
- Regions
- Not published
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 | Docker Cloud Sandboxes: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Daytona fits a software factory because sandboxes have no session cap, while Docker stops each one at 24 hours and runs 10 at a time; bochka fits with a full VM on every sandbox. | 15th cheapest of 367 $4,111 a month | 280th of 367, with limits $4,928 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month fits Daytona, which has no session cap, but not one Docker session, which ends 24 hours after creation. | 24th cheapest of 366 $6,104 a month | 276th of 366, with limits $5,110 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 handle short code runs as a compromise here; Docker bills small sandboxes by the second with no fee, and Daytona creates hundreds of sandboxes a minute. | 25th cheapest of 345 $271 a month | 119th of 345, with limits $233 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 at once go past Daytona's Tier 4 pool of 500 vCPU and far past Docker's default of 10 sandboxes; bochka fits on its $100 plan. | 154th of 361, with limits $2,000 a month | 136th of 361, with limits $1,628 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 | 114th of 360, with limits $7,000 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 | 167th of 364, with limits $1,400 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 Daytona caps one sandbox at 4 vCPU by default and Docker allows 10 at once, so both are a compromise for CI; bochka allows 8 vCPU from the $20 plan. | 308th of 377, with limits $805 a month | 172nd of 377, with limits $672 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 183rd of 368, with limits $245 a month | 127th of 368, with limits $204 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 fits computer-use agents with a VNC desktop and a computer-use API, while Docker's sandboxes are terminal only; bochka streams a 60fps desktop. | 26th cheapest of 369 $1,198 a month | 268th of 369, with limits $1,400 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 | 277th of 367, with limits $700 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 | 262nd of 346, with limits $350 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 | 190th of 338, with limits $7,000 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 Daytona fits parallel red teaming with many sandboxes and no session cap; Docker's 10 at a time and 24-hour cap make it a compromise. | 12th cheapest of 360 $2,000 a month | 248th of 360, with limits $350 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 GPU jobs: it rents Nvidia and AMD GPUs by the hour, and neither Docker Cloud Sandboxes 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 | Docker Cloud Sandboxes | bochka |
|---|---|---|---|
| Isolation | Container by default; Linux VM and Windows VM classes have their own kernel | MicroVM with its own Linux kernel for every sandbox | Full VM with its own kernel for every sandbox, on dedicated AMD Ryzen 9 9950X hosts |
| Session length | No cap by default; you can set an optional time to live | 1 hour by default, at most 24 hours from creation | No cap on paid plans; you set the time to live |
| How many at once | A pool of 10 to 500 vCPU running at once, by tier | 10 sandboxes by default; no published way to raise it | 100 sandboxes on the $20 plan, up to 2,000 on higher plans |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 21.52 runs/s on the Linux VM class | Not measured | 26.69 runs/s |
| Stop, pause and fork | VM classes pause and fork with memory kept; containers cannot | Stop keeps memory and files; snapshot a running sandbox and restore it as a new one | Fork a running sandbox with its disk; resume boots again from disk |
| Docker and nested virtualization | Docker in all classes; /dev/kvm only on Linux VMs, once KVM is turned on for your organization | Its own Docker Engine; nested virtualization not documented | Docker, root, systemd and /dev/kvm on every machine |
| Desktop and computer use | VNC desktop and a computer-use API on Linux and Windows | Terminal sessions only | 60fps Linux desktop with Chromium, computer use and browser control |
| Inbound access | HTTPS preview URLs on any port, token-protected or public; SSH; no raw TCP | Public HTTPS URL per published port, not protected by Docker sign-in; SSH | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Outbound internet | Tier 1 and 2 reach only registries, git hosts and AI APIs; Tier 3 and up get open internet and allowlists | Allow and deny rules by host, with allow-all, balanced and deny-all presets | Open internet on every plan; no provider-side allowlist |
| Coding agents | Guides to install agents and run them as processes | Claude Code, Codex, Copilot, OpenCode and more, attached from the sbx CLI | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Keeping keys out of the sandbox | Secrets proxy swaps placeholders in HTTPS headers for allowed hosts | Cloud proxy sets the auth header for AI services and custom hosts | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| GPUs and Windows | Nvidia and AMD GPUs by the hour, and Windows VM sandboxes | CPU only, Linux only | No GPUs; no Windows guests (Wine for Windows apps) |
| Laptop and cloud | Cloud, plus dedicated regions or your own machines | Same microVM and CLI on your laptop or in the cloud; move a sandbox either way | Cloud only |
| Regions | US and EU, plus dedicated regions and your own machines | Not published | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Daytona | Docker Cloud Sandboxes | 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 | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | Yes | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | No | Not published | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | 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 | Yes | 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 | No | No |
| HIPAA | Yes | No | 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. Daytona's default container class reported no result. Docker Cloud Sandboxes launched in September 2026 and has no comparable measurement yet.
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). Docker Cloud Sandboxes 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 | Docker Cloud Sandboxes, 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) | $49 · Docker Agentic Platform (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) | $204 · Docker Agentic Platform (pay-as-you-go) · with limits | $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) | $2,464 · Docker Agentic Platform (pay-as-you-go) · with limits | $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 | $700 · Docker Agentic Platform (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,400 · Docker Agentic Platform (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).
Docker Cloud Sandboxes: Docker bills per second for the size you pick, from $0.07 an hour for 1 vCPU / 2 GiB to $1.12 an hour for 16 vCPU / 32 GiB, with no monthly fee. A stopped sandbox costs nothing, and volumes and egress are free.
Docker Cloud Sandboxes: Plans start at $20 a month, and the whole fee becomes usage credit spent per second while sandboxes run. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Docker ends every sandbox 24 hours after creation, so one agent that never stops does not fit, and its default of 10 sandboxes at once rules out 50 agents in parallel, sandboxes for your users and 1,000 short jobs at once. Daytona has no session cap, but it limits the vCPU running at once to a pool of up to 500 on Tier 4, so 300 user sandboxes (600 vCPU) and the 1,000-job burst (2,000 vCPU) need a custom limit. Daytona's Tier 1 and 2 also reach only an allowlist of services. bochka fits every scenario but the burst, where its start limits queue the jobs.
| Scenario | Daytona | Docker Cloud Sandboxes | bochka |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
|
| 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, a US region or your own machines, or must run longer than a day.
- No session cap. For agents that work for days: a Daytona sandbox has no time limit by default, while Docker ends each one at 24 hours.
- GPUs and Windows. For model evals or Windows desktops: Daytona rents Nvidia and AMD GPUs by the hour and runs Windows VM sandboxes.
- More at once, in more places. For bigger fleets: Daytona's limit is a vCPU pool of up to 500, and it runs in the US, the EU or on your machines.
Use Docker Cloud Sandboxes when
you already run agents in sbx on your laptop and want a few of them to keep going in the cloud for up to a day, with memory kept across stops.
- A microVM for every sandbox. For teams that want a separate kernel without picking a class: every Docker sandbox is a microVM with its own Docker Engine.
- Memory kept on every stop. For agents that pause between steps: a stopped Docker sandbox comes back with its memory and running processes.
- The same sandbox on your laptop. If you already run sbx locally, the cloud is the same microVM and CLI, and a sandbox can move between them.
Where bochka fits
If your agents run for hours or days, build and test real code, and need a screen or emulators, look at bochka. Every sandbox is a full VM with Docker, /dev/kvm and a desktop, it has no session cap on paid plans, and the $20 plan runs 100 at once.
A full VM with /dev/kvm, every time
Daytona's default sandbox is a container on a shared kernel, and /dev/kvm needs its VM class plus KVM turned on for your organization. Docker does not document nested virtualization, so Android emulators and VMs have nowhere to run.
Long and wide without a wall
On Docker your code must stop and resume an agent before 24 hours, and the eleventh one waits for a slot. On Daytona, open internet needs a $500 top-up and 300 small sandboxes go past the 500 vCPU pool.
Agents and a desktop built in
On Daytona you install the agent and run it as a process; on Docker you attach to its terminal, which has no desktop. Either way you write the wrapper. bochka drives seven agents through an API, with a 60fps desktop.
Use bochka when your agents run for days or by the dozen on a full, faster VM with Docker, /dev/kvm, a desktop and coding agents you drive through an API. Compare it one to one: bochka vs Daytona and bochka vs Docker Cloud Sandboxes.
Questions people ask
Is Daytona cheaper than Docker Cloud Sandboxes?
For one coding agent on workdays at 4 vCPU / 8 GiB, Docker is a little cheaper: $49 a month against $56 on Daytona. In our other scenarios Docker does not fit, because of its 24-hour cap or its 10 sandboxes at once. bochka comes to $20 for the same workday agent.
Which is faster, Daytona or Docker Cloud Sandboxes?
Only Daytona has a public number: its Linux VM class did 21.52 Node.js build-and-test runs per second at 4 vCPU / 8 GB. Docker Cloud Sandboxes has not been measured yet. bochka did 26.69 in the same run.
Are Daytona and Docker sandboxes containers or VMs?
Daytona's default class is a container, and it also sells Linux VM and Windows VM classes with their own kernel. Every Docker cloud sandbox is a microVM with its own Linux kernel and Docker Engine. Every bochka sandbox is a full VM.
Can a Docker cloud sandbox run as long as a Daytona sandbox?
No. A Docker cloud sandbox ends one hour after creation by default and can be extended to at most 24 hours. A Daytona sandbox has no time limit by default, and bochka has no session cap on paid plans.
Can I run Docker inside Daytona and Docker Cloud Sandboxes?
Yes, both run Docker inside the sandbox. Daytona also offers /dev/kvm on its Linux VM class once KVM is turned on for your organization, while Docker does not document nested virtualization. bochka has Docker and /dev/kvm on every machine.
Which one has a desktop for computer use?
Daytona has a VNC desktop and a computer-use API on Linux and Windows. Docker's cloud sandboxes are terminal sessions only. bochka streams a 60fps Linux desktop with Chromium on every sandbox.
Try bochka
Install the CLI, then run bochka new.
Product preview