Daytona vs CodeSandbox SDK
Daytona starts each sandbox as a container and sells Linux VM, Windows and GPU classes on top. CodeSandbox SDK gives every sandbox a Firecracker microVM that hibernates with its memory and wakes on the next HTTP 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
CodeSandbox SDK
CodeSandbox SDK is an API from CodeSandbox, now a Together AI company, that starts sandboxed development VMs on the same infrastructure as the CodeSandbox editor.
Each sandbox is a Firecracker microVM built from a template or any Dockerfile. When it goes idle it hibernates with a memory snapshot, and it resumes or forks from that snapshot in seconds. You drive it from a TypeScript SDK through terminals, commands, files and HTTPS hosts. Together's docs now call it the legacy offering and point new users to its successor, the together-sandbox SDK.
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 | CodeSandbox SDK: 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 and ranks 15th, CodeSandbox SDK is a compromise at 178th, and bochka ranks 3rd with Docker, a desktop and /dev/kvm on every machine. | 15th cheapest of 367 $4,111 a month | 178th of 367, with limits $1,939 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 24th cheapest of 366 $6,104 a month | 215th of 366, with limits $2,478 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 Short code runs suit both: Daytona ranks 25th at $271 a month and CodeSandbox SDK 46th at $642, while bochka's start limits make big bursts a compromise. | 25th cheapest of 345 $271 a month | 46th cheapest of 345 $642 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 Neither fits 300 sandboxes at once: Daytona's Tier 4 pool stops at 500 vCPU and CodeSandbox SDK's Scale plan at 250 VMs, while bochka fits at $200 a month. | 154th of 361, with limits $2,000 a month | 140th of 361, with limits $1,707 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 CodeSandbox SDK's memory forks let many rollouts branch from one running state, and Daytona's VM classes can fork with memory too. | 130th of 360, with limits $8,261 a month | 348th of 360, with limits $3,861 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 CodeSandbox SDK fits fully and ranks 64th, Daytona is a compromise at 189th, and bochka ranks 10th. | 189th of 364, with limits $2,000 a month | 64th cheapest of 364 $1,335 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, so it ranks 308th here against CodeSandbox SDK's 92nd; bochka ranks 4th. | 308th of 377, with limits $805 a month | 92nd cheapest of 377 $860 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 | 310th of 368, with limits $240 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, CodeSandbox SDK has no desktop, and bochka streams a 60fps desktop. | 26th cheapest of 369 $1,198 a month | 206th of 369, with limits $691 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 | 251st of 367, with limits $443 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 | 281st of 346, with limits $508 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 | 193rd of 338, with limits $7,390 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 | 240th of 360, with limits $326 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 CodeSandbox SDK 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 | CodeSandbox SDK | bochka |
|---|---|---|---|
| Isolation | Container by default; Linux VM and Windows VM classes with their own kernel | Firecracker microVM with its own kernel for every sandbox | 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 |
| Docker and nested virtualization | Docker in all classes; /dev/kvm only on Linux VMs, once KVM is turned on for your organization | Docker and root, built from any Dockerfile; nested virtualization not documented | Docker, root, systemd and /dev/kvm on every machine |
| Pause with memory | Linux VM and Windows classes pause and resume with memory kept; containers do not | Every sandbox hibernates with a memory snapshot and resumes with processes still running | Disk saved every minute and on stop; resume boots the machine again |
| Fork | Linux VM and Windows classes fork with memory kept; containers do not fork | Fork a hibernated sandbox from its snapshot, or a running one sharing its memory | Fork a running sandbox with its disk |
| Wake on request | No | Yes; an HTTP request to a host wakes a hibernated sandbox | No; a stopped sandbox is started by API |
| Biggest machine | 4 vCPU / 8 GiB per sandbox by default, raisable per region | Up to 16 cores / 32 GB on Scale, 64 cores / 128 GB on Enterprise | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Desktop and computer use | VNC desktop (xfce4) and a computer-use API on Linux and Windows | No desktop; a headless Chromium template | 60fps desktop with Chromium, computer use and browser control, embeddable stream |
| Reaching the sandbox | HTTPS preview URLs on any port, token-protected or public; SSH; no raw TCP or public IP | HTTPS host per port, public by default, signed tokens for private hosts; no SSH, raw TCP or public IP | HTTPS URLs for up to 50 ports, token-protected; SSH; raw TCP; dedicated IPv6 or IPv4 |
| Keeping keys out of the sandbox | Secrets proxy swaps placeholders in HTTPS request headers for allowed hosts | Secrets passed in as environment variables | AI 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 | Run your own agent through the command API | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| GPUs and Windows | Nvidia and AMD GPUs by the hour; Windows VM sandboxes | No GPUs, no Windows | No GPUs; no Windows guests, Wine for Windows apps |
| Regions | US and EU, plus dedicated regions or your own machines | A country hint steers scheduling, for example to Europe, but placement is not guaranteed | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Daytona | CodeSandbox SDK | 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 | No | 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 | 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 | No | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | No | 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 | 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 in that run. CodeSandbox SDK was not part of it, so there is no comparable CPU 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). CodeSandbox SDK 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 | CodeSandbox SDK, 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) | $193 · Scale | $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) | $341 · Scale | $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,500 · Scale | $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 | $815 · Scale · 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,632 · Scale · with limits | $2,000 · $2000/mo · with limits |
Daytona: Daytona bills per second for the vCPU, memory and disk you reserve, including while a sandbox starts or stops, and keeps billing the disk while it 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).
CodeSandbox SDK: CodeSandbox SDK sells VM credits that each size burns per hour, billed per started minute while the VM runs, including idle time before it hibernates. The Scale plan adds a $170 monthly platform fee that is not usage credit, and a hibernated VM costs nothing.
CodeSandbox SDK: 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 running at once, up to 500 vCPU on Tier 4, and only opens the internet from Tier 3. CodeSandbox SDK's Scale plan allows 250 VMs at once, gives each a 20 GB disk, and does not publish the price of more disk. So 300 sandboxes for your users and 1,000 short jobs at once fit neither without custom limits. bochka fits the 300 user sandboxes at $200 a month, but its start limits queue the 1,000-job burst too.
| Scenario | Daytona | CodeSandbox SDK | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| 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 or a desktop, or must run in the US or on your own machines.
- GPUs by the hour. If your agents train or test models, Daytona rents Nvidia and AMD GPUs by the hour, which CodeSandbox SDK does not offer.
- Windows and a desktop. If your agents need a Windows machine or a desktop to click through, Daytona has Windows VMs and a computer-use API.
- US regions and your own machines. If your sandboxes must run in a chosen region, Daytona offers US and EU, dedicated regions and machines you bring.
Use CodeSandbox SDK when
your sandboxes sleep between visits and should wake on the next HTTP request with their memory intact, and you are fine building on what Together now calls its legacy SDK.
- Hibernate and wake on request. For previews used in short bursts, a hibernated VM wakes on the next HTTP request with its processes still running.
- Memory forks on every sandbox. For branching many runs from one warm state, every CodeSandbox SDK sandbox can fork with its memory, not only a VM class.
- Bigger machines without asking. For heavy builds, Scale allows up to 16 cores and 32 GB, while Daytona caps one sandbox at 4 vCPU by default.
Where bochka fits
If your agents run for hours doing installs, builds, tests, Docker and emulators, look at bochka. Every bochka sandbox is a full VM with /dev/kvm, a desktop and coding agents built in, on a CPU that measured faster than Daytona's VM class. Stopped sandboxes cost nothing and keep their disk.
A full VM with /dev/kvm every time
Daytona's default sandbox is a container sharing the host kernel; you get /dev/kvm only on its VM class once KVM is turned on for your organization. CodeSandbox SDK documents no nested virtualization and no SSH, so emulator builds cannot start.
Faster CPU in the same test
At 21.52 runs per second on Daytona's VM class against bochka's 26.69, every install, build and test takes about a quarter longer, and you pay for the wait. CodeSandbox SDK has no measured number at all.
Agents and keys already set up
On Daytona and CodeSandbox SDK you install the agent and write the code that starts, prompts and watches it. CodeSandbox SDK puts keys in environment variables the agent can read; bochka keeps them in a proxy outside the sandbox.
Use bochka when your agents do real work for hours: installs, builds, Docker and emulators on a full, faster VM with a desktop and coding agents built in. Compare it one to one: bochka vs Daytona and bochka vs CodeSandbox SDK.
Questions people ask
Is Daytona cheaper than CodeSandbox SDK?
For one agent, yes: one coding agent on workdays comes to $56 a month on Daytona and $193 on CodeSandbox SDK, and one agent all month to $245 versus $341. For 50 agents in parallel CodeSandbox SDK is a bit cheaper, $2,500 versus $2,682. bochka comes to $20, $26 and $317 for the same three.
Which is faster, Daytona or CodeSandbox SDK?
There is no shared measurement. Daytona's Linux VM class did 21.52 runs per second in StarSling's 4 vCPU / 8 GB test, and CodeSandbox SDK was not part of that run. bochka did 26.69 in the same test.
Can Daytona and CodeSandbox SDK run Docker?
Both run Docker inside the sandbox. Daytona also gives /dev/kvm on its Linux VM class once KVM is turned on for your organization, while CodeSandbox SDK does not document nested virtualization. bochka has Docker and /dev/kvm on every machine.
Which one pauses a sandbox with its memory?
Both can. Every CodeSandbox SDK sandbox hibernates with a memory snapshot and can wake on an HTTP request, while on Daytona only the Linux VM and Windows classes pause with memory. bochka saves the disk and boots again on resume.
Is CodeSandbox SDK still maintained?
CodeSandbox is now part of Together AI. Together's docs call the CodeSandbox-based SDK deprecated and name together-sandbox as its successor, while self-serve sign-up still runs through CodeSandbox.
Does either have GPUs or Windows?
Daytona does: it rents Nvidia and AMD GPUs by the hour and runs Windows VM sandboxes. CodeSandbox SDK and bochka have neither.
Try bochka
Install the CLI, then run bochka new.
Product preview