Upstash Box vs Modal VM Sandboxes
Upstash Box gives each agent a light container that pauses when idle, keeps its files and wakes on the next request. Modal VM Sandboxes give each agent a real Linux VM with Docker and systemd, but it ends within 24 hours and only Volumes and snapshots keep files.
The companies and products
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.
Modal VM Sandboxes
Modal is a serverless cloud for AI work, and VM Sandboxes are the version of its sandboxes that run in a virtual machine with their own Linux kernel.
You create a VM Sandbox from Python, TypeScript or Go code with runtime="vm", run commands in it, and terminate it when the job is done. Modal built the runtime on the Rust-based Cloud Hypervisor, so Docker, FUSE, systemd and nested cgroups work, with the same API, images and prices as its gVisor sandboxes. It became generally available on 1 October 2026 and suits teams that want many short-lived agent machines next to Modal's inference and training.
- Funding
- Over $466M raised
- Generally available
- 1 October 2026; early customers launched over 20 million VMs before that
- Session length
- Default 5 minutes, maximum 24 hours
- Compliance
- SOC 2 on every plan; HIPAA on Enterprise
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. “10th cheapest of 345” means 9 of the other 344 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 | Upstash Box: price rank | Modal VM Sandboxes: 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 needs Docker for databases and test services: Modal's VM runs it but ends within 24 hours, Upstash's container does not run it, and bochka runs Docker in a VM that keeps its disk. | 61st of 367, with limits $464 a month | 84th of 367, with limits $759 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 103rd of 366, with limits $475 a month | Can't run it | 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 Upstash well, since an idle box costs no CPU and a paused box wakes when work arrives. | 10th cheapest of 345 $119 a month | Can't run it | 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 Users who come back to the same sandbox fit Upstash and bochka, which both keep files between visits, while a Modal VM is gone once it finishes. | 2nd cheapest of 361 $222 a month | Can't run it | 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 Huge bursts of short rollouts are what Modal is built for, with 5,000 containers at once on Team, while bochka queues large bursts of starts. | 352nd of 360, with limits $8,068 a month | 171st of 360, with limits $16,322 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 | 52nd cheapest of 364 $1,011 a month | Can't run it | 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 container images need Docker, which Modal's VM and bochka run and an Upstash container does not; bochka also has /dev/kvm on every plan for Android emulators. | 120th cheapest of 377 $1,520 a month | 188th of 377, with limits $1,064 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 all month fits Upstash's flat-price keep-alive box and bochka, while a Modal VM stops at 24 hours. | 10th cheapest of 368 $20 a month | Can't run it | 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 Computer-use agents need a screen: Upstash has only a headless browser, Modal leaves you to set up Xvfb and VNC, and bochka streams a Linux desktop at 60fps. | 73rd of 369, with limits $76 a month | Can't run it | 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 | 49th of 367, with limits $38 a month | Can't run it | 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 | 37th cheapest of 346 $400 a month | Can't run it | 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 | 200th of 338, with limits $8,000 a month | Can't run it | 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 Parallel red-team agents often need Docker and a machine that lasts, which bochka gives every sandbox, while Upstash has no Docker inside and Modal ends each VM within a day. | 225th of 360, with limits $259 a month | 294th of 360, with limits $642 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 | Upstash Box | Modal VM Sandboxes | bochka |
|---|---|---|---|
| Isolation | Docker container per box on AWS | VM with its own Linux kernel on Cloud Hypervisor | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Docker and systemd inside | Not documented; the box is itself a Docker container, and custom images are listed as coming soon | Yes; you start dockerd yourself as the entrypoint | Yes, Docker and systemd run in every sandbox as on any Linux server |
| Nested virtualization | No; no VM support documented | Team and Enterprise plans only, on request | Yes, /dev/kvm on every plan for Android emulators and VMs |
| CPU benchmark (4 vCPU / 8 GB) | No result in the benchmark | 15.54 runs/s | 26.69 runs/s |
| Longest session | No cap documented; a box pauses when idle and resumes later, and a keep-alive box stays on | 24 hours (default 5 minutes); continue with a filesystem snapshot | No cap on paid plans; you set the time to live |
| Stop and resume | Pauses itself when idle and keeps its files; storage keeps billing while paused | No paused state; a finished sandbox is gone, only Volumes and snapshots keep files | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Wake on request | Yes; a request to a public URL resumes a paused box and waits for the app | No | No; a stopped sandbox is started by API |
| Fork and snapshots | Snapshot a running box and start many new boxes from it | Filesystem snapshots into an image; memory snapshots in alpha, which end the sandbox | Fork a running sandbox with its disk |
| Desktop and browser | Managed headless Chromium with AI page actions and CDP; no desktop | Not offered; an example shows how to set up Xvfb and VNC yourself | Linux desktop streamed at 60fps, Chromium and a computer-use API |
| Coding agents | Claude Code, Codex and OpenCode built in, with run and stream APIs, webhooks and scheduled prompts | Examples only; you install the agent yourself | Claude Code, Codex and other agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Host proxy injects headers into outbound HTTPS on port 443; set when the box is created | Secrets are environment variables, or you run your own proxy in a sidecar | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Inbound access | HTTPS URL per port, public unless you add a token or basic auth; SSH through a gateway; no raw TCP | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | HTTPS URLs for up to 50 ports, token-protected by default, plus raw TCP |
| Outbound rules | Allow all, deny all, or allow and deny by domain and CIDR, changeable on a running box | Block all, IP-range allowlist, domain allowlist (beta) | Open internet, no provider-side allowlist |
| Regions | US only (AWS us-east-1) | US, EU and Asia-Pacific plus narrower regions; pinning costs 1.15x to 1.75x | EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Upstash Box | Modal VM Sandboxes | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Not published | Yes | Yes |
| Systemd | Not published | Yes | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | No | 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 | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | Yes | No | 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 | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | Not published | Yes |
| Audit logs | Not published | Yes | No |
| SSO | No | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Upstash Box has no result in the hpc-sandbox-benchmarks CPU test, so there is no comparable measurement for it. In the same run at 4 vCPU / 8 GB on 29 September 2026, Modal's VM runtime did 15.54 Node.js build-and-test runs per second and bochka did 26.69, about 1.7 times the CPU work in the same time. This measures CPU speed only, not start time.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal VM Sandboxes measured on: VM Sandbox, request = size. 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 | Upstash Box, a month | Modal VM 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 | $21 · Pay as You Go | $15 · Starter · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $21 · Pay as You Go | $178 · Starter · 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 | $900 · Pay as You Go · with limits | $2,229 · Starter · 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 | $306 · Pay as You Go | $792 · Team | $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,822 · Pay as You Go | $3,193 · Team · with limits | $2,000 · $2000/mo · with limits |
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.
Modal VM Sandboxes: Modal bills by the second for whichever is higher, the CPU and memory you request or what you use, until the sandbox is terminated. Starter is free with $30 of monthly credit, Team is $250 a month with $100 of credit, region pinning multiplies the price by 1.15x to 1.75x, and egress above the free allowance costs $0.04 per GiB.
Modal VM Sandboxes: 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
Upstash does not run Docker inside a box, so the 50-agent scenario does not fit there, its disks stop at 5, 10 or 20 GB, and its egress price is not published. A Modal VM Sandbox lives at most 24 hours and keeps only what you put in a Volume or a snapshot, so the workday, always-on and fleet scenarios do not fit, and its 1,000-job burst relies on shared CPU above the request. bochka's limit is start rate: even the $2,000 plan starts 90 sandboxes a minute and 2,400 a day, so 1,000 jobs at once are queued.
| Scenario | Upstash Box | Modal VM Sandboxes | 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 | None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Upstash Box when
your agents mostly wait, need to wake on an incoming request, run light work without Docker, 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.
- Boxes that stay around. A box keeps its files across pauses with no documented session cap, and a keep-alive box stays on all month for a flat price.
- Coding agents built in. Useful if you want Claude Code, Codex or OpenCode ready in each box, with streaming, webhooks and scheduled prompts.
Use Modal VM Sandboxes when
you need Docker in a real VM for jobs that finish within a day, run huge bursts of them, need regions outside the US, or already run your models on Modal.
- A real kernel for Docker and systemd. Each sandbox is a VM with its own Linux kernel, so Docker, FUSE and systemd work for jobs that need them.
- Very large bursts of short jobs. Useful for huge fan-outs that finish within a day: Team runs 5,000 containers at once, and memory snapshots are in alpha.
- Regions and one AI platform. Runs in the US, EU and Asia-Pacific, next to Modal's inference and training on the same account and bill.
Where bochka fits
Upstash Box and Modal VM Sandboxes each give up something an agent often needs: Upstash gives up Docker and a full machine, and Modal gives up a disk that lasts past 24 hours. If your agents install, build, test and come back to the same machine for days, bochka gives them a full VM with Docker that keeps its disk and has no session cap on paid plans.
Docker and emulators in every sandbox
An agent that runs a database in Docker or builds an image gets stuck on Upstash, whose box is itself a container. Modal runs Docker, but /dev/kvm for emulators comes only on Team or Enterprise after asking support.
A machine that keeps its work
A Modal VM ends within 24 hours and its root disk goes with it, so you write snapshot code or keep files in a Volume. Upstash keeps files, but disks stop at 10 GB on the 4 vCPU size and 20 GB at most.
A desktop the agent can see
Computer-use agents need a screen to look at and click. Upstash offers only a headless Chromium with no desktop, and on Modal you set up Xvfb, VNC and the browser yourself. bochka streams a Linux desktop at 60fps.
Use bochka when your agents need a real machine they come back to: Docker, emulators, a desktop and a big disk that is saved every minute, on a faster VM with no session cap. Compare it one to one: bochka vs Upstash Box and bochka vs Modal VM Sandboxes.
Questions people ask
Is Upstash Box cheaper than Modal VM Sandboxes?
In most of our scenarios, yes: one always-on agent is $21 a month on Upstash against $178 on Modal, and 30,000 short user sandboxes are $306 against $792. For one agent on workdays Modal is a little lower ($15 against $21), but its files reset between days unless you use a Volume.
Which is faster, Upstash Box or Modal VM Sandboxes?
Upstash Box has no result in the hpc-sandbox-benchmarks CPU test, so we cannot compare them. Modal's VM runtime did 15.54 runs per second at 4 vCPU / 8 GB, and bochka did 26.69 in the same run.
Can Upstash Box or Modal VM Sandboxes run Docker?
Modal VM Sandboxes can: each is a VM with its own kernel, and you start dockerd yourself. Upstash's docs do not offer Docker inside a box, which is itself a Docker container. bochka runs Docker and systemd in every sandbox.
How long can each one run?
A Modal VM Sandbox runs 5 minutes by default and 24 hours at most, then you continue from a filesystem snapshot. An Upstash box has no documented cap: it pauses when idle and resumes with its files, and a keep-alive box stays on. bochka has no session cap on paid plans.
Where do Upstash Box and Modal VM Sandboxes run?
Upstash Box runs only in AWS us-east-1, with more regions planned. Modal runs in the US, EU and Asia-Pacific, and pinning a region costs 1.15x to 1.75x. bochka runs in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview