Deno Sandbox vs Upstash Box
Deno Sandbox gives code a small Firecracker microVM that starts in under 200 ms and lives up to 30 minutes. Upstash Box gives an agent a container that pauses when idle, keeps its files and wakes on the next request.
The companies and products
Deno Sandbox
Deno Sandbox is part of Deno Deploy, the hosting platform from the company behind the Deno runtime, and runs untrusted or AI-generated code in Linux microVMs.
Each sandbox is a Firecracker microVM with 2 vCPU, up to 4 GB of memory and a 10 GB disk that is wiped when it ends, created from a TypeScript or Python SDK. Outbound traffic goes through a proxy that can enforce a host allowlist and swap placeholder secrets for real ones. It is built for short runs of agent or user code, and a sandbox can be promoted to a Deno Deploy app.
- Isolation
- Firecracker microVM per sandbox
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. “290th cheapest of 367” means 289 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 | Deno Sandbox: 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 A software factory runs builds for hours, which outlasts Deno's 30-minute lifetime, and needs Docker, which an Upstash box, itself a container, does not offer; bochka has both. | 290th of 367, with limits $5,665 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 An assistant that stays on all month fits an Upstash keep-alive box better than a Deno sandbox that ends after 30 minutes; bochka gives it a full VM with systemd and a desktop. | 287th of 366, with limits $5,803 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 Both suit short code runs: Deno starts in under 200 ms and bills CPU only while code runs, and an idle Upstash box costs no CPU. | 141st of 345, with limits $329 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 allows 1,000 boxes at once and wakes a paused box on a request, while Deno Builder stops at 20 sandboxes at once per region. | 148th of 361, with limits $1,863 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 | 122nd of 360, with limits $7,963 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 | 296th of 364, with limits $1,563 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 CI jobs that build containers or boot Android emulators need Docker and /dev/kvm, which neither Deno nor Upstash documents and bochka has. | 304th of 377, with limits $731 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 dev box that stays on needs files that survive, which an Upstash keep-alive box gives at a flat price and a Deno sandbox does not by default. | 179th of 368, with limits $200 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 Neither has a desktop: Deno has no browser and Upstash has a headless Chromium, while bochka streams a Linux desktop at 60fps. | 280th of 369, with limits $1,583 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 Upstash ships a managed headless Chromium with AI page actions; on Deno you would install a browser yourself in 4 GB of memory. | 284th of 367, with limits $783 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 | 286th of 346, with limits $573 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 | 247th of 338, with limits $11,923 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 | 251st of 360, with limits $367 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 | Can't run it | 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 | Deno Sandbox | Upstash Box | bochka |
|---|---|---|---|
| Isolation | Firecracker microVM with its own kernel | Docker container per box on AWS | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | 2 vCPU fixed, 768 MB to 4 GB memory | Small 2 vCPU / 4 GB, Medium 4 vCPU / 8 GB, Large 8 vCPU / 16 GB | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB on the $100 plan and above |
| Disk | 10 GB, wiped when the sandbox ends; opt-in volumes of 300 MB to 20 GB, Chicago only | 5, 10 or 20 GB by size, kept while paused, billed per GB-month | 50 GB at the default size, 12 to 251 GB by size, saved every minute and on stop |
| Session length | Up to 30 minutes; longer work can be promoted to a Deno Deploy app | No cap documented; pauses when idle, keep-alive boxes stay on all month | No cap on paid plans; you set the time to live |
| Stop and resume | No pause; a new sandbox starts fresh | Pauses itself when idle and wakes when a request reaches its URL | Stop and start by API; a stopped sandbox costs nothing and keeps its disk |
| Snapshots and fork | Read-only snapshots of a volume that new sandboxes can boot from | Snapshot a running box and start many new boxes from it | Automatic disk snapshots; fork a running sandbox with its disk |
| Docker and nested virtualization | Root access; Docker and nested virtualization not documented | No Docker inside documented; the box is itself a container, no VM support | Docker, systemd and /dev/kvm for Android emulators and VMs |
| Desktop and browser | No desktop or browser; a VS Code editor in the browser and SSH | Managed headless Chromium with AI page actions and CDP; no desktop | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Coding agents | A root image with Claude Code, run through the shell command API | Claude Code, Codex and OpenCode built in, with run and stream APIs, webhooks and scheduled prompts | Seven agents preinstalled, with a prompt, steer and events API |
| Inbound access | HTTPS URL per exposed port, public without authentication; SSH | HTTPS URL per port, public unless you add a token or basic auth; SSH through a gateway | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Outbound rules | Host allowlist per sandbox, enforced by a proxy outside the VM | Allow all, deny all, or allow and deny by domain and CIDR, changeable on a running box | Open internet, no provider-side allowlist |
| Keeping API keys out of the sandbox | Secrets swapped in on outbound requests to approved hosts; the sandbox only sees a placeholder | 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 |
| Boxes at once | 3 per region on Pro, 20 per region on Builder | 10 on Free, 1,000 on Pay as You Go, raised on request | Start rate set by plan, up to 90 starts a minute on the top plan |
| Regions | Amsterdam and Chicago | US only (AWS us-east-1) | EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Deno Sandbox | Upstash Box | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Not published | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | No | Yes | Yes |
| Idle auto-stop | No | 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 | No | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Not published | Not published | No |
| SSO | No | 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
There is no comparable measurement for either. Neither Deno Sandbox nor Upstash Box has a result in the StarSling hpc-sandbox-benchmarks CPU test, and Deno's fixed 2 vCPU shape could not run the 4 vCPU test as set up. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Deno Sandbox and Upstash Box have 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 | Deno Sandbox, 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 | $53 · Pro · with limits | $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 | $200 · Builder · with limits | $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,779 · Builder · with limits | $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 | $783 · Builder · 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 | $1,563 · Builder · with limits | $1,822 · Pay as You Go | $2,000 · $2000/mo · with limits |
Deno Sandbox: Sandboxes need the Pro plan at $20 a month or Builder at $200 a month, which include CPU, memory and egress allowances shared with Deno Deploy apps. Past those, CPU costs $0.10 per hour of active CPU time and memory $0.025 per GiB-hour for the whole life of the sandbox.
Upstash Box: There is no fee: a standard box bills $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.
Upstash Box: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Deno Sandbox fits none of the five scenarios as written: a sandbox lives up to 30 minutes, is fixed at 2 vCPU with up to 4 GB, and Builder allows 20 at once per region. Upstash fits four of them but not 50 agents with Docker inside, and its egress price is not published. bochka fits four; at 1,000 short jobs at once its top plan queues starts above 90 a minute, so Upstash is the only one of the three that fits that burst.
| Scenario | Deno Sandbox | 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 Deno Sandbox when
you run short pieces of untrusted code that must start in milliseconds inside their own microVM, reach only hosts you allow, or ship onward to Deno Deploy.
- Starts in under 200 ms. Good for one sandbox per request: Deno says a sandbox starts in under 200 ms, and CPU bills only while code runs.
- A VM boundary with a strict allowlist. For untrusted code that needs its own kernel: each Firecracker microVM can be limited to a list of hosts, enforced outside the VM.
- Two regions and a path to Deno Deploy. Fits teams on Deno Deploy: sandboxes run in Amsterdam or Chicago and can be promoted to a Deploy app.
Use Upstash Box when
your agents mostly wait, need their files kept between runs, should wake on an incoming request, or run in large numbers in the US.
- Files that stay and a box that wakes. Good for agents that wait a lot: a box pauses when idle, keeps its files and wakes when a request arrives.
- Bigger boxes and many at once. Fits larger jobs and fleets: boxes go up to 8 vCPU / 16 GB, and 1,000 can run at once by default.
- Agents built in. For teams that want an agent API: Claude Code, Codex and OpenCode come with run, stream, webhook and scheduled prompt APIs.
Where bochka fits
Deno Sandbox is built for short, locked-down runs, and Upstash Box for light agents that sleep between requests. If your agents run builds, Docker, emulators or a browser they can see, for hours at a time, look at bochka: a full VM whose disk is still there tomorrow.
A whole Linux machine
Neither Deno nor Upstash documents Docker inside, and neither offers nested virtualization, so an agent that starts a database in Docker or boots an Android emulator gets stuck. bochka runs Docker, systemd and /dev/kvm in every sandbox.
Work that outlasts 30 minutes
A Deno sandbox ends after 30 minutes and wipes its 10 GB disk, so long jobs must be split and rebuilt. Upstash keeps files, but disks stop at 20 GB. bochka has no cap on paid plans and saves a disk of up to 251 GB every minute.
A screen the agent can see
Deno has no browser and Upstash has only a headless Chromium driven over CDP, so desktop apps and a human watching along are out of reach. bochka streams a Linux desktop at 60fps with Chromium and computer-use tools.
Use bochka when your agents do real work for hours: Docker, emulators, a desktop and a big disk, on a full VM that keeps every file across stops. Compare it one to one: bochka vs Deno Sandbox and bochka vs Upstash Box.
Questions people ask
Is Deno Sandbox cheaper than Upstash Box?
Usually not. For one coding agent on workdays Upstash comes to $21 a month against $53 on Deno, and for one agent that never stops $21 against $200. Deno does not fit any of the five scenarios as written, because of its 30-minute lifetime, 2 vCPU size and concurrency caps.
Which is faster, Deno Sandbox or Upstash Box?
Neither has a result in the hpc-sandbox-benchmarks CPU test, so there is no fair speed comparison. Deno says a sandbox starts in under 200 ms; bochka did 26.69 runs per second on that test at 4 vCPU / 8 GB.
Can Deno Sandbox or Upstash Box run Docker?
Deno's docs give root access but do not say Docker works inside. An Upstash box is itself a Docker container, its docs do not offer Docker inside, and custom images are listed as coming soon. bochka runs Docker, systemd and /dev/kvm.
How long can each one run?
A Deno sandbox lives up to 30 minutes and its root disk is wiped when it ends. An Upstash box has no documented cap: it pauses when idle and resumes with its files, and a keep-alive box stays on all month. bochka has no session cap on paid plans.
Where do they run?
Deno Sandbox runs in Amsterdam and Chicago, with volumes only in Chicago. Upstash Box runs in AWS us-east-1 only. bochka runs in the EU, in Germany, Finland and France.
Is bochka SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.
Try bochka
Install the CLI, then run bochka new.
Product preview