Daytona vs Upstash Box
Daytona runs sandboxes as containers by default and sells Linux VM, Windows and GPU classes on top, paid from a prepaid wallet. Upstash Box gives each agent a light Docker container that pauses when idle, bills only the CPU it uses, and runs in one US region.
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
Upstash Box
Upstash Box is a cloud computer for AI agents from Upstash, the company known for serverless Redis, Vector and QStash.
Each box is a Docker container with its own filesystem, shell, git and an optional coding agent such as Claude Code, Codex or OpenCode, which you drive from TypeScript or Python SDKs. A box pauses when it sits idle, keeps its files, and you pay for the CPU it actually uses. Upstash built it to run its own Context7 service and opened it to everyone in March 2026.
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 | Upstash Box: 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 Docker runs in all its classes, while an Upstash box is itself a container with no Docker inside; bochka runs Docker and /dev/kvm on every VM. | 15th cheapest of 367 $4,111 a month | 61st of 367, with limits $464 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 | 103rd of 366, with limits $475 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 Upstash fits short code runs better than Daytona: an idle box costs no CPU and RAM is never billed, while Daytona bills reserved resources until a sandbox stops. | 25th cheapest of 345 $271 a month | 10th cheapest of 345 $119 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 Upstash fits 300 user sandboxes at once, while 600 vCPU is more than Daytona's Tier 4 pool of 500 vCPU; bochka fits too, with a full VM per user. | 154th of 361, with limits $2,000 a month | 2nd cheapest of 361 $222 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 | 352nd of 360, with limits $8,068 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 | 52nd cheapest of 364 $1,011 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 Upstash fits the CI scenario better than Daytona, which caps one sandbox at 4 vCPU by default; bochka adds Docker and /dev/kvm for jobs that build images or apps. | 308th of 377, with limits $805 a month | 120th cheapest of 377 $1,520 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A flat-price keep-alive box makes Upstash a light 24/7 dev box, while Daytona keeps billing reserved vCPU, memory and disk all month. | 183rd of 368, with limits $245 a month | 10th cheapest of 368 $20 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 with a VNC desktop and a computer-use API on Linux and Windows, while Upstash has only a headless browser; bochka streams a 60fps desktop. | 26th cheapest of 369 $1,198 a month | 73rd of 369, with limits $76 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 | 49th of 367, with limits $38 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 | 37th cheapest of 346 $400 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 | 200th of 338, with limits $8,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 | 12th cheapest of 360 $2,000 a month | 225th of 360, with limits $259 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 Upstash Box 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 | Upstash Box | bochka |
|---|---|---|---|
| Isolation | Container by default; Linux VM and Windows VM classes have their own kernel | One Docker container per box on AWS | 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 | No result in the benchmark | 26.69 runs/s |
| Docker and nested virtualization | Docker in all classes; /dev/kvm only on Linux VMs, with KVM turned on for your organization | No Docker inside documented, and no VM support; custom images are listed as coming soon | Docker, root, systemd and /dev/kvm on every machine |
| Machine size and disk | 4 vCPU / 8 GiB / 10 GiB disk per sandbox by default, raisable per region | Up to 8 vCPU / 16 GB; disk of 5, 10 or 20 GB by size | Up to 16 vCPU / 32 GB from the $100 plan; 50 GB disk at the default 4 vCPU / 8 GB size |
| Paying while idle | Reserved vCPU, memory and disk are billed until auto-stop; the disk keeps billing while stopped | Only CPU actually used is billed and RAM is free; storage keeps billing while paused | Billed per second while running; a stopped sandbox costs nothing and keeps its disk |
| Pause and fork | Linux VM and Windows: pause, resume and fork with memory kept; containers: no pause or fork | Pauses when idle and keeps its files; snapshot a running box and start many boxes from it | Fork a running sandbox with its disk; resume reboots from disk |
| Wake on request | No | A request to a public URL resumes a paused box and waits for the app | No; a stopped sandbox is started by API |
| Desktop and computer use | VNC desktop (xfce4) and a computer-use API on Linux and Windows | Managed headless Chromium with AI page actions and CDP; no desktop | Linux desktop streamed at 60fps with Chromium and computer-use tools, embeddable in your app |
| Reaching the sandbox | HTTPS preview URLs on any port, token-protected or public; SSH; no raw TCP or public IP | HTTPS URL per port, public unless you add a token or basic auth; SSH through a gateway; no raw TCP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv6 or IPv4 |
| Outbound internet | Tier 1 and 2 reach only package registries, git hosts and AI APIs; Tier 3 and up get open internet plus domain or CIDR allowlists | Allow all, deny all, or allow and deny by domain and CIDR, changeable on a running box | Open internet on every plan; no provider-side allowlist |
| Coding agents | Guides install agents and run them through process exec | Claude Code, Codex and OpenCode built in, with run and stream APIs, webhooks and scheduled prompts | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets proxy swaps placeholders in HTTPS request headers for allowed hosts | Host proxy injects headers into outbound HTTPS on port 443, set when the box is created | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| GPUs and Windows | Nvidia and AMD GPUs by the hour, and Windows VM sandboxes | None | No GPUs and no Windows guests; Wine for Windows apps |
| Regions | US and EU, plus dedicated regions or your own machines | US only (AWS us-east-1) | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Daytona | Upstash Box | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | Yes | 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 | Yes | 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 | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | No | 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, and Upstash Box has no result in that benchmark, so there is no comparable number for either.
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). Upstash Box 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 | Upstash Box, 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) | $21 · 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) | $21 · 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) | $900 · 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 | $306 · Pay as You Go | $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,822 · Pay as You Go | $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 with $200 of free compute to start: open internet needs a $500 top-up (Tier 3), and the biggest pool needs $2,000 every 30 days (Tier 4).
Upstash Box: A standard box is billed for the CPU it actually uses, at $0.10, $0.20 or $0.40 per active CPU hour for Small, Medium and Large, plus $0.10 per GB-month of storage, and RAM is free. A keep-alive box costs a flat $8, $16 or $32 a month whether it is busy or not.
Upstash Box: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. 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, so 300 user sandboxes (600 vCPU) and 1,000 short jobs at once do not fit without a custom limit, and Tier 1 and 2 reach only an allowlist of services. Upstash runs 1,000 boxes at once by default, but it has no Docker inside a box, so the 50-agent scenario with Docker does not fit there. Neither publishes an egress price. bochka queues the 1,000-job burst, since even the $2,000 plan starts at most 2,400 sandboxes a day.
| Scenario | Daytona | Upstash Box | 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, pause with memory kept, or must run in the EU, the US or on your own machines.
- GPUs by the hour. Useful if your agents train or test models: Daytona rents Nvidia and AMD GPUs, from RTX 4090 to B300, and Upstash has none.
- Windows and memory pause. Useful if you need Windows desktops, or a sandbox that pauses and comes back with its memory, which Daytona's VM classes do.
- More places to run. Daytona runs in the US and the EU and on your own machines, while Upstash Box runs only in AWS us-east-1.
Use Upstash Box when
your agents mostly wait, need to wake on an incoming request, must stay inside a strict outbound allowlist, or must run in the US.
- Idle costs no CPU, and a request wakes the box. Good for agents that wait a lot: an idle box costs no CPU, RAM is free, and a request to its URL wakes it.
- Network rules on every box. Useful when an agent may only reach a few domains: Upstash sets allow and deny rules on any box, while Daytona's start at Tier 3.
- Big bursts out of the box. Runs 1,000 boxes at once by default, so the 1,000-job burst fits on Upstash but goes past Daytona's Tier 4 pool.
Where bochka fits
If your agents do real work for hours, with installs, builds, tests, Docker and emulators, look at bochka. Every bochka sandbox is a full, faster VM with a desktop, hosting and coding agents built in, so you skip Daytona's class choices and Upstash's container limits.
A full VM with Docker and /dev/kvm
An Upstash box is itself a container with no Docker inside, so the 50-agent scenario does not fit there. Daytona's default container shares the host kernel, and /dev/kvm needs its Linux VM class with KVM turned on for your organization.
Faster CPU in the same test
In the same public run at 4 vCPU / 8 GB, bochka did 26.69 runs per second and Daytona's Linux VM class did 21.52, so every build waits longer there. Upstash Box and Daytona's default containers have no measured result.
Room on disk, kept across stops
Upstash disks stop at 20 GB and Daytona starts each sandbox at 10 GiB unless you raise the limit, and both keep billing storage while stopped or paused. bochka gives 50 GB at 4 vCPU / 8 GB, saves it every minute, and stops cost nothing.
Use bochka when your agents need a real machine for hours: Docker, emulators, a desktop, a big disk and hosting, on a full VM that measured faster than Daytona's. Compare it one to one: bochka vs Daytona and bochka vs Upstash Box.
Questions people ask
Is Daytona cheaper than Upstash Box?
In most scenarios we priced, no. One coding agent on workdays comes to $56 a month on Daytona against $21 on Upstash, and one agent running all month comes to $245 against $21. bochka comes to $20 and $26 for the same two.
Which is faster, Daytona or Upstash Box?
Only Daytona has a number: its Linux VM class did 21.52 runs per second in StarSling's 4 vCPU / 8 GB test. Upstash Box has no result there, so the two cannot be compared. bochka did 26.69 in the same run.
Can Daytona or Upstash Box run Docker?
Daytona runs Docker in all its sandbox classes. Upstash's docs do not offer Docker inside a box, since each box is itself a Docker container. bochka runs Docker, systemd and /dev/kvm on every sandbox.
Are they containers or VMs?
Daytona's default sandbox is a container, with Linux VM and Windows VM classes that have their own kernel. Every Upstash box is a Docker container. Every bochka sandbox is a full VM.
Can I run 1,000 sandboxes at once?
On Upstash, yes: Pay as You Go allows 1,000 boxes at once by default. Daytona's Tier 4 pool stops at 500 vCPU, so 1,000 jobs of 2 vCPU need a custom limit. bochka queues that burst by its start limits.
Where do Daytona and Upstash Box run?
Daytona runs in the US and the EU, plus dedicated regions and your own machines. Upstash Box runs in AWS us-east-1 only, with more regions planned. bochka runs in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview