bochka vs exe.dev
bochka and exe.dev both run each machine as a real VM with root, Docker and SSH. bochka adds a live desktop, a snapshot every minute and an API to drive agents inside from outside; exe.dev adds more regions, Docker image boot and team features like SSO.
Where bochka stands out
A screen your agents can use
Every bochka sandbox can show a 60fps desktop with Chromium, and agents can click, type and browse through the computer-use and browser-control APIs. You can embed the live stream in your own app. exe.dev VMs are headless, so agents that need a screen have nothing to look at.
State saved every minute
bochka snapshots a running sandbox every minute and again when it stops, so a crash or a bad agent step loses at most a minute. You can fork a running sandbox and save named snapshots as templates others can start from. exe.dev keeps your disk safe on a second server, but has no snapshots to roll back to.
Drive agents inside from outside
bochka ships seven agent harnesses and one API to prompt them, steer them mid-task and stream their events, with SDKs for TypeScript and Python. exe.dev preinstalls Claude Code, Codex and Pi too, but only its own Shelley agent takes prompts through the API; the others you run through shell commands.
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
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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 | exe.dev: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month bochka fits a software factory fully, with a desktop for checking UIs and snapshots for every agent run; exe.dev runs the code but has no desktop or snapshots. | 3rd cheapest of 367 $634 a month | 253rd of 367, with limits $3,701 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both fit always-on assistants well: each gets its own VM with a disk that lasts, and both can keep it running with no time limit. | 5th cheapest of 366 $657 a month | 15th cheapest of 366 $3,833 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Neither is built as a code interpreter, and both rank low for many tiny runs. | 186th of 345, with limits $2,000 a month | 235th of 345, with limits $175 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month For sandboxes you hand to your own users, bochka fits with token-protected URLs and high concurrency; exe.dev's Personal plan stops at 50 VMs at once. | Cheapest of 361 $209 a month | 257th of 361, with limits $1,226 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 | 265th of 360, with limits $5,250 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 | 283rd of 364, with limits $1,050 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month bochka's per-second billing on running time suits CI; exe.dev pools bill whether jobs run or not, though standalone VMs bill per second. | 4th cheapest of 377 $86 a month | 288th of 377, with limits $504 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both make good 24/7 dev boxes with root, SSH and a persistent disk; exe.dev offers more regions, bochka offers a desktop in the browser. | 18th cheapest of 368 $26 a month | 25th cheapest of 368 $35 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; bochka streams a 60fps desktop, and exe.dev VMs are headless. | 6th cheapest of 369 $200 a month | 240th of 369, with limits $1,055 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month bochka gives agents a visible Chromium and browser control; on exe.dev you install and run a headless browser yourself. | 7th cheapest of 367 $200 a month | 130th of 367, with limits $530 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 | 124th of 346, with limits $278 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 | 166th of 338, with limits $5,490 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 | 60th of 360, with limits $263 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 | exe.dev |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | KVM VM with Cloud Hypervisor on rented bare metal; you can't choose the kernel |
| Desktop and computer use | 60fps desktop and Chromium, computer use, browser control, embeddable stream | Headless; no desktop or screen streaming |
| Saved state | Snapshots every minute while running and on stop; stopped sandboxes resume with their disk | Disk persists and is streamed to a second server; no snapshots |
| Fork and templates | Fork a running sandbox; named snapshots as templates, shareable by code | cp copies a VM's disk and config into a new VM |
| Custom images | Templates from named snapshots; no Dockerfile or OCI images | Boot from your own Docker image |
| Preinstalled agents | Claude Code, Codex, pi, OpenCode, Prime Agent, Kimi Code, Mistral Vibe | Claude Code, Codex, Pi and Shelley |
| Agent API | Prompt, steer and stream events for any built-in agent, with TypeScript and Python SDKs | Send a prompt to Shelley from the CLI or HTTPS API; other agents through shell commands |
| MCP server | No | Yes, at exe.dev/mcp |
| Inbound traffic | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv6 or IPv4 per machine | HTTPS proxy for ports 3000 to 9999, one of them public; SSH; no public IP or raw TCP |
| Secrets | Credentials proxy for model providers and any HTTPS API you register; switch accounts when one runs out of credits | Integrations inject secrets at the network edge for any HTTP host, S3, GitHub and a large catalog |
| Nested virtualization | Yes, /dev/kvm on every plan | Enterprise only |
| Regions | EU only: Germany, Finland, France | 9 regions in the US, Europe, Asia and Australia |
| Teams and access | Org seats, scoped API keys, spend limits, usage per sandbox | Unlimited users, SSO and roles on Work; BYOC and dedicated hardware on Enterprise |
| Session length | No cap on paid plans; you set the TTL | No cap; VMs run until you stop them |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | No SOC 2 report published |
Every feature Battleships tracks (43)
| Feature | bochka | exe.dev |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | Yes |
| Root | Yes | Yes |
| Systemd | Yes | Yes |
| 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 | No |
| 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 | No |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | Yes |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | Yes |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | No |
| BYOC | No | Yes |
| Open source | No | No |
| Scoped API keys | Yes | Yes |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | Yes |
| Audit logs | No | Not published |
| SSO | No | Yes |
| SOC 2 | No | No |
| HIPAA | No | No |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
exe.dev is not in the hpc-sandbox-benchmarks run, so there is no comparable CPU measurement for it. bochka was measured on that Node.js build-and-test loop at 4 vCPU / 8 GB, and the table shows its score. We don't guess how exe.dev would score.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. exe.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 | exe.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 | $35 · Personal |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $35 · Personal |
| 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 | $1,848 · Personal |
| 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 | $530 · Personal · 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 | $1,050 · Personal · with limits |
bochka: Your monthly plan fee is all usage credit, and sandboxes bill per second only while they run. A stopped sandbox costs nothing and resumes with its disk.
exe.dev: Pools are reserved capacity that your VMs share: Personal is a flat monthly fee paid upfront, and Work is a team fee plus extra capacity billed by the hour while it exists. A pool bills the same whether its VMs are busy or idle.
exe.dev: Standalone VMs bill per second, with no minimum, at $0.105 per 2 vCPU / 4 GiB per hour. A stopped standalone VM pays nothing for CPU and memory but keeps its disk and still counts toward your VM limit.
Limits in those scenarios
On exe.dev Personal you get one pool of up to 16 vCPU and 50 VMs, plus up to 50 standalone VMs, so the 300-at-once and 1,000-at-once scenarios don't fit there. On Work, pools above 32 vCPU need approval from exe.dev support, and standalone VMs stay off until a team admin turns them on. On bochka, concurrency goes from 100 to 2,000 by plan, but start-rate limits mean even the top plan can't launch 1,000 short jobs at once without queueing.
| Scenario | bochka | exe.dev |
|---|---|---|
| One coding agent, workdays | 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 |
|
| 1,000 short jobs at once |
|
|
Which one should you use?
Use exe.dev when
your users are outside Europe, or your team wants VMs booted from its own Docker image with SSO and roles.
- Regions around the world. Useful if your users are far from Europe: exe.dev runs in nine regions across the US, Europe, Asia and Australia.
- Your own Docker image. exe.dev can boot each VM straight from your own Docker image.
- Team and enterprise controls. Its Work plan covers a whole team with SSO and roles, and it serves an MCP server for controlling VMs.
Use bochka when
your agents do real work for hours: builds, tests, Docker, a desktop and a browser, with state saved every minute and one API to drive agents inside from outside.
- A screen your agents can use. Computer-use agents work by looking at a screen. exe.dev VMs are headless, so before an agent can check a UI or click through a web app, you set up and stream a desktop yourself.
- State saved every minute. Agents sometimes break things, like deleting files or wrecking an install. exe.dev has no snapshots to roll back to, so one bad step can cost a whole session's work.
- Drive agents inside from outside. On exe.dev only Shelley takes prompts through the API. To run Claude Code or Codex from your app you script shell sessions yourself, with no clean way to steer a task or stream what it does.
Questions people ask
Is bochka cheaper than exe.dev?
In our scenario table bochka's monthly bill is lower in four of the five workloads, and the gap is largest for 50 agents running in parallel. For 1,000 short jobs at once exe.dev's bill is lower, but neither provider fits that load on the plans we priced.
Does exe.dev have a desktop or computer use?
No. exe.dev VMs are reached over SSH and an HTTPS proxy, with no desktop stream. bochka gives every sandbox a 60fps desktop with Chromium and APIs for computer use and browser control.
Does exe.dev have snapshots?
No. exe.dev keeps each VM's disk and streams it to a second server, and cp makes a copy of a VM, but there is no snapshot to roll back to. bochka snapshots running sandboxes every minute and lets you save named snapshots as templates.
Can I run Claude Code on both?
Yes. exe.dev preinstalls Claude Code, Codex and Pi along with its own Shelley agent. bochka preinstalls Claude Code, Codex, pi, OpenCode, Prime Agent, Kimi Code and Mistral Vibe, and its credentials proxy keeps your real API keys out of the sandbox.
Where do bochka and exe.dev run?
bochka runs only in the EU, in Germany, Finland and France, with EU data residency. exe.dev has nine regions in the US, Europe, Asia and Australia.
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 Amp Orbs
- bochka vs Prized
- bochka vs Zo Computer
- bochka vs Namespace
- bochka vs Ona
- bochka vs boxes.dev
- bochka vs Tencent Cloud Studio
- bochka vs Sealos DevBox
- bochka vs E2B
- bochka vs Daytona
- bochka vs Modal
- bochka vs Vercel Sandbox
- E2B vs exe.dev
- Daytona vs exe.dev
- Modal vs exe.dev
- Vercel Sandbox vs exe.dev
- Cloudflare Sandbox vs exe.dev
- Blaxel vs exe.dev
- Runloop vs exe.dev
- Tensorlake vs exe.dev