bochka vs Vercel Sandbox
Both give each sandbox its own kernel. bochka is built for agents that work for hours on one machine, with a desktop, a browser and an API to drive them; Vercel Sandbox is built for short runs of untrusted code in 19 regions around the world.
Where bochka stands out
Agents can work all day
On paid plans a bochka machine runs as long as you want, with no session cap, and saves its files every minute. Vercel stops each session after 24 hours, and its docs say sandboxes are not designed to run continuously.
A desktop and a browser built in
Every bochka sandbox can stream a 60fps desktop with Chromium, and you get computer-use and browser-control APIs. That lets an agent open the app it built and check it. Vercel Sandbox is headless only.
Drive the agents inside from outside
bochka runs Claude Code, Codex and five other agents in the sandbox and gives you one API to prompt them, steer them and stream their events. On Vercel the agents are installed, but you run them as plain commands and build that layer yourself.
The companies and products
bochka
bochka.xyz runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.
You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.
- Isolation
- Full VM per sandbox, own kernel
- Regions
- EU: Germany, Finland, France
Vercel Sandbox
Vercel is a cloud platform for web apps and agents, and Vercel Sandbox is its product for running untrusted or agent-written code in isolated Linux microVMs.
Each sandbox is a Firecracker microVM with its own kernel, started from a Vercel image, your own OCI image, or a saved snapshot. You drive it with the JavaScript or Python SDK or the sandbox CLI: run commands, move files, open ports, and set network rules. It is aimed at code interpreters, app builders, test runs and agent tools, and Vercel's docs say it is not meant to run nonstop.
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. “3rd cheapest of 367” means 2 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 | bochka: price rank | Vercel Sandbox: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Vercel has no desktop or browser for an agent to check the UI it built, no nested virtualization, and each session stops after 24 hours, so it only fits with workarounds. | 3rd cheapest of 367 $634 a month | 244th of 367, with limits $3,351 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Vercel's docs say sandboxes are not designed to run continuously; bochka machines can run with no session cap and keep their disk. | 5th cheapest of 366 $657 a month | 257th of 366, with limits $3,657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Vercel fits short code bursts better: it bills CPU only while code uses it, and bochka's per-plan start limits slow down large bursts. | 186th of 345, with limits $2,000 a month | 22nd cheapest of 345 $216 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Both fit sandboxes for your own users; bochka ranks first and Vercel ranks 15th on cost for the same work. | Cheapest of 361 $209 a month | 15th cheapest of 361 $1,267 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Vercel fits many short parallel rollouts well thanks to high concurrency and fast starts; bochka's start limits make it a compromise here. | 34th of 360, with limits $2,000 a month | 3rd cheapest of 360 $15,761 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 10th cheapest of 364 $200 a month | 69th cheapest of 364 $1,508 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month | 4th cheapest of 377 $86 a month | 107th cheapest of 377 $1,144 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box that stays up all day fits bochka; on Vercel it restarts every 24 hours and loses its running processes. | 18th cheapest of 368 $26 a month | 276th of 368, with limits $145 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month bochka streams a 60fps desktop with a computer-use API; Vercel Sandbox has no desktop, so you would have to build one yourself. | 6th cheapest of 369 $200 a month | 235th of 369, with limits $952 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month bochka ships Chromium with browser control; Vercel Sandbox has no browser feature. | 7th cheapest of 367 $200 a month | 259th of 367, with limits $486 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 6th cheapest of 346 $90 a month | 277th of 346, with limits $468 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 71st of 338, with limits $1,800 a month | 234th of 338, with limits $9,960 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 2nd cheapest of 360 $200 a month | 283rd of 360, with limits $554 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 |
| 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 |
Key features
| Feature | bochka | Vercel Sandbox |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Firecracker microVM with its own kernel |
| Longest session | No cap on paid plans (--no-auto-stop); default TTL 1 hour, changeable | 24 hours per session on Pro and Enterprise, 45 minutes on Hobby; resume starts a new session |
| Saving files | Snapshot every minute while running and on stop; a stopped sandbox costs nothing | Filesystem snapshot on stop, stored at a per-GB monthly rate and kept 30 days after last use by default |
| Memory on resume | Not kept; the machine reboots with its disk | Not kept; a new session boots from the snapshot |
| Desktop, browser, computer use | 60fps desktop and Chromium, computer-use and browser-control APIs, embeddable stream | None; headless Linux only |
| Nested virtualization | Yes, /dev/kvm (Android emulator, VMs) | No |
| Docker inside | Yes, with root and systemd | Yes, with sudo |
| Custom images | Named snapshots (templates), shareable by code; no Dockerfile builds | Your own OCI images from a Dockerfile, via Vercel Container Registry |
| Coding agents | Claude Code, Codex, pi, OpenCode, Prime Agent, Kimi Code, Mistral Vibe, with an API to prompt, steer and stream events | Claude Code, Codex, OpenCode and pi preinstalled; you start them as commands |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv6 or IPv4 | Public URLs for up to 15 ports, no built-in auth; no raw TCP or public IP |
| Egress rules | No provider-side allowlist; firewall inside the VM | Allow-all, deny-all or a domain and CIDR allowlist, changeable while running; static IPs and VPC peering on Enterprise |
| Keys kept outside the sandbox | Credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when one runs out | Credentials brokering injects headers for any HTTPS domain you allow |
| Regions | EU only: Germany, Finland, France | 19 regions across the US, Europe, Asia, South America, Africa and Australia |
| Usage per sandbox | Usage API per sandbox, scoped API keys, spend limits | Usage dashboard; spend alerts that can pause projects |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | SOC 2 |
Every feature Battleships tracks (43)
| Feature | bochka | Vercel Sandbox |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | No |
| Root | Yes | Yes |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | No |
| Browser | Yes | No |
| Computer-use API | Yes | No |
| SSH | Yes | No |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| Fork/clone | Yes | Yes |
| Live fork (no pause) | Yes | Yes |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | No |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | No |
| Public IPv4 | No | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | Yes |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | No |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Yes |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Not published |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | Yes |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
Both were measured on the same hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB. bochka did 26.69 runs per second and Vercel Sandbox did 12.96, so bochka finished about twice as many runs 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.
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 | bochka, a month | Vercel Sandbox, 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 | $20 · $20/mo | $57 · Pro |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $236 · Pro · with limits |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $317 · $20/mo × 3 seats | $2,884 · Pro |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $200 · $100/mo × 2 seats | $828 · Pro |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · $2000/mo · with limits | $3,152 · Pro |
bochka: bochka charges a flat price per size, per second, only while the machine runs; a stopped sandbox costs nothing. Plans start at $20 a month, and all of the fee is usage credit.
Vercel Sandbox: Vercel charges for CPU only while your code uses it, but charges for memory for the whole time the sandbox runs, idle time included, plus a small fee per sandbox created and a monthly fee per GB of snapshots. Rates are lowest in the US regions and higher elsewhere, and the $20 Pro credit is shared with your other Vercel usage.
Limits in those scenarios
For one agent that never stops, Vercel ends each session at 24 hours; the sandbox resumes from its snapshot, but running processes start over. For 1,000 short jobs at once, bochka does not fit: even the $2,000 plan allows 600 starts an hour and 2,400 a day, and bursts above 90 starts a minute wait in a queue. Vercel fits that burst, though its vCPU allocation starts at 150 a minute and climbs toward 5,000 with steady use. On Pro, one Vercel sandbox can be at most 8 vCPU / 16 GB.
| Scenario | bochka | Vercel Sandbox |
|---|---|---|
| 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 | None that bite |
| Sandboxes for your users | None that bite | None that bite |
| 1,000 short jobs at once |
| None that bite |
Which one should you use?
Use Vercel Sandbox when
you run many short bursts of untrusted code, or need to run close to users outside Europe.
- Regions all over the world. Useful if your users are far from Europe: Vercel Sandbox runs in 19 regions, from Virginia to Tokyo and Sydney.
- A firewall you control from outside. A running sandbox can be switched to deny-all, or to a list of allowed domains, without a restart.
- Images from your Dockerfile. Useful if you already have a Dockerfile: you can build it into an image and boot sandboxes straight into it.
Use bochka when
your agents work for hours on one machine: builds, tests, Docker, emulators and a desktop with a browser, with an API to drive the agents inside from outside.
- Agents can work all day. On Vercel each session stops at 24 hours and the resumed sandbox starts every process over, so a long build, test run or agent task is cut off in the middle.
- A desktop and a browser built in. Without a screen an agent cannot open the web app it just built to see if it works, so broken pages reach you instead. On Vercel you would have to build that desktop yourself.
- Drive the agents inside from outside. Without that API you write and maintain the code that starts each agent, sends it prompts, steers it and reads its output, for every agent you support.
Questions people ask
Is bochka cheaper than Vercel Sandbox?
bochka costs less in all five of our scenarios, though two come with a catch. One workday agent costs $20 a month on bochka vs $57 on Vercel, 50 parallel agents cost $317 vs $2,884, and sandboxes for your users cost $200 vs $828. One agent that never stops costs $26 on bochka; on Vercel it costs $236 and still restarts every 24 hours. For 1,000 short jobs at once, bochka's $2,000 plan still hits its start limits, while Vercel fits at $3,152.
Can Vercel Sandbox run 24/7?
Not as one session. Pro and Enterprise sessions last up to 24 hours, then stop; the sandbox can resume from its filesystem snapshot, but processes and memory start fresh. Vercel's docs say sandboxes are not designed to run continuously.
Does Vercel Sandbox have a desktop or browser for computer use?
No. It is a headless Linux microVM that you control with commands, files and ports. bochka includes a 60fps desktop, Chromium, and computer-use and browser-control APIs.
Are both real virtual machines?
Yes. Vercel runs each sandbox in a Firecracker microVM with its own kernel, and bochka runs each one as a full VM with its own kernel. bochka also exposes /dev/kvm, so you can run Android emulators or VMs inside; Firecracker does not offer nested virtualization.
Where do they run?
Vercel Sandbox runs in 19 regions around the world, with iad1 in the US as the default. bochka runs only in the EU (Germany, Finland and France) and keeps data in the EU, with a zero data retention option.
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.
Start a sandbox
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs E2B
- bochka vs Daytona
- bochka vs Modal
- bochka vs Blaxel
- bochka vs Runloop
- bochka vs Tensorlake
- bochka vs Cloudflare Sandbox
- bochka vs Agent 37
- bochka vs exe.dev
- bochka vs Oracle Cloud
- bochka vs IONOS Cloud
- bochka vs Browser Use
- E2B vs Vercel Sandbox
- Daytona vs Vercel Sandbox
- Modal vs Vercel Sandbox
- Vercel Sandbox vs Cloudflare Sandbox
- Vercel Sandbox vs Blaxel
- Vercel Sandbox vs Runloop
- Vercel Sandbox vs Tensorlake
- Vercel Sandbox vs Morph Cloud