bochka vs OpenComputer
Both give each agent its own Linux virtual machine. bochka gives it a full workstation with a desktop, SSH, nested virtualization and coding agents preinstalled, while OpenComputer is strongest at sandboxes that sleep with their memory and wake fast, and at running in your own cloud.
Where bochka stands out
A computer the agent can see and use
Every bochka sandbox has a Linux desktop streamed at 60fps, Chromium, and computer use built in, plus SSH. OpenComputer runs Chromium well, but a visible desktop means installing Xvfb and noVNC yourself and wiring them through a preview URL.
Steady CPUs and nested virtualization
bochka runs on dedicated AMD Ryzen 9 9950X hosts and did 26.69 runs per second on the hpc-sandbox-benchmarks CPU test. It also exposes /dev/kvm, so Android emulators and VMs run inside the sandbox. OpenComputer sizes burst from a baseline, and nested virtualization is not documented for sandboxes.
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. Real keys stay outside the sandbox in a credentials proxy, and a credential can switch to another account when one runs out of credits.
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
OpenComputer
OpenComputer calls itself the platform for long-running agents: you define an agent like a serverless function, and each session runs on its own Linux microVM.
OpenComputer has two layers. Its main product is Serverless Agents, where you write an agent in TypeScript and OpenComputer runs the agent loop, the models and the machine. Under it sit bare sandboxes: QEMU/KVM virtual machines with checkpoint, fork and live resize, for teams that bring their own harness. The code is open source under Apache-2.0.
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 | OpenComputer: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker, emulators and full builds on steady CPUs; bochka gives each agent dedicated hosts, /dev/kvm and coding agents preinstalled. | 3rd cheapest of 367 $634 a month | 323rd of 367, with limits $7,314 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both can keep an agent alive for weeks; bochka adds a desktop, SSH and a dedicated IP so the agent can work like a person at a computer. | 5th cheapest of 366 $657 a month | 31st cheapest of 366 $10,065 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month OpenComputer suits short code runs: a sandbox can hibernate with its memory and wake in under a second on the next SDK call. | 186th of 345, with limits $2,000 a month | 109th of 345, with limits $200 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Both give each user a VM; bochka protects every port with a token by default and serves raw TCP, while OpenComputer previews are public until you turn on a token. | Cheapest of 361 $209 a month | 155th of 361, with limits $2,090 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 | 360th of 360, with limits $16,995 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 | 158th of 364, with limits $1,224 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI that builds Android apps or VM images needs nested virtualization, which bochka has and OpenComputer does not document. | 4th cheapest of 377 $86 a month | 258th of 377, with limits $200 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box wants SSH, a dedicated IP and a desktop; OpenComputer offers a terminal over WebSocket and HTTPS previews instead. | 18th cheapest of 368 $26 a month | 295th of 368, with limits $200 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Computer use needs a desktop the agent can see and click; bochka streams one at 60fps, while OpenComputer documents only a do-it-yourself VNC setup. | 6th cheapest of 369 $200 a month | 233rd of 369, with limits $922 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Both run a real Chromium inside a full VM, so both fit browser agents well. | 7th cheapest of 367 $200 a month | 9th 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 | 6th cheapest of 346 $90 a month | 123rd of 346, with limits $200 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 | 269th of 338, with limits $16,628 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 | 56th of 360, with limits $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 |
| 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 | OpenComputer |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | QEMU/KVM virtual machine with its own kernel, memory and disk |
| CPU | 26.69 runs/s on the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB | Burstable: each size has a baseline and bursts to 4x under load, billed at the peak rate while bursting; no CPU benchmark published |
| Biggest machine | Up to 16 vCPU / 32 GB on the $100 plan and above | 4 vCPU / 8 GB baseline, bursting to 16 vCPU / 32 GB |
| Sleep and wake | Disk is saved every minute and on stop; a stopped sandbox costs nothing and boots again on start | Hibernate saves memory and disk; any SDK call wakes it, typically in under a second |
| Fork | Fork a running sandbox with its disk | Checkpoint a running sandbox with disk, memory and CPU state, then fork unlimited copies; warm restore is best effort |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | Not documented for sandboxes |
| Desktop and computer use | Linux desktop streamed at 60fps, Chromium, and computer use built in | Headless or headed Chromium; a desktop means installing Xvfb and noVNC yourself |
| Shell access | SSH | Interactive terminal over WebSocket through the SDK or CLI; no SSH |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 | HTTPS preview URL per port, public by default unless you turn on a token; no raw TCP or public IP |
| Outbound rules | Open internet, no provider-side allowlist | Host allowlist enforced by a proxy outside the VM |
| 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 | Secrets sealed as tokens in the VM and swapped for the real value by a host-side proxy on outbound HTTPS |
| Coding agents | Claude Code, Codex and five more preinstalled, with a prompt, steer and events API | Its own managed agent loop (Serverless Agents); no coding agent CLIs preinstalled in sandboxes |
| Regions | EU only (Germany, Finland, France), with EU data residency | Not published |
| Self-hosting | No | Apache-2.0 code you can run on AWS or Azure, plus your own cloud on Enterprise |
| 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 | OpenComputer |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | No |
| Root | Yes | Not published |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | No |
| Browser | Yes | Yes |
| 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 | Yes |
| 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 | Yes |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | Yes |
| Preinstalled agents | Yes | No |
| Agent harness API | Yes | Yes |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | Yes |
| BYOC | No | Yes |
| Open source | No | Yes |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | Yes |
| Audit logs | No | Yes |
| SSO | No | Yes |
| SOC 2 | No | No |
| HIPAA | No | No |
| EU data residency | Yes | Not published |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement: OpenComputer has no score on the hpc-sandbox-benchmarks CPU test. bochka did 26.69 runs per second there at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. OpenComputer sizes run at a baseline and burst to 4x under load, so its speed depends on how long a job stays in the burst.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. OpenComputer 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 | OpenComputer, 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 | $20 · Pro · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $200 · Max · 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 | $4,188 · Max · 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 | $200 · Max · 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,959 · Max · 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.
OpenComputer: OpenComputer bills machine time per second while a sandbox runs, by its baseline size, and burst time at the peak rate. Pro at $20 and Max at $200 a month give 10x the fee as credit, shared between model tokens and machine time. A bare sandbox never hibernates unless you set a timeout, and disk beyond the included size and egress have no published price.
Limits in those scenarios
OpenComputer does not fit any scenario cleanly because its CPU is burstable: a size guarantees only its baseline, and running above it costs the peak rate. It also publishes no concurrency limit and no egress price, so 300 or 1,000 machines at once are not confirmed. bochka has no session cap and a published concurrency limit on each plan, but its start rate is lower: at 1,000 short jobs at once, even the $2,000 plan queues the starts.
| Scenario | bochka | OpenComputer |
|---|---|---|
| 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 OpenComputer when
your agents sleep between turns and must wake with their memory, when you need an outbound allowlist, or when you want to run the platform in your own cloud.
- Memory hibernate and memory checkpoints. Useful for agents that sleep between turns: a hibernated sandbox wakes in under a second with its memory.
- Outbound allowlist. Teams that must limit which hosts an agent reaches can set an allowlist enforced outside the VM.
- Open source and your own cloud. The code is Apache-2.0 and can run on your own AWS or Azure KVM hosts.
Use bochka when
your agents need a whole computer: a desktop they can see and click, Docker and emulators on steady CPUs, SSH, real hosting, and coding agents you drive from outside.
- A computer the agent can see and use. Agents that click through apps, log in to sites or show their work to a person need a screen. On OpenComputer you build and maintain that stack inside every image yourself.
- Steady CPUs and nested virtualization. Long builds and test suites run above any baseline for minutes at a time. On a burstable size that time is billed at the peak rate, and an Android emulator cannot start at all without /dev/kvm.
- Coding agents you drive from outside. OpenComputer's agent API drives its own agent loop. To run Claude Code or Codex on its sandboxes you install, start and watch them yourself through exec calls.
Questions people ask
Is bochka cheaper than OpenComputer?
For one agent on workdays and for sandboxes for your users, the two cost about the same. For one agent that never stops, bochka is $26 against $200 on Max, and for 50 agents in parallel $317 against $4,188. For 1,000 short jobs at once the price is close, but bochka queues the starts.
Can OpenComputer run a desktop for computer use?
Not as a built-in feature. Its docs show how to install Xvfb, x11vnc and noVNC yourself and expose them through a preview URL. bochka streams a Linux desktop at 60fps and has computer use built in.
Does bochka keep memory when a sandbox sleeps, like OpenComputer?
No. bochka saves the disk every minute and when the sandbox stops, so files survive, but starting it again boots the machine. OpenComputer hibernates with memory and disk and usually wakes in under a second.
Is OpenComputer open source?
Yes, its code is on GitHub under Apache-2.0, and its self-hosting guide covers AWS and Azure with bare-metal KVM workers. bochka is a hosted service only.
Can I run Docker and Android emulators in each?
Both are full Linux VMs, so Docker runs in both. bochka also exposes /dev/kvm for Android emulators and VMs, which OpenComputer does not document for its sandboxes.
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