bochka vs boxes.dev
boxes.dev is an app where you chat with Codex or Claude Code, and each agent works on its own cloud devbox. bochka is a sandbox platform you drive from code: every sandbox is a full VM with root, Docker and /dev/kvm, real keys stay out of it, and one plan runs a hundred machines at once.
Where bochka stands out
Fleets you run from code
On bochka you create, fork and stop VMs from an API, and one $20 plan runs 100 sandboxes at once. boxes.dev counts awake devboxes per person: 4 on Starter and 10 on Pro, and each seat must belong to a real user.
Real keys never enter the sandbox
bochka's AI credentials proxy adds your keys to requests for model providers and any HTTPS API you register, so the sandbox never holds them. When an account runs out of credits, bochka can switch the credential to another account of the same type.
Host real services
bochka gives each sandbox token-protected HTTPS URLs on up to 50 ports, raw TCP, and a dedicated IPv6 or IPv4. boxes.dev shares one HTTP port at a time through a public link that anyone holding it can open.
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
boxes.dev
boxes.dev, from Boxes, Inc., gives every coding agent its own cloud computer, called a devbox, that you manage from a desktop app, a phone or a terminal.
It is a different kind of product from bochka: an app for developers who work with agents, not a sandbox API. You set up a project once on a Template box, then each chat thread gets a devbox copied from it, where Codex or Claude Code runs on your own subscription. Devboxes sleep when idle and wake when you come back, and you pay per seat with a pool of box-hours.
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 | boxes.dev: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month boxes.dev allows 4 or 10 awake devboxes per paid seat, so a software factory of many agents needs many real users, while one bochka plan runs 100 sandboxes at once. | 3rd cheapest of 367 $634 a month | 325th of 367, with limits $7,381 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 5th cheapest of 366 $657 a month | 60th of 366, with limits $18,882 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month | 186th of 345, with limits $2,000 a month | 321st of 345, with limits $1,916 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month boxes.dev is built for your own team, not for handing machines to your users through an API, so it fits this only as a compromise. | Cheapest of 361 $209 a month | 332nd of 361, with limits $6,223 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 34th of 360, with limits $2,000 a month | 319th of 360, with limits $29,782 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 | 314th of 364, with limits $2,448 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month boxes.dev has no API to create machines on demand for jobs; bochka starts a VM per job from code, with Docker and /dev/kvm inside. | 4th cheapest of 377 $86 a month | 335th of 377, with limits $1,389 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both fit a dev box you keep: boxes.dev sleeps it after 5 to 60 idle minutes, your choice, with memory kept, and bochka keeps the disk with snapshots every minute and charges nothing while it is stopped. | 18th cheapest of 368 $26 a month | 110th cheapest of 368 $326 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month boxes.dev has a shared browser for reviewing pages with the agent, but no graphical desktop or computer-use API; bochka streams a 60fps desktop with Chromium. | 6th cheapest of 369 $200 a month | 309th of 369, with limits $2,208 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 7th cheapest of 367 $200 a month | 146th of 367, with limits $2,208 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month Scrapers need machines that run around the clock with their own IP; boxes.dev bills every awake hour against a seat's box-hours. | 6th cheapest of 346 $90 a month | 144th of 346, with limits $2,874 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 | 320th of 338, with limits $58,449 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Running many attackers at once needs many machines awake together, which boxes.dev caps per person and bochka counts per plan. | 2nd cheapest of 360 $200 a month | 89th of 360, with limits $1,473 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
Every feature Battleships tracks (43)
| Feature | bochka | boxes.dev |
|---|---|---|
| Full VM (own kernel) | Yes | Not published |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | Not published |
| Root | Yes | Not published |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | No |
| Browser | Yes | Yes |
| Computer-use API | Yes | No |
| SSH | Yes | Yes |
| 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 | Yes |
| Wake on request | No | Yes |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | Not published |
| Public IPv4 | No | No |
| Egress allowlist | No | No |
| Secret proxy | Yes | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | Yes |
| MCP server | No | No |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | Not published |
| Self-hosting | No | No |
| BYOC | No | Yes |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Yes |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Yes |
| SSO | No | Yes |
| SOC 2 | No | No |
| HIPAA | No | No |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement for boxes.dev: it was not in the public benchmark we use. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's run of 2026-09-29, on dedicated AMD Ryzen 9 9950X (Zen 5) hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. boxes.dev 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 | bochka, a month | boxes.dev, 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 | $99 · Pro |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $343 · Pro |
| 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 | $4,899 · Pro · with limits |
| 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 | $2,748 · Pro · with limits |
| 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 | $5,916 · Pro · with limits |
bochka: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
boxes.dev: You pay per paid seat: Starter at $19 includes 40 box-hours per user and Pro at $99 includes 250. After that each awake hour of a default 4 vCPU / 8 GiB devbox costs $0.75 on Starter or $0.60 on Pro from prepaid credits, bigger machines burn up to about 2.78 box-hours an hour, and sleeping devboxes are free.
Limits in those scenarios
The limit that bites on boxes.dev is awake devboxes per person: 10 on Pro. That is why 50 agents in parallel, 300 sandboxes for your users and 1,000 short jobs at once do not fit one seat, and the seats you add must go to real people. On bochka the limit is a sandbox count per plan (100 to 2,000) plus starts per minute, so the 1,000-job burst gets queued and needs more starts per day than the $2,000 plan allows. boxes.dev also does not publish an egress price.
| Scenario | bochka | boxes.dev |
|---|---|---|
| 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 boxes.dev when
you are a few developers who want to chat with Codex or Claude Code from a desktop, a phone, Slack or Linear, each on its own devbox, without writing any code.
- An app made for people working with agents. Useful if your team wants to chat with agents from a desktop, a phone, Slack or Linear, with no code to write.
- Sleep that keeps memory. Useful if you want an idle machine to doze off and come back with every process still running when you return.
- Team controls and your own cloud. Useful for teams that need SCIM, roles, Tailscale into private services, or machines in their own cloud account.
Use bochka when
you run agents from your own code: many at once, each on a full VM with root, Docker and /dev/kvm, hosting real services, with real keys kept out of the machine.
- Fleets you run from code. Fifty agents in parallel do not fit one boxes.dev Pro seat, which allows 10 awake devboxes. You would need five people on Pro seats, each with their own limit, to run them.
- Real keys never enter the sandbox. On boxes.dev, environment files are plaintext on the devbox, and its own docs say agents on the machine can read them. One prompt injection can copy them out.
- Host real services. A database, a game server or an SSH-based tool needs raw TCP, which boxes.dev share links do not carry. Its public links have no login, so your app must add its own.
Questions people ask
Is bochka cheaper than boxes.dev?
In the scenarios we priced, yes: one coding agent on workdays comes to $20 a month on bochka and $99 on boxes.dev Pro, and one agent running all month comes to $26 against $343. 50 agents in parallel come to $317 on bochka against $4,899, and that still does not fit one Pro seat.
Is boxes.dev a sandbox API like bochka?
No. boxes.dev is an app where you work with coding agents in threads, and each thread gets its own devbox. It has a CLI and an HTTP trigger to start agent runs, but no API to create and manage machines for your own product. bochka is built for that.
Can I use my Claude or Codex subscription?
On boxes.dev, yes: it runs Codex and Claude Code with your own subscription or API key. bochka also ships Claude Code, Codex, pi, OpenCode and more in every sandbox, and its credentials proxy keeps the real keys out of the machine.
How many agents can run at once?
boxes.dev allows 4 awake devboxes per paid seat on Starter and 10 on Pro, plus the Template box, and asks that seats go to real users. bochka runs 100 sandboxes at once on the $20 plan and up to 2,000 on higher plans.
Where does my data run?
bochka runs only in the EU (Germany, Finland and France), with EU data residency and a zero data retention option. boxes.dev does not publish regions, and its privacy policy says data may be processed in the United States.
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