bochka vs Wasmer
Wasmer Edge hosts web apps as WebAssembly packages that start on a request and stop when idle. bochka gives each agent a whole Linux machine with its own kernel, root and Docker, that keeps its disk between runs.
Where bochka stands out
A real Linux machine, not a Wasm runtime
A bochka sandbox is a full VM with its own kernel, root, systemd and Docker, so anything that runs on Ubuntu runs there. Wasmer Edge runs code that was built as a WebAssembly package, and it has no Docker or container images.
A machine that keeps its state
bochka keeps the sandbox disk between runs, saves it every minute and when it stops, and can fork a running sandbox with its disk. Wasmer instances are stateless and shut down after a short idle period.
Agents, keys and a desktop built in
Claude Code, Codex and five other agents come preinstalled, and you drive agents inside from outside with one prompt, steer and events API. Real API keys stay outside the sandbox in a credentials proxy, and each sandbox has a 60fps desktop with Chromium for computer use.
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
Wasmer
Wasmer makes an open-source WebAssembly runtime and Wasmer Edge, a cloud that hosts apps built as Wasm packages. It is an app platform, not a machine-per-agent sandbox.
You deploy a package from the Wasmer registry or a Git repo, and Edge runs it as WebAssembly (WASIX) instances that start when traffic arrives and shut down after a short idle period. Instances are stateless, so files that must last go in volumes or a database. It is built for web apps, APIs, WordPress and static sites that should scale to zero, and the same runtime can run on your own machines.
- Open source
- Wasmer runtime under the MIT license
- Backers
- Y Combinator
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 | Wasmer: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory installs packages, runs Docker and builds native code, which needs a real Linux machine; Wasmer only runs code built for WebAssembly. | 3rd cheapest of 367 $634 a month | 151st of 367, with limits $1,319 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month needs state that stays put, while Wasmer instances are stateless and stop when idle. | 5th cheapest of 366 $657 a month | 189th of 366, with limits $1,729 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code runs that start on a request and stop when idle are close to what Wasmer Edge does, as long as the code runs on its Wasm runtime. | 186th of 345, with limits $2,000 a month | 224th of 345, with limits $125 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Giving each user a machine they can install anything on needs a full Linux VM; Wasmer suits hosting each user's web app instead. | Cheapest of 361 $209 a month | 223rd of 361, with limits $631 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 | 288th of 360, with limits $11,063 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 | 273rd of 364, with limits $825 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs often need Docker, root and native toolchains, which a WebAssembly instance does not have. | 4th cheapest of 377 $86 a month | 306th of 377, with limits $780 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs a disk that keeps your work and a normal shell; Wasmer keeps state only in volumes and databases. | 18th cheapest of 368 $26 a month | 156th of 368, with limits $70 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Computer-use agents need a desktop and a real browser, and Wasmer Edge offers neither. | 6th cheapest of 369 $200 a month | 152nd of 369, with limits $374 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Running Chromium needs a full Linux machine, which bochka gives you and Wasmer Edge does not. | 7th cheapest of 367 $200 a month | 201st of 367, with limits $194 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 | 261st of 346, with limits $334 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 | 180th of 338, with limits $6,468 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 | 246th of 360, with limits $348 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 | Wasmer |
|---|---|---|
| Kind of product | A sandbox: one full Linux VM per agent or user | An app platform that hosts WebAssembly packages |
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | WebAssembly (WASIX) sandbox per workload, no container or VM |
| Run any Linux program | Yes: root, systemd, apt and Docker inside | Only code built as a Wasm package; no Docker or OCI images |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | No |
| State between runs | The machine keeps its disk, saved every minute and on stop | Instances are stateless; files last only in volumes (backed up every 24 hours) or a database |
| Fork | Fork a running sandbox with its disk | No; new instances start fresh from the app package |
| Idle and wake | Runs until you stop it or its time to live ends; a stopped sandbox is started by API | Starts on the next request and shuts down after a short idle period |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP | Public HTTPS app URL and custom domains; TCP/UDP apps and a dedicated IP on Pro |
| Shell access | SSH and a terminal on every plan | SSH and SFTP on Pro and above |
| Desktop and browser | 60fps Linux desktop and Chromium, with computer use | No |
| Coding agents | Seven agents preinstalled, with a prompt, steer and events API | None built in |
| Keeping API keys out of the sandbox | Credentials proxy for model providers and any HTTPS API | Secrets passed into the app as environment variables |
| Regions | EU only (Germany, Finland, France) | France, Germany, Canada and three US regions |
| Self-hosting | No | MIT-licensed runtime you can run on your own machines |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | Not published |
Every feature Battleships tracks (43)
| Feature | bochka | Wasmer |
|---|---|---|
| Full VM (own kernel) | Yes | No |
| Docker inside | Yes | No |
| 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 | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | No |
| Fork/clone | Yes | No |
| Live fork (no pause) | Yes | No |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Not published |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | Yes |
| Wake on request | No | Yes |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | Yes |
| Public IPv4 | No | Yes |
| Egress allowlist | No | No |
| Secret proxy | Yes | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | No |
| Agent harness API | Yes | No |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | Yes |
| BYOC | No | No |
| Open source | No | Yes |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Not published |
| SSO | No | Not published |
| SOC 2 | No | Not published |
| HIPAA | No | Not published |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement. bochka did 26.69 runs per second on the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, but Wasmer Edge has not been run on that benchmark, and its WebAssembly runtime is a different kind of machine.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Wasmer 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 | Wasmer, 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 | $36 · Hobby · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $143 · Hobby · 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 | $1,740 · Hobby · 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 | $498 · Hobby · 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 | $2,213 · Hobby · 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.
Wasmer: Wasmer bills active CPU at $0.10 per CPU hour and provisioned memory at $0.01 per GB-hour, after a monthly allowance of 6 CPU hours and 400 GB-hours. Pro costs $10 a month plus $5 per extra seat, and bandwidth, storage, requests and build minutes are billed on top.
Limits in those scenarios
Wasmer does not fit any scenario on this page as a like-for-like sandbox, because it is an app platform: its instances run Wasm packages, have no Docker and do not keep a machine's state. It also does not publish how many instances can run at once, so 300 or 1,000 parallel sandboxes are unconfirmed. bochka fits every scenario except 1,000 short jobs at once, where even the $2,000 plan queues starts above 90 per minute.
| Scenario | bochka | Wasmer |
|---|---|---|
| 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 Wasmer when
you are hosting web apps or APIs that should start on a request, stop when idle and run close to users in the US and EU, or when you want a WebAssembly runtime you can also run yourself.
- Scale to zero for web apps. Good for web apps and APIs with spiky traffic: instances start on a request and stop when nobody is using them.
- Regions in North America and Europe. Apps can run in the US, Canada, France and Germany, close to users on both sides of the Atlantic.
- Open-source runtime you can run yourself. The Wasmer runtime is MIT-licensed, so the same sandboxes can run on your laptop or your own servers.
Use bochka when
your agents need a whole Linux machine: installs, builds, tests, Docker, emulators and a browser, on a disk that stays between runs.
- A real Linux machine, not a Wasm runtime. Coding agents run apt, pip, npm, Docker and native compilers all day. On Wasmer each of those tools has to work on WebAssembly first, and the ones that do not simply cannot run.
- A machine that keeps its state. An agent's cloned repos, installed packages and half-done work live on its disk. On Wasmer that state must be moved into volumes or a database, and volumes are backed up once a day.
- Agents, keys and a desktop built in. Wasmer passes secrets into the app as environment variables an agent can read, has no desktop or browser, and leaves the agent harness for you to build.
Questions people ask
Is bochka cheaper than Wasmer?
In the five scenarios on this page, bochka's estimate is lower in each one, for example $317 against $1,740 a month for 50 agents in parallel. Wasmer does not fit any of them as a like-for-like sandbox, so treat its numbers as rough.
Can I run Docker on Wasmer Edge?
No. Wasmer Edge runs apps as WebAssembly packages from its registry, not Docker or OCI images, and there is no container engine inside an instance. bochka runs Docker inside every sandbox.
Is Wasmer a sandbox for AI agents?
Wasmer describes its runtime as lightweight sandboxes for apps and AI agents, and each workload is isolated by WebAssembly. Wasmer Edge itself is an app host whose instances are stateless and stop when idle, so it does not give an agent a lasting Linux machine.
Does a Wasmer app keep its files?
Not on the instance: instances are stateless and ephemeral. Files that must last go in volumes, which stay in one region and are backed up every 24 hours, or in a database. A bochka sandbox keeps its whole disk and saves it every minute.
Which is faster?
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 Wasmer Edge has not been run on it.
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