bochka vs Runloop

Both give each agent its own VM. bochka ran about three times faster on the same CPU benchmark and gives you a fuller machine, while Runloop adds hostname egress rules, arm64 and deploys into your own cloud.

Where bochka stands out

About three times the CPU speed

On the same Node.js build-and-test benchmark at 4 vCPU / 8 GB, bochka ran 26.69 loops a second and Runloop 8.29. Each bochka sandbox runs on dedicated AMD Ryzen 9 9950X hosts. Builds, tests and agent tool calls finish sooner.

A fuller Linux machine

Each bochka sandbox is a full VM with its own kernel, root, systemd and /dev/kvm, so you can run Android emulators or VMs inside. You can open raw TCP ports and get a dedicated IPv6 or IPv4 address. Runloop documents Docker-in-Docker but not nested virtualization, and reaches devboxes through HTTPS tunnels only.

Files kept on every plan, no session cap

bochka snapshots the disk every minute and on stop, and a stopped sandbox resumes with the same files on any plan. Paid plans have no session cap, so an agent can run for days. On Runloop, keeping a devbox's disk between runs means the Pro plan's suspend or taking disk snapshots yourself.

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
Hardware: Dedicated AMD Ryzen 9 9950X (Zen 5) hosts
Regions: EU: Germany, Finland, France
Plans: From $20 a month, all of it usage credit, 7-day trial

Runloop

Runloop is a US platform of sandboxes, called devboxes, for building, running and testing AI coding agents.

You get Linux devboxes built from Dockerfile-style blueprints, disk snapshots, HTTPS tunnels, agent gateways that hide API keys, and Axons, event streams that drive agents such as Claude Code. Each devbox runs in a micro-VM on Runloop's own bare-metal hypervisor, with a container layer inside. It is built for teams shipping coding agents, plus evaluation and RL fine-tuning work on the Enterprise plan.

Isolation: Micro-VM on a custom bare-metal hypervisor, with a container layer on top
Compliance: SOC 2 Type 2
Architectures: x86_64 and arm64 base blueprints
Own-cloud deploy: Deploy to VPC on AWS, GCP and Azure (Enterprise)
Regions: Not documented or selectable
Plans: Basic (usage only), Pro ($250/month plus usage), Enterprise (custom)
Company: Runloop AI, Inc.

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	Runloop: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both fit fully; bochka adds nested virtualization for Android emulators and keeps the disk on every plan.	3rd cheapest of 367 $634 a month	20th cheapest of 367 $8,152 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Runloop can suspend an idle devbox and wake it on an HTTP request, but suspend needs the Pro plan and the disk is kept only while suspended or in a snapshot.	5th cheapest of 366 $657 a month	32nd cheapest of 366 $10,194 a month
Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Runloop ranks higher for many short code runs, because bochka's per-plan start limits queue very large bursts.	186th of 345, with limits $2,000 a month	44th cheapest of 345 $525 a month
Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month	Cheapest of 361 $209 a month	26th cheapest of 361 $3,301 a month
RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Runloop ranks higher for RL rollouts: it starts large waves without published start limits and sells RL fine-tuning on Enterprise.	34th of 360, with limits $2,000 a month	4th cheapest of 360 $15,922 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	81st cheapest of 364 $2,562 a month
CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month bochka's faster CPUs finish builds and test runs sooner, and Docker works inside both.	4th cheapest of 377 $86 a month	121st cheapest of 377 $1,554 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Runloop is a compromise here: no public IP or raw TCP, and running all month needs an idle policy in place of the 48-hour lifetime setting.	18th cheapest of 368 $26 a month	113th cheapest of 368 $410 a month
Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both ship a desktop and a browser your agent can control; bochka streams the desktop at 60fps and you can embed it in your app.	6th cheapest of 369 $200 a month	39th cheapest of 369 $2,306 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	40th cheapest of 367 $1,153 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	68th cheapest of 346 $781 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	266th of 338, with limits $15,611 a month
Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Both fit; Runloop can lock each devbox to a hostname allowlist, bochka gives each one a full kernel with nested virtualization.	2nd cheapest of 360 $200 a month	10th cheapest of 360 $770 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	Runloop
Isolation	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts	Micro-VM on a custom bare-metal hypervisor, plus a container layer
Nested virtualization	Yes: /dev/kvm, Android emulator, VMs inside	Not documented; Docker-in-Docker blueprints only
Docker inside	Yes, with root and systemd	Yes, on the dnd blueprints, as root
Images	Templates from named snapshots, no Dockerfile builds	Blueprints built from Dockerfiles, plus disk snapshots
CPU architecture	x86_64 only	x86_64 and arm64
Keeping files	Snapshot every minute and on stop, on every plan; resume with the same disk	Disk kept through suspend (Pro plan) or manual disk snapshots; shutdown ends the devbox
Long runs	No session cap on paid plans; default TTL 1 hour, changeable	Fixed lifetime 1 hour by default, 48 hours max; an idle policy replaces it
Idle sleep and wake	No idle timer; TTL based	Suspend after idle, wake on an HTTP request to the tunnel (Pro)
Inbound networking	HTTPS URLs for up to 50 ports, token-protected by default, raw TCP, dedicated IPv6 or IPv4	One HTTPS tunnel per devbox covering its ports, open or bearer token; SSH through a TLS proxy; no public IP
Egress rules	Open internet, no provider-side allowlist	Hostname allowlist with wildcards, or block all
Hidden API keys	Credentials proxy for model providers and any HTTPS API; switch a credential to another account when one runs out	Agent gateways for any API endpoint with bearer, header or basic auth
Built-in agents	Claude Code, Codex, pi, OpenCode, Prime Agent, Kimi Code, Mistral Vibe, with a prompt, steer and events API	Claude Code, Codex, OpenCode, Gemini CLI, DeepAgents, driven through Axons and Broker
Where it runs	EU only (Germany, Finland, France), EU data residency	Regions not documented; Deploy to VPC on AWS, GCP or Azure (Enterprise)
Usage per sandbox	Per-sandbox usage API and spend limits	Usage shown on the dashboard; no per-devbox usage endpoint documented
Compliance and transparency	SOC 2 is in progress. We're open about where we stand: live status and data retention policy.	SOC 2

Every feature Battleships tracks (43)

Feature	bochka	Runloop
Full VM (own kernel)	Yes	Yes
Docker inside	Yes	Yes
Nested virtualization	Yes	No
Root	Yes	Yes
Systemd	Yes	Not published
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	No
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	No
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	Yes
GPU	No	No
Windows	No	No
Arm64	No	Yes
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	No
Audit logs	No	Not published
SSO	No	Yes
SOC 2	No	Yes
HIPAA	No	Not published
EU data residency	Yes	No
Zero data retention	Yes	Not published

Performance

bochka26.69 runs/s

Runloop8.29 runs/s

Both were measured on the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB (run 36498291449, 2026-09-29). bochka scored 26.69 runs a second and Runloop 8.29, about 3.2 times apart. The test measures CPU work only, not start time or network speed.

Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite.

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	Runloop, 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	$113 · Basic
One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month	$26 · $20/mo	$429 · Basic
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	$5,268 · Basic
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,441 · Basic
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	$3,184 · Basic

bochka: Plans start at $20 a month and the whole fee is usage credit, billed per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.

Runloop: Runloop bills per second for the CPU and memory you allocate, while a devbox is starting, running, suspending or resuming, and bills its disk for the devbox's whole life. Basic has no plan fee; Pro adds $250 a month that is not usage credit and unlocks suspend and resume.

Limits in those scenarios

Runloop's fixed lifetime setting defaults to 1 hour and tops out at 48 hours, but an idle policy replaces that cap, so a devbox can run 24/7; suspending on idle needs Pro. Runloop publishes no concurrency cap for paid plans and no egress price, and its disk tops out at 64 GiB. bochka's limit that bites is start rate: even the $2,000 plan queues bursts above 90 starts a minute, so 1,000 jobs at once does not fit there.

Scenario	bochka	Runloop
One coding agent, workdays	None that bite	egress price not published
One agent that never stops	None that bite	egress price not published
50 agents in parallel	None that bite	egress price not published
Sandboxes for your users	None that bite	egress price not published
1,000 short jobs at once	max 2,400 starts/day (needs ~6,667) max 600 starts/hour (needs ~1,000) bursts above 90 starts/min are queued (a burst of 333 takes ~4 min to start)	egress price not published

Which one should you use?

Use Runloop when

you launch very large bursts of short jobs, or need hostname allowlists, arm64 or devboxes inside your own AWS, GCP or Azure account.

Lock down the network. Useful if a sandbox must only reach a fixed list of hosts: Runloop allows listed hostnames, with wildcards, or blocks everything.
Run it in your own cloud. On the Enterprise plan, Runloop can run devboxes inside your own AWS, GCP or Azure account.
Sleep when idle, arm64 and Dockerfiles. Useful for idle devboxes and arm64 builds: Runloop can suspend and wake on a request (Pro), and builds images from Dockerfiles.

Use bochka when

your agents do real work for hours: installs, builds, tests, Docker and emulators, on CPUs about three times faster, with files kept on every plan.

About three times the CPU speed. Agents spend most of their time waiting on installs, builds and tests. At about a third of the speed, each of those waits takes three times as long on Runloop, and you pay for the waiting.
A fuller Linux machine. Without /dev/kvm an Android emulator or a VM does not start at all, and with HTTPS tunnels only, a database or server that speaks raw TCP has no way in.
Files kept on every plan, no session cap. On Runloop a devbox is gone once it shuts down, so keeping an agent's work means the $250-a-month Pro plan for suspend, or snapshot code you write and maintain yourself.

Questions people ask

Is bochka cheaper than Runloop?

In most of our scenarios, yes. One coding agent on workdays costs $20 a month on bochka and $113 on Runloop, and 50 agents in parallel cost $317 versus $5,268. For 1,000 short jobs at once, Runloop fits and bochka's start limits do not.

Is Runloop faster than bochka?

Not on CPU. On the same Node.js build-and-test benchmark at 4 vCPU / 8 GB, bochka ran 26.69 loops a second and Runloop 8.29.

Can I run Android emulators or VMs inside Runloop?

Runloop documents Docker-in-Docker but not nested virtualization or /dev/kvm. bochka exposes /dev/kvm, so Android emulators and VMs run inside a sandbox.

Can I limit which websites a sandbox can reach?

On Runloop, yes: network policies allow only the hostnames you list, or block all traffic. bochka has no provider-side egress allowlist, so you filter inside the VM.

Is Runloop SOC 2 compliant? What about bochka?

Runloop's trust center lists SOC 2 Type 2. For bochka, 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.

Does bochka support Dockerfiles or arm64 like Runloop?

No. bochka builds templates from named snapshots of a running sandbox instead of Dockerfiles, and runs x86_64 only. Runloop builds blueprints from Dockerfiles and offers arm64.

Start a sandbox

Install the CLI, then run bochka new.

Product preview