bochka vs Runta
Runta and bochka both give AI agents their own VM, with a desktop, secret injection and an API to drive an agent. bochka lets you pick the agent, documents root, systemd and /dev/kvm, opens more ways into the machine, and costs less in four of the five scenarios below.
Where bochka stands out
Pick your coding agent
bochka ships Claude Code, Codex, pi, OpenCode and other agents in every sandbox, and you drive them from outside with a prompt, steer and events API. Runta's Cloud Agents API drives one managed agent, Pi, and its docs say the harness field does not select Codex CLI or Claude Code.
A full machine, written down
bochka documents root, systemd, Docker and /dev/kvm on every sandbox, on dedicated AMD Ryzen 9 9950X (Zen 5) hosts that did 26.69 runs per second in a public 4 vCPU / 8 GB benchmark. Runta's docs build images from a Dockerfile but do not say what runs inside a runtime, and Runta has no public CPU number.
More ways in
A bochka sandbox can serve HTTPS on up to 50 ports behind a token, take raw TCP, and get its own IP address. A Runta runtime publishes up to 16 HTTP or HTTPS ports at a runta.dev URL, and the docs describe no token or private mode for them.
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
Runta
Runta calls itself an execution layer for AI agents: isolated computers, called runtimes, that agents can work in and keep state on.
A Runta runtime is a VM you create from the CLI, Python or TypeScript SDK, or REST API, with a VNC desktop, SSH keys, published HTTPS ports, egress rules and secret stubs that add credentials at its gateway. Checkpoints capture the filesystem and running processes, and Cloud Agents run Runta's managed Pi agent inside a runtime that you prompt over REST. It is built for teams that want governed agent compute with tight control over network access and credentials.
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 | Runta: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month bochka documents Docker, root and /dev/kvm on every machine and ships the coding agents; Runta is a compromise because its docs do not confirm Docker inside a runtime, and you install your own agent unless Pi is enough. | 3rd cheapest of 367 $634 a month | 27th of 367, with limits $4,151 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both fit; Runta's Cloud Agents keep sessions across runs with Pi, and bochka runs Claude Code, Codex or OpenCode on a disk that is saved every minute. | 5th cheapest of 366 $657 a month | 21st cheapest of 366 $5,277 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Runta fits short bursts better: it has no plan fee and bills only the seconds a runtime runs, while bochka's start limits make big bursts a compromise. | 186th of 345, with limits $2,000 a month | 26th cheapest of 345 $273 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Both fit; bochka gives each user's sandbox token-protected HTTPS on up to 50 ports, and Runta publishes up to 16 HTTP or HTTPS ports per runtime. | Cheapest of 361 $209 a month | 18th cheapest of 361 $1,715 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 | 132nd of 360, with limits $8,288 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 | 63rd cheapest of 364 $1,333 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both fit; on Runta a runtime that is shut down keeps billing its disk, while a stopped bochka sandbox costs nothing. | 4th cheapest of 377 $86 a month | 89th cheapest of 377 $805 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 103rd cheapest of 368 $212 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both fit: Runta opens a VNC desktop through expiring computer sessions, and bochka streams a 60fps desktop with Chromium and a computer-use API. | 6th cheapest of 369 $200 a month | 28th cheapest of 369 $1,200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Runta's browser lives inside the Cloud Agent computer and is reached through VNC, so driving it from your own browser agent is a compromise. | 7th cheapest of 367 $200 a month | 94th of 367, with limits $600 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 | 40th cheapest of 346 $406 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 | 207th of 338, with limits $8,126 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Runta publishes only HTTP and HTTPS ports, so tools that need raw TCP into the target are a compromise there; bochka has raw TCP. | 2nd cheapest of 360 $200 a month | 36th of 360, with limits $398 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 | Runta |
|---|---|---|
| Isolation | Every sandbox is a full VM with its own kernel | Every runtime is an isolated VM |
| Root, systemd, Docker, /dev/kvm | Root, systemd, Docker and /dev/kvm documented on every machine | Images build from a Dockerfile; the docs do not say whether root, systemd, a Docker daemon or /dev/kvm are available inside |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 26.69 runs/s | No public measurement |
| Built-in agents | Claude Code, Codex, pi, OpenCode and more preinstalled, with a prompt, steer and events API | Cloud Agents API drives one managed agent, Pi; Codex CLI and Claude Code are not selectable harnesses |
| Desktop and computer use | 60fps desktop and Chromium, computer use and browser control, embeddable stream | VNC desktop opened with expiring computer sessions; a browser inside Cloud Agent computers; no documented screenshot or input API for your own agent |
| Saving state | Disk snapshots every minute and on stop; resume reboots from disk | Checkpoints on demand with filesystem and running processes; restore creates a new runtime |
| Fork a running machine | Fork a running sandbox from its disk | Full VM checkpoint of a running runtime, restored into as many new runtimes as you want |
| Idle and wake | Sandboxes run until you stop them; no idle suspend or wake on request | Auto-suspend after an idle timeout and wake on the next HTTP request (preview) |
| Reaching the machine | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 | Up to 16 published HTTP or HTTPS ports per runtime at a runta.dev URL; SSH keys; no raw TCP |
| Outbound internet | Open internet; no provider-side allowlist | Open by default; per-runtime hostname allowlist or denylist at the egress gateway |
| Keeping keys out of the sandbox | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out | Secret stubs add a stored secret to request headers for a matching host and path at the egress gateway |
| Memory size | Fixed size per sandbox, up to 16 vCPU / 32 GB by plan | Memory can grow on its own up to a set maximum, and can be resized while running |
| Regions | EU only: Germany, Finland, France, with EU data residency and zero data retention | No region named or selectable |
| 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 | Runta |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Not published |
| Nested virtualization | Yes | Not published |
| Root | Yes | Not published |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | Yes |
| Browser | Yes | Yes |
| Computer-use API | Yes | Not published |
| 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 | 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 | Yes |
| Agent harness API | Yes | Yes |
| MCP server | No | No |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Yes |
| 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: Runta has no result in the public StarSling benchmark we use, and it publishes no CPU numbers of its own. In that benchmark bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Runta 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 | Runta, 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 | $56 · Prepaid |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $222 · Prepaid |
| 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,702 · Prepaid · 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 | $750 · Prepaid |
| 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,658 · Prepaid |
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.
Runta: Runta bills prepaid credit, with no subscription and a $5 minimum top-up, for the vCPU, memory and disk of each running runtime, and every disk is at least 32 GiB. A paused, suspended or shut-down runtime still pays for its disk, and egress and checkpoint storage prices are not published.
Limits in those scenarios
Runta publishes only its trial limit: 32 vCPU and 64 GiB shared across all runtimes, which is 8 machines of 4 vCPU / 8 GiB. Adding a card unlocks higher limits, but the numbers are not published, so the 50-agent fleet and the 1,000-job burst depend on what Runta grants you, and the fleet also needs Docker inside, which Runta's docs do not confirm. On bochka the limit is a sandbox count (100 to 2,000 by plan) plus starts per minute, so the 1,000-job burst gets queued and needs more starts per day than the $2,000 plan allows.
| Scenario | bochka | Runta |
|---|---|---|
| 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 Runta when
an agent must pause with its running processes and resume later, sleep until a request wakes it, or reach only a list of allowed hosts.
- Checkpoints with running processes. Useful if an agent must pause and come back mid-task: Runta checkpoints keep running processes and restore into new runtimes.
- Sleep when idle, wake on request. Useful for services that sit idle: a Runta runtime can suspend after a quiet spell and wake on the next HTTP request.
- Egress rules and growing memory. Useful if agents must reach only chosen hosts, or need memory that grows with the job.
Use bochka when
your agents do long coding work with the agent you choose, on a documented full VM with root, Docker and /dev/kvm, served on many ports, in the EU.
- Pick your coding agent. If your team runs Claude Code or Codex, Runta's agent API does not drive it, so you install the agent yourself and write the code that starts, prompts and watches it.
- A full machine, written down. Agents that run Docker Compose, system services or Android emulators need these. On Runta you find out by trying it, since the docs make no promise either way.
- More ways in. A database, game server or red team target that speaks TCP cannot sit behind an HTTP-only port, and a preview with no token is open to anyone who finds the URL.
Questions people ask
Is bochka cheaper than Runta?
In four of the five scenarios we priced, yes: one coding agent on workdays comes to $20 a month on bochka and $56 on Runta, and one agent running all month comes to $26 versus $222. 50 agents in parallel come to $317 versus $2,702, though that scenario needs Docker inside, which Runta's docs do not confirm. For 1,000 short jobs at once, Runta comes to $1,658 against $2,000 on bochka, where the burst does not fit the start limits.
Can Runta run Claude Code or Codex?
Runta's Cloud Agents API drives its managed Pi agent, and the docs say the harness field does not select Codex CLI or Claude Code. You can install those agents in a runtime yourself and run them there. bochka has them preinstalled and drives them with a prompt, steer and events API.
Does Runta keep memory when it pauses?
Its checkpoints capture the filesystem and running processes, and restoring one creates a new runtime. bochka snapshots the disk every minute and on stop, and a resumed sandbox reboots from that disk.
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. Runta's docs and API do not name a region or let you pick one.
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. Runta's Trust Center lists SOC 2 Type 2 and ISO 27001 as in progress.
Start a sandbox
Install the CLI, then run bochka new.
Product preview