bochka vs Rivet
Rivet runs agents in tiny V8 and WebAssembly sandboxes that start in milliseconds and sleep when idle. bochka gives each agent a whole Linux machine with root, Docker, a browser and coding agents built in.
Where bochka stands out
A whole Linux machine, not an isolate
Each bochka sandbox is a full VM with its own kernel, root, systemd and Docker. Agents can apt install anything, compile native code, and start Android emulators or VMs through /dev/kvm. agentOS runs a focused subset of Linux with no Docker, no apt and no hardware access.
A real browser and desktop inside
bochka runs Chromium and a Linux desktop in the sandbox, streamed at 60fps, with computer use built in. The agent can click, type and watch the screen on the same machine as its files.
Agents and keys built in
Claude Code, Codex and five other agents come preinstalled, and you drive agents inside from outside with one prompt, steer and events API. Real API keys stay in a credentials proxy outside the sandbox, for model providers and any HTTPS API, 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
Rivet
Rivet makes Actors, long-lived stateful processes, and agentOS, a light sandbox for agents built on V8 isolates and WebAssembly.
agentOS gives each agent a small virtual Linux with a lasting file system, Bash, Node.js and Python, running in-process instead of booting a VM. It is a different kind of product from bochka: not a full Linux machine, so Docker, apt installs and browsers are out, and Rivet's own docs send that work to a full sandbox. It suits teams that want many cheap, fast-waking agents whose tools are mostly scripts and API calls, and the whole stack is open source.
- Bring your own cloud
- Full stack in your VPC, managed by Rivet, on Enterprise
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 | Rivet: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs to install toolchains, run Docker and start dev servers, which agentOS cannot do on its own; bochka runs all of it on one machine. | 3rd cheapest of 367 $634 a month | 346th of 367, with limits $13,066 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Rivet agents sleep and wake on request, which suits light assistants; bochka fits when the assistant needs a real machine with a browser and Docker. | 5th cheapest of 366 $657 a month | 59th of 366, with limits $9,071 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Rivet's agentOS is built for short script and code runs that start in milliseconds and sleep between calls, so it fits this one better than most. | 186th of 345, with limits $2,000 a month | 151st of 345, with limits $458 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Rivet is cheap to keep idle for each user and wakes on request; bochka gives each user a full machine with hosting built in. | Cheapest of 361 $209 a month | 309th of 361, with limits $2,904 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 | 165th of 360, with limits $14,029 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 | 325th of 364, with limits $4,169 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs need apt, native compilers and Docker, which agentOS lists as unavailable, while bochka runs them with root and nested virtualization. | 4th cheapest of 377 $86 a month | 363rd of 377, with limits $4,812 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs SSH, root and any tool you want to install, which bochka has and agentOS does not. | 18th cheapest of 368 $26 a month | 353rd of 368, with limits $667 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 to see and click, and agentOS has none; bochka streams a Linux desktop at 60fps. | 6th cheapest of 369 $200 a month | 339th of 369, with limits $3,752 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month agentOS sends browser work to an outside service like Browserbase, while bochka runs Chromium inside the sandbox. | 7th cheapest of 367 $200 a month | 136th of 367, with limits $1,016 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 | 111th of 346, with limits $681 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 | 260th of 338, with limits $14,234 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 | 298th of 360, with limits $683 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 | Rivet |
|---|---|---|
| What runs inside | Full VM with its own Linux kernel on dedicated AMD Ryzen 9 9950X hosts | agentOS: V8 isolates and WebAssembly with a virtual POSIX kernel |
| Installing software | Root, apt and any binary you want | Tools come from a fixed registry; no curl or apt installs of arbitrary binaries |
| Docker inside | Yes | No; container runtimes are not available |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | No; the VM has no access to hardware |
| Biggest machine | Up to 16 vCPU / 32 GB on the $100 plan and above | Up to 8 vCPU on paid plans |
| Start time | Boots a full VM | 4.8 ms p50 cold start for an agentOS instance |
| Sleep and wake | Stop and start by API; a stopped sandbox keeps its disk | Sleeps after 30 seconds idle by default and wakes on the next request |
| What survives a stop | The whole disk, saved every minute and on stop | Durable files, config and cron jobs; running processes and terminals do not |
| Fork | Fork a running sandbox with its disk | Not documented |
| Browser and desktop | Linux desktop at 60fps, Chromium and computer use built in | No browser in the VM; it connects to services like Browserbase |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 | Signed preview URLs that proxy HTTP to a VM port until they expire |
| Outbound rules | Open internet, no provider-side allowlist | Permission policy with allow rules by host and port, enforced outside the VM |
| Coding agents | Seven agents preinstalled, with a prompt, steer and events API | Pi through Rivet Agents with follow-up, steer and event streams; its Sandbox Agent SDK drives Claude Code, Codex and others in other sandboxes |
| Self-hosting | No | Open source under Apache 2.0, plus bring 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. | Not published |
Every feature Battleships tracks (43)
| Feature | bochka | Rivet |
|---|---|---|
| Full VM (own kernel) | Yes | No |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | Not published |
| 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 | No |
| Fork/clone | Yes | No |
| Live fork (no pause) | Yes | No |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Not published |
| ≥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 | No |
| Secret proxy for any API | Yes | No |
| 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 | Yes |
| BYOC | No | Yes |
| Open source | No | Yes |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Not published |
| SSO | No | Not published |
| SOC 2 | No | Not published |
| HIPAA | No | No |
| EU data residency | Yes | Not published |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement. bochka did 26.69 runs per second on the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts; Rivet has not been run on the same test. Rivet publishes its own cold-start figure of 4.8 ms p50 for agentOS.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Rivet 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 | Rivet, 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 | $182 · Hobby · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $697 · Hobby · 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 | $8,489 · Hobby · 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 | $1,270 · Hobby · 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 | $2,806 · Hobby · 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.
Rivet: Hobby and Team charge a monthly base fee plus usage, and the fee covers Awake Actor Hours, not compute. Compute is billed per vCPU-second and GiB-second only while an agent is awake, plus $0.05 per 1,000 awake hours, storage and egress. The scenarios price Rivet at the same machine size as bochka; a light agentOS instance that uses far less memory costs far less.
Limits in those scenarios
Rivet does not fit any of the five scenarios as modelled: its largest size is 4 vCPU / 4 GiB, so the 8 GiB machines do not fit, and the agent fleet needs Docker, which agentOS does not run. Rivet does not publish how many agents can run at once, so the 300 and 1,000 machine scenarios are not confirmed. bochka fits four of the five; for 1,000 short jobs at once, its $2,000 plan queues starts above 90 a minute.
| Scenario | bochka | Rivet |
|---|---|---|
| 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 Rivet when
you run very many light agents whose tools are scripts and API calls, want them to wake in milliseconds, or must self-host the whole stack.
- Tiny, fast-waking sandboxes. Good for huge numbers of light agents: an agentOS instance starts in about 5 ms and uses about 22 MB.
- Open source and self-hosted. The whole stack is Apache 2.0 and can run in your own VPC, on-prem or air-gapped.
- Network rules outside the VM. Useful when an agent should reach only the hosts you pick, enforced outside the sandbox.
Use bochka when
your agents need a real machine: installs, builds, Docker, emulators, a browser and coding agents, on one VM that keeps its disk.
- A whole Linux machine, not an isolate. Rivet's own docs say heavy compilation, native toolchains, databases and dev servers need a full sandbox. On agentOS that means wiring in a second provider and paying for it too.
- A real browser and desktop inside. agentOS never runs a browser, so browser and computer-use agents need an outside service like Browserbase, with a separate bill and their pages away from the agent's files.
- Agents and keys built in. On Rivet you keep keys out by writing host functions for each tool, while Claude Code and Codex run through its SDK in someone else's sandbox. Either way, more glue code is yours.
Questions people ask
Is bochka cheaper than Rivet?
In all five scenarios on this page bochka costs less, and Rivet does not fit any of them as modelled, mostly because of its 4 GiB memory cap and no Docker. Those scenarios price Rivet at full machine sizes, though; for tiny agents that only run scripts, agentOS can cost much less.
Can Rivet agentOS run Docker?
No. Rivet's docs list container runtimes like Docker, kernel modules and file watching as unavailable in agentOS, and say heavy compilation needs a full sandbox. bochka runs Docker inside every sandbox.
Is agentOS a real VM?
Not in the usual sense. It is built on V8 isolates and WebAssembly with a virtual POSIX kernel, so it starts in milliseconds but cannot run arbitrary Linux binaries. A bochka sandbox is a full VM with its own kernel.
Can I run Claude Code on Rivet?
Rivet's Sandbox Agent SDK drives Claude Code, Codex and others inside sandboxes from providers like E2B or Daytona, while Rivet Agents runs Pi. bochka has seven coding agents preinstalled and drives agents inside from outside with one API.
Can I self-host Rivet?
Yes. Rivet is open source under Apache 2.0 and ships as a Rust binary or Docker image, and Enterprise offers bring your own cloud. bochka is a hosted service in the EU.
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