bochka vs smol machines
Both give each agent its own Linux VM with its own kernel. bochka gives it a fuller machine with a desktop, nested virtualization and coding agents built in, while smol machines is strongest at branching a running machine and running the same VM on your own laptop or servers.
Where bochka stands out
A whole machine, not just a VM boundary
A bochka sandbox exposes /dev/kvm for Android emulators and nested VMs, takes SSH, serves HTTPS on up to 50 ports and raw TCP, and has a dedicated IP. smol cloud gives you a command API and up to 16 published ports, with no SSH and no nested virtualization on hosted machines.
A desktop and a browser, ready to use
Every bochka sandbox can run a Linux desktop streamed at 60fps, with Chromium and computer use built in, and you can embed the stream in your app. smol cloud has no hosted desktop; its guide shows how to install and run your own Chromium inside a machine.
Agents and keys built in
Claude Code, Codex and five other agents come preinstalled, and you prompt, steer and follow them from outside through one API. Real API keys stay outside the sandbox in a credentials proxy that works with 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
smol machines
smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.
The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.
- Uptime SLA
- 99.95% on Pro, Startup and 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 | smol machines: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run Docker inside the VM, but bochka adds /dev/kvm for Android emulators, SSH, and coding agents you prompt and steer through an API. | 3rd cheapest of 367 $634 a month | 73rd of 367, with limits $604 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine needs a desktop, a browser and keys it cannot leak; bochka has all three built in, while smol cloud has none of them. | 5th cheapest of 366 $657 a month | 148th of 366, with limits $1,038 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month smol machines fits short code runs well: a one-minute minimum, a /code endpoint for Python and JavaScript, and branches of a warm machine that pay the minimum once. | 186th of 345, with limits $2,000 a month | 12th cheapest of 345 $140 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Both fit; smol machines starts a stopped machine on the next command, while bochka gives each user a desktop, hosting on up to 50 ports and a credentials proxy. | Cheapest of 361 $209 a month | 7th cheapest of 361 $531 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month smol machines can branch a running machine with its memory and processes, so many rollouts start from one prepared state. | 34th of 360, with limits $2,000 a month | 111th of 360, with limits $6,978 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 | 36th cheapest of 364 $670 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 boot VMs need nested virtualization, which bochka has and smol cloud does not expose. | 4th cheapest of 377 $86 a month | 66th cheapest of 377 $514 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 216th of 368, with limits $29 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month bochka streams a full Linux desktop at 60fps with computer use; on smol cloud you would build and run your own desktop stack inside the VM. | 6th cheapest of 369 $200 a month | 90th of 369, with limits $156 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month bochka ships Chromium ready for agents; smol machines documents how to run your own Chromium inside a machine. | 7th cheapest of 367 $200 a month | 176th of 367, with limits $136 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 | 241st of 346, with limits $242 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 | 148th of 338, with limits $4,344 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 | 252nd of 360, with limits $377 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
Every feature Battleships tracks (43)
| Feature | bochka | smol machines |
|---|---|---|
| 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 | No |
| Computer-use API | Yes | No |
| SSH | Yes | No |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | No |
| 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 | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | No |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | Yes |
| Self-hosting | No | Yes |
| BYOC | No | Yes |
| Open source | No | Yes |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Yes |
| Usage per sandbox (API) | Yes | Yes |
| Audit logs | No | Not published |
| SSO | No | Yes |
| SOC 2 | No | No |
| HIPAA | No | No |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement: smol cloud has not been run on the StarSling hpc-sandbox-benchmarks CPU test. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB. smol machines publishes a boot time under 200ms for smolvm, which is a start-time figure, not CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. smol machines 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 | smol machines, 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 | $25 · Standard |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $93 · Standard |
| 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 | $1,139 · Pro |
| 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 | $465 · Startup |
| 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,389 · Startup |
bochka: Plans start at $20 a month, and the whole fee is usage credit. You pay per second for the size you pick while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
smol machines: smol cloud charges a base fee for every hour a machine runs, plus the CPU and memory the guest actually uses, with a one-minute minimum and disk billed even while stopped. Pro ($20 a month) and Startup ($150 a month) are fees added on top of usage, not credit, and new accounts get $100 of credit once.
Limits in those scenarios
smol machines caps how many machines you hold and run at once by plan: 20 on Standard, 100 on Pro and 1,000 on Startup, with stopped machines still holding a slot. So 50 agents in parallel needs Pro, and 1,000 short jobs at once needs Startup, whose fee is added on top of the usage in the table. bochka's limit that bites is starts: at 1,000 short jobs at once, the $2,000 plan queues starts above 90 a minute, while smol machines on Startup can start them all.
| Scenario | bochka | smol machines |
|---|---|---|
| One coding agent, workdays | None that bite | None that bite |
| One agent that never stops | None that bite | None that bite |
| 50 agents in parallel | None that bite | None that bite |
| Sandboxes for your users | None that bite | None that bite |
| 1,000 short jobs at once |
| None that bite |
Which one should you use?
Use smol machines when
you want one open-source VM engine from your laptop to your own servers, or you fan out many branches of a running machine with its memory.
- Open source, from laptop to your own servers. Teams that want to run the same VM locally, in a hosted cloud and on their own servers can do it with one open-source engine.
- Live branches with memory. Useful for RL and test fan-out: branch a running machine with its memory and processes, and wake stopped machines on the next command.
- Outbound allowlists and arm64. Teams that must limit which hosts a machine reaches, or need arm64 images, get both on smol cloud.
Use bochka when
your agents need a whole machine for real work: Docker, emulators, SSH, a desktop and a browser, with coding agents you drive from outside and keys that never enter the sandbox.
- A whole machine, not just a VM boundary. An agent that needs an Android emulator or a VM inside its sandbox cannot start one on smol cloud, and tools that expect SSH have to be rewired to an exec API.
- A desktop and a browser, ready to use. On smol cloud you build, package and maintain the desktop, browser and screen stream yourself before a computer-use agent can click anything.
- Agents and keys built in. On smol cloud secrets are environment variables the guest can read, so one prompt injection can leak them, and you write the agent harness on top of exec calls yourself.
Questions people ask
Is bochka cheaper than smol machines?
In four of the five scenarios on this page, yes. For 1,000 short jobs at once, smol machines starts the whole burst while bochka's plans queue the starts, so smol machines fits that one better. smol bills the CPU and memory a guest actually uses, so a machine that sits idle most of the day costs less than one that works all day.
Is smol machines open source?
The engine, smolvm, and the smol SDK are open source and free to run on your own computer or servers. smol cloud, the hosted service, is paid. bochka is a hosted service only.
Can I run Docker and Android emulators in each?
Both run Docker inside the VM; smol's guide says Docker data must live on the machine's ext4 disk. bochka also exposes /dev/kvm for Android emulators and nested VMs, while smol cloud does not expose nested virtualization on hosted machines.
Can smol machines fork a running machine?
Yes. It branches a running machine into children that keep its memory and running processes, and it can checkpoint a machine with its RAM. bochka forks a running sandbox with its disk, and the fork boots fresh.
Does smol cloud keep API keys out of the VM?
Not on the hosted cloud today: its docs say secret values are plaintext inside the guest. Placeholder credential swapping exists in self-hosted smolvm. bochka's credentials proxy keeps real keys outside the sandbox for model providers and any HTTPS API.
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
More comparisons
- bochka vs E2B
- bochka vs Daytona
- bochka vs Modal
- bochka vs Vercel Sandbox
- bochka vs Blaxel
- bochka vs Runloop
- bochka vs Tensorlake
- bochka vs Cloudflare Sandbox
- bochka vs exe.dev
- bochka vs Agent 37
- bochka vs Oracle Cloud
- bochka vs IONOS Cloud
- E2B vs smol machines
- Daytona vs smol machines
- Modal vs smol machines
- Vercel Sandbox vs smol machines
- Cloudflare Sandbox vs smol machines
- Blaxel vs smol machines
- Runloop vs smol machines
- Tensorlake vs smol machines