bochka vs InstaVM
Both give each agent its own small Linux VM with its own kernel. bochka gives it a bigger machine that keeps its disk and runs as long as you want, with coding agents built in, while InstaVM is strongest at fast, short-lived VMs with tight network rules.
Where bochka stands out
A bigger machine that keeps its work
A bochka sandbox goes up to 16 vCPU / 32 GB, exposes /dev/kvm for Android emulators and VMs, and saves its disk every minute and on every stop. It has no time limit on paid plans. An InstaVM VM tops out at 8 vCPU / 8 GB and lives 5 minutes unless you set a longer lifetime.
Coding agents built in, driven from outside
Claude Code, Codex and five other agents come preinstalled in every bochka sandbox. You prompt them, steer them mid-task and follow their events through one API. InstaVM gives you a clean Linux VM and leaves the agent to you.
Hosting that goes past HTTPS
Each bochka sandbox can serve HTTPS on up to 50 ports, token-protected by default, take raw TCP, and get its own IP. InstaVM shares a port over HTTPS, with custom domains, but documents no raw TCP or dedicated IP.
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
InstaVM
InstaVM sells instant computers for AI agents: an API that starts an isolated microVM for each agent or session.
Each InstaVM sandbox is a Firecracker microVM with its own kernel, filesystem and network stack, and the home page says a cold boot usually takes under 200 ms. You drive it from Python or JavaScript SDKs, a CLI or a REST API, with extras for a browser, a Linux desktop, port shares, volumes and a secrets vault. It is built for teams that run many short code, browser and agent jobs with tight control over network access.
- Machine size
- 1 to 8 vCPU and up to 8 GB RAM per VM
- Data location
- Stored on cloud servers in the United States
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 | InstaVM: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both fit; bochka gives a software factory up to 16 vCPU / 32 GB, nested virtualization and a disk that is saved every minute, where InstaVM stops at 8 vCPU / 8 GB. | 3rd cheapest of 367 $634 a month | 17th cheapest of 367 $4,239 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month runs into InstaVM's 30-day VM lifetime, while a bochka sandbox on a paid plan can simply keep running. | 5th cheapest of 366 $657 a month | 52nd of 366, with limits $5,371 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month InstaVM is built for this: short code runs in VMs that boot in under 200 ms and go away when the job is done. | 186th of 345, with limits $2,000 a month | 35th cheapest of 345 $371 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month InstaVM Pro allows 100 VMs at once, so a product that gives each user a sandbox outgrows it fast; bochka's paid plans start at 100 and go up to 2,000. | Cheapest of 361 $209 a month | 146th of 361, with limits $1,804 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 | 134th of 360, with limits $8,334 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 | 169th of 364, with limits $1,433 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI runners that build Android apps or VM images need nested virtualization, which bochka has and InstaVM does not document. | 4th cheapest of 377 $86 a month | 336th of 377, with limits $1,396 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs a disk that survives every stop, which bochka saves every minute; on InstaVM state is lost at the end of a VM's lifetime unless you set up volumes or snapshots. | 18th cheapest of 368 $26 a month | 190th of 368, with limits $314 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both have a Linux desktop for computer use; InstaVM shows it through a noVNC viewer, and bochka streams it at 60fps. | 6th cheapest of 369 $200 a month | 30th cheapest of 369 $1,300 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Both run a browser in the sandbox; InstaVM adds a browser API with a monthly session quota per plan. | 7th cheapest of 367 $200 a month | 97th of 367, with limits $696 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 | 52nd cheapest of 346 $504 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 | 209th of 338, with limits $8,173 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 | 41st of 360, with limits $498 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 | InstaVM |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Firecracker microVM with its own kernel |
| Biggest machine | Up to 16 vCPU / 32 GB on the $100 plan and above | Up to 8 vCPU / 8 GB |
| How long a sandbox lives | No cap on paid plans; you set the time to live | You set a lifetime per VM: 5 minutes by default, 30 days at most |
| Keeping files | Disk is saved every minute and on stop; a stopped sandbox keeps it | State is lost when the VM's lifetime ends, unless you use volumes, snapshot on terminate or suspend |
| Pause and wake | Stop and start by API; the disk is kept | Suspend and resume, and a VM can wake itself when the next request arrives |
| Fork a running sandbox | Fork a running sandbox with its disk | Clone a running VM with its disk and memory; the source keeps running |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | Not documented |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 | HTTPS share for any port, private with a token or public, with custom domains; raw TCP not documented |
| Outbound rules | Open internet, no provider-side allowlist | Deny by default, with domain and CIDR allowlists; open internet needs Pro |
| Coding agents | Seven agents preinstalled, with a prompt, steer and events API | None preinstalled; you install your own agent in the VM |
| Keeping API keys out of the sandbox | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out | Secrets vault swaps the real key into outbound HTTPS requests for any host |
| Desktop for computer use | Linux desktop with Chromium, streamed at 60fps and embeddable in your app | Linux desktop through a noVNC viewer, plus a browser API |
| Where it runs | EU only (Germany, Finland, France) | United States: the privacy policy says all data is stored on US servers |
| 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 | InstaVM |
|---|---|---|
| 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 | 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 | No |
| Agent harness API | Yes | No |
| 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 | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Yes |
| SSO | No | No |
| SOC 2 | No | Yes |
| HIPAA | No | No |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement for InstaVM: it is not in the hpc-sandbox-benchmarks run we use. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. InstaVM publishes boot times, not a CPU benchmark.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. InstaVM 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 | InstaVM, 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 | $158 · Pro |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $323 · Pro · 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 | $2,796 · 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 | $845 · Pro · 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 | $1,747 · Pro · 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.
InstaVM: InstaVM bills per second for the vCPU and RAM you set, the same rates on Free and Pro, plus volumes above 10 GB by allocated size. Pro costs $100 a month as a base fee, not usage credit, and is needed to reach the open internet.
Limits in those scenarios
InstaVM's Free plan reaches only package managers and AI APIs, so every scenario here needs Pro. Pro allows 100 VMs at once, which is why InstaVM does not fit sandboxes for your users or 1,000 short jobs at once, and a VM lives 30 days at most, so an agent that never stops has to be restarted. bochka has no session cap, but its start limits are lower: at 1,000 short jobs at once, even the $2,000 plan queues starts.
| Scenario | bochka | InstaVM |
|---|---|---|
| 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 InstaVM when
you run many short code or browser jobs that need a fresh VM in under 200 ms, strict outbound allowlists, or clones that keep memory.
- Tight network rules. For agents that must only reach a few hosts, InstaVM blocks outbound traffic by default and allows the domains and CIDRs you list.
- Suspend, wake on request and memory clones. For short jobs that sleep between calls, a suspended VM can wake on the next request, and a clone copies the memory too.
- Very fast short-lived VMs. For code-interpreter bursts, InstaVM boots a fresh VM in under 200 ms and bills only while it runs.
Use bochka when
your agents do real work for hours or days: installs, builds, Docker, emulators and a desktop, on a bigger machine that keeps its disk, with coding agents ready to drive.
- A bigger machine that keeps its work. On InstaVM, a VM that reaches its lifetime is killed and its files are gone unless you set up volumes or snapshots. You need that plumbing before an agent can work on a repo for days.
- Coding agents built in, driven from outside. Without a harness API you install the agent in each VM, run it over exec or SSH and parse its output yourself, then write your own way to steer it or tell when it has finished.
- Hosting that goes past HTTPS. An agent that runs a database, a game server or anything that is not HTTP can't be reached from outside through an HTTPS-only share.
Questions people ask
Is bochka cheaper than InstaVM?
In four of the five scenarios on this page, yes, by a wide margin, mostly because bochka's plan fee becomes usage credit. For 1,000 short jobs at once neither fits: bochka queues the starts and InstaVM Pro stops at 100 VMs at once.
Can an InstaVM sandbox run for weeks?
Up to 30 days. You set each VM's lifetime, which is 5 minutes by default, and when it ends the VM is killed and its state is lost unless you use volumes or snapshots. bochka has no session cap on paid plans and keeps the disk when a sandbox stops.
Can I run Docker and Android emulators in each?
Both give you root in a VM with its own kernel. bochka also exposes /dev/kvm for Android emulators and nested VMs, which InstaVM does not document.
Do both keep API keys out of the sandbox?
Yes. InstaVM's secrets vault and bochka's credentials proxy both put the real key into outbound HTTPS requests, so the VM only sees a placeholder. bochka can also switch a credential to another account when one runs out of credits.
Is bochka faster than InstaVM?
There is no comparable measurement. bochka did 26.69 runs per second on the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, and InstaVM is not in that benchmark.
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