bochka vs machine0
Both give each agent its own persistent Linux VM with Docker and coding agents preinstalled. bochka keeps a stopped machine's disk for free, forks it while it runs and lets you drive the agents inside from outside, while machine0 offers GPUs, bigger machines and regions in the US, UK and Asia.
Where bochka stands out
Stop for free, fork while it runs
A stopped bochka sandbox costs nothing and keeps its disk, which is saved every minute. You can fork a sandbox while it runs and get a copy with the same files, so many agents start from the same state.
Drive the agents inside from outside
Claude Code, Codex and five other agents come preinstalled, and you prompt, steer and follow them through one API. Real API keys stay outside the sandbox in a credentials proxy that works for any HTTPS API, and a credential can switch to another account when one runs out of credits.
A desktop, a browser and /dev/kvm
Every bochka sandbox has a 60fps Linux desktop with Chromium and computer use, plus nested virtualization for Android emulators and VMs. Docker, systemd and root work as on any Linux machine.
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
machine0
machine0 sells persistent cloud VMs for long-running agents, driven from a CLI or a remote MCP server.
One command gives you an SSH-ready Ubuntu or NixOS VM with its own public IPv4 and an HTTPS address at <vm>.mac0.io. The VMs run on DigitalOcean in five regions, come with Docker, Claude Code, Codex and OpenCode preinstalled, and can have GPUs from an RTX 4000 Ada up to 8x H200. It is built for developers and agents that want a long-lived machine they manage themselves, paid per minute from a prepaid balance.
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 | machine0: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run long builds with Docker, but bochka adds a desktop and Chromium for testing the app, live forks and an API to steer the coding agent. | 3rd cheapest of 367 $634 a month | 172nd of 367, with limits $1,850 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month fits both; on machine0 a stopped VM still bills at the full rate, while a stopped bochka sandbox costs nothing. | 5th cheapest of 366 $657 a month | 195th of 366, with limits $1,898 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code runs on a small machine0 size billed by the minute fit well, since nothing has to stay reserved between runs. | 186th of 345, with limits $2,000 a month | 83rd of 345, with limits $113 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month A new machine0 account runs up to 50 machines at once, so serving many users at the same time needs a higher limit first. | Cheapest of 361 $209 a month | 72nd of 361, with limits $632 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 | 44th of 360, with limits $2,600 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 | 121st of 364, with limits $520 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both fit; bochka also exposes /dev/kvm for Android emulators and VM builds, which machine0 does not document. | 4th cheapest of 377 $86 a month | 19th cheapest of 377 $250 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both make good 24/7 dev boxes with SSH and preinstalled agents; machine0 also gives each VM its own public IPv4. | 18th cheapest of 368 $26 a month | 60th cheapest of 368 $76 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month bochka ships a 60fps Linux desktop with Chromium and computer use, while on machine0 you install and expose a desktop yourself. | 6th cheapest of 369 $200 a month | 176th of 369, with limits $520 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month bochka has Chromium ready in every sandbox; machine0 has no browser product, so you set one up on the VM. | 7th cheapest of 367 $200 a month | 219th of 367, with limits $260 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 | 214th of 346, with limits $170 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 | 118th of 338, with limits $3,440 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 | 158th of 360, with limits $132 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 | machine0 |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Full VM with its own kernel on DigitalOcean |
| Docker and root | Docker, systemd and root in every sandbox | Docker preinstalled; sudo through the ubuntu user, root login disabled |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | Not documented |
| Stopping a machine | A stopped sandbox costs nothing and keeps its disk, which is saved every minute | Stopped VMs bill at the full rate; suspend snapshots the disk, stops compute billing and gives a new IP on resume |
| Fork | Fork a running sandbox with its disk | Snapshot a VM into an image, which stops it first, then create new VMs from it |
| Coding agents | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside | Claude Code, Codex and OpenCode preinstalled and logged in by profiles; you run them over SSH |
| Keeping API keys out of the machine | Credentials proxy for model providers and any HTTPS API; real keys never enter the sandbox | Injected credentials are plain files on the VM and travel with snapshots |
| Desktop and browser | 60fps Linux desktop with Chromium and computer use | No desktop or browser product; install your own |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP | Dedicated public IPv4 per VM; owner-authenticated HTTPS to port 80 at <vm>.mac0.io |
| Machines at once | 100 on the $20 plan, up to 2,000 on higher plans | 50 for new accounts after the first top-up |
| Biggest machine | Up to 16 vCPU / 32 GB on the $100 plan and above | Up to 60 vCPU / 240 GB on CPU sizes |
| GPUs | No | RTX 4000 Ada to 8x H200, from $0.836 an hour |
| Regions | EU only (Germany, Finland, France) | New York, San Francisco, London, Amsterdam and Singapore |
| Remote MCP server | No | Yes; agents can create, snapshot and delete VMs over MCP |
| 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 | machine0 |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | No |
| Root | Yes | Yes |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | No |
| Browser | Yes | No |
| Computer-use API | Yes | No |
| SSH | Yes | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| Fork/clone | Yes | Yes |
| Live fork (no pause) | Yes | No |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | No |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | Not published |
| Public IPv4 | No | Yes |
| Egress allowlist | No | No |
| 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 | Yes |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| 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 | Yes |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement for machine0 yet. On the StarSling hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, bochka did 26.69 runs per second on dedicated AMD Ryzen 9 9950X hosts. machine0 says its -premium sizes use dedicated vCPUs and are its fastest for single-thread work.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. machine0 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 | machine0, 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 | $18 · Pay as you go |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $76 · Pay as you go |
| 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 | $915 · Pay as you go |
| 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 | $260 · Pay as you go · 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 | $520 · Pay as you go · 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.
machine0: machine0 bills per minute at the size's hourly rate from a prepaid balance, with no monthly fee. A stopped VM still bills at the full rate; only a suspended VM drops to image storage at $0.078 per GB a month.
Limits in those scenarios
A new machine0 account can run 50 machines at once, so the scenarios with up to 300 user sandboxes or 1,000 short jobs at once do not fit without a higher limit. bochka's plans hold 300 user sandboxes at once, but at 1,000 short jobs at once even the $2,000 plan queues starts. On machine0 an always-on agent keeps billing while stopped, and if the balance drops to the suspension threshold its machines are snapshotted and destroyed.
| Scenario | bochka | machine0 |
|---|---|---|
| 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 |
|
| 1,000 short jobs at once |
|
|
Which one should you use?
Use machine0 when
your agents need GPUs, machines bigger than 16 vCPU / 32 GB, or a VM in the US, UK or Asia.
- GPUs on the same VM. Useful for agents that train or serve models: machine0 VMs can carry one to eight GPUs, up to H200.
- Regions beyond the EU. machine0 runs in New York, San Francisco, London, Amsterdam and Singapore, so machines can sit near users on three continents.
- Very large machines with their own IP. CPU sizes go up to 60 vCPU / 240 GB, and every VM gets a dedicated public IPv4.
Use bochka when
your agents live on their machines for days, run Docker, emulators and a browser, and you want to stop, fork and steer them from outside without putting real keys inside.
- Stop for free, fork while it runs. On machine0 a stopped VM bills at the full rate. Suspending saves money, but the snapshot becomes the only copy of the disk, the IP changes, and cloning means stopping the source VM first.
- Drive the agents inside from outside. machine0 logs agents in, but you SSH in to run them, and its docs say injected credentials are plain files on the VM that travel with snapshots, where a prompt injection can read them.
- A desktop, a browser and /dev/kvm. machine0 has no desktop or browser product, so a computer-use or browser agent first needs you to install, secure and expose a desktop on each VM, and its docs never mention /dev/kvm.
Questions people ask
Is bochka cheaper than machine0?
For one agent that works a normal workday, the two cost about the same. For agents that stay on all month or a fleet of them, bochka comes out lower, $26 against $76 a month for one always-on agent, mostly because machine0 keeps billing a stopped VM at the full rate.
Does machine0 charge for a stopped VM?
Yes. machine0 bills a stopped VM at the full rate because its resources stay reserved. Suspending stops compute billing and leaves image storage, but the VM gets a new IP when it resumes. A stopped bochka sandbox costs nothing and keeps its disk.
Can I clone a running machine in each?
bochka can fork a sandbox while it runs. On machine0 you snapshot a VM into an image, which stops the VM first, and then create new VMs from that image.
Do both come with Claude Code and Codex?
Yes. machine0 preinstalls Claude Code, Codex and OpenCode and logs them in through profiles, and you run them over SSH. bochka preinstalls seven agents and adds an API to prompt, steer and follow them from outside.
Does machine0 have GPUs?
Yes, from an RTX 4000 Ada up to 8x H200, in every region except San Francisco. bochka runs CPU machines only.
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