bochka vs Leap0
Leap0 and bochka both put each agent in its own small virtual machine. bochka's machine can run for as long as you want, with more room and coding agents built in, while Leap0 is strongest at short sessions that pause with their memory and wake on the next request.
Where bochka stands out
No 8 hour wall
A Leap0 sandbox lives for 5 minutes by default and 8 hours at most, then it is killed or paused. A bochka sandbox on a paid plan has no session cap: it runs until you stop it, and its disk is saved every minute.
A bigger machine that can run VMs
bochka machines go up to 16 vCPU and 32 GB of RAM, and the default one has 50 GB of disk for your files, up to 251 GB on the largest. Every machine has Docker, root, systemd and /dev/kvm, so Android emulators and VMs start inside it.
Coding agents you drive from outside
Claude Code, Codex and five other agents come preinstalled, and you prompt, steer and follow them through one API. Leap0 gives you guides to install an agent CLI and run it as a process.
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
Leap0
Leap0 is a sandbox cloud for AI agents: an API that starts a small Linux virtual machine for each agent or code run.
Every Leap0 sandbox is a Firecracker microVM with its own Linux 6.1 kernel, built from a template that can come from your own Docker image. You get APIs for processes, files, git, SSH, a code interpreter, a Linux desktop for computer use, memory snapshots and a network firewall, plus an MCP server so an editor can drive sandboxes. It is in a free public preview, runs in the US, and can also run on your own compute.
- Machine size
- 1 to 8 vCPU, 512 MiB to 8 GB RAM, 10 GiB disk
- Session length
- 1 minute to 8 hours, default 5 minutes
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 | Leap0: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory runs builds and tests for hours; Leap0 ends a sandbox at 8 hours with a 10 GiB disk, while bochka has no session cap and a much larger disk. | 3rd cheapest of 367 $634 a month | 30th of 367, with limits $5,829 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month must pause and resume on Leap0 every 8 hours at most; on bochka it simply keeps running. | 5th cheapest of 366 $657 a month | 55th of 366, with limits $6,044 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Leap0 suits short code runs well: the code interpreter keeps state between calls, and a paused sandbox wakes on the next request with its memory. | 186th of 345, with limits $2,000 a month | 132nd of 345, with limits $276 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Leap0's wake on request is handy for user sandboxes that sleep, but bochka gives each user a bigger machine with HTTPS on up to 50 ports and raw TCP. | Cheapest of 361 $209 a month | 150th of 361, with limits $1,925 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Leap0 can fork one memory snapshot into many sandboxes, which suits rollouts that branch from the same state. | 34th of 360, with limits $2,000 a month | 131st of 360, with limits $8,280 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 | 178th of 364, with limits $1,656 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that build Android apps or VM images need /dev/kvm, which bochka exposes and Leap0 does not document. | 4th cheapest of 377 $86 a month | 330th of 377, with limits $1,279 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box that stays up all month needs no session cap, which bochka has and Leap0's 8 hour limit rules out. | 18th cheapest of 368 $26 a month | 129th of 368, with limits $242 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both ship a Linux desktop with Chrome for computer use; bochka streams it at 60fps and you can embed it in your app. | 6th cheapest of 369 $200 a month | 56th of 369, with limits $1,656 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 | 104th of 367, with limits $828 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 | 103rd of 346, with limits $414 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 | 213th of 338, with limits $8,280 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 | 38th of 360, with limits $414 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 | Leap0 |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Firecracker microVM with its own Linux 6.1 kernel |
| Biggest machine | Up to 8 vCPU / 16 GB on the $20 plan, 16 vCPU / 32 GB on the $100 plan and above | Up to 8 vCPU / 8 GB |
| Disk | 50 GB of your own files on the default machine, up to 251 GB on the largest, saved every minute | 10 GiB per sandbox, plus S3 buckets you mount |
| Session length | No cap on paid plans; you set the time to live | 1 minute to 8 hours, default 5 minutes; then killed, or paused if you turn on auto_pause |
| Pause and wake | Disk saved every minute and on stop; a stopped sandbox is started again by API and boots fresh | Pause saves memory and disk; a paused sandbox resumes on the next request with its processes |
| Fork | Fork a running sandbox with its disk | Snapshot a running sandbox with its memory and restore it into many new sandboxes |
| Docker and nested virtualization | Docker, root, systemd and /dev/kvm on every machine | Docker and systemd through a custom template; nested virtualization not documented |
| Desktop and computer use | Linux desktop with Chromium streamed at 60fps, embeddable, with computer use | XFCE desktop at 1440x900 with Chrome, Firefox and VS Code, mouse and keyboard API, screen recording |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 | Per-port URL called with your API key, or an expiring public presigned URL; no raw TCP or dedicated IP documented |
| Coding agents | Seven agents preinstalled, with a prompt, steer and events API | Guides to install Claude Code, Codex or OpenCode yourself and run them through the process API |
| Keeping API keys out of the sandbox | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out | Firewall injects headers per domain on the host side, so secrets never enter the sandbox |
| Outbound rules | Open internet, no provider-side allowlist | Allow all, deny all, or allow by domain and CIDR |
| Regions | EU only (Germany, Finland, France), with zero data retention | US only, more regions planned |
| Self-hosting | No | Bring your own compute, or deploy on your own infrastructure |
| 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 | Leap0 |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | No |
| Root | Yes | Not published |
| Systemd | Yes | Yes |
| Desktop GUI | Yes | Yes |
| Browser | Yes | Yes |
| Computer-use API | Yes | Yes |
| 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 | Yes |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | No |
| Idle auto-stop | No | No |
| Wake on request | No | Yes |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | Not published |
| Public IPv4 | No | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | Yes |
| Preinstalled agents | Yes | No |
| Agent harness API | Yes | No |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | Yes |
| BYOC | No | Yes |
| Open source | No | No |
| Scoped API keys | Yes | No |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Not published |
| SSO | No | No |
| 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 Leap0. bochka did 26.69 runs per second on the StarSling hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, and Leap0 has not been run on that benchmark, so we make no speed claim either way.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Leap0 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 | Leap0, 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 | $58 · Public preview · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $242 · Public preview · 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,915 · Public preview · 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 | $828 · Public preview · 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,656 · Public preview · with limits |
bochka: 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.
Leap0: Leap0 is free during its public preview. The table uses the rates it says will apply when billing goes live, per second for the vCPU and RAM you set, and Leap0 has not yet published disk, snapshot or egress prices.
Limits in those scenarios
The limit that bites first on Leap0 is the 8 hour session cap, which is why the always-on scenario does not fit. Each sandbox also tops out at 8 vCPU, 8 GB of RAM and a 10 GiB disk. Leap0 does not publish how many sandboxes can run at once, and its limits page says limits may change during the preview, so ask Leap0 before planning hundreds of sandboxes. bochka has no session cap, but at 1,000 short jobs at once its $2,000 plan queues starts.
| Scenario | bochka | Leap0 |
|---|---|---|
| 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 Leap0 when
your sandboxes are short sessions that should pause with their memory and wake on request, you need an outbound allowlist, or you must run on your own compute.
- Memory snapshots and wake on request. Useful for sessions that sleep between requests: a paused sandbox resumes with its memory when the next request arrives.
- Outbound firewall. Teams that must limit where an agent can connect can allow only chosen domains and IP ranges.
- Your own compute, and free for now. Teams that need sandboxes on their own machines can bring their own compute, and the preview costs nothing today.
Use bochka when
your agents work for hours on a full machine: builds, Docker, emulators, a browser and hosted services, with coding agents you steer by API and no session cap.
- No 8 hour wall. A coding agent that runs a long migration or stays on call all day hits Leap0's 8 hour limit, so your code has to pause, track and resume every sandbox to keep the work alive.
- A bigger machine that can run VMs. On Leap0 a sandbox stops at 8 GB of RAM and a 10 GiB disk, which a monorepo with Docker images fills fast, and no nested virtualization is documented for emulators.
- Coding agents you drive from outside. Without a harness API you install the agent, start it as a process, parse its output and build steering yourself, for every sandbox you launch.
Questions people ask
Is bochka cheaper than Leap0?
Today Leap0 costs nothing because it is in a free public preview. At the rates Leap0 says will apply when billing starts, bochka costs less in four of the five scenarios on this page; for 1,000 short jobs at once, Leap0's rate is lower.
How long can a Leap0 sandbox run?
From 1 minute to 8 hours, with a default of 5 minutes. At the timeout it is killed, or paused if you set auto_pause. bochka has no session cap on paid plans.
Can bochka pause a sandbox with its memory like Leap0?
No. bochka saves the disk every minute and when the sandbox stops, so files survive, but starting it again boots the machine. Leap0 can pause with memory and resume the running processes on the next request.
Can I run Docker and Android emulators in each?
Both can run Docker; on Leap0 you build a template with Docker and systemd. bochka also exposes /dev/kvm for Android emulators and VMs, which Leap0's docs do not mention.
Where do bochka and Leap0 run?
Leap0 runs in the US and plans more regions. bochka runs in the EU, in Germany, Finland and France, with zero data retention.
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