bochka vs Superserve
Both give each agent its own VM that can run as long as you want. bochka gives that agent a desktop, a browser, nested virtualization and a built-in coding agent you drive by API, while Superserve is strongest at pausing a headless VM with its memory and waking it on the next call.
Where bochka stands out
A screen and a browser for the agent
Every bochka sandbox can run a Linux desktop streamed at 60fps, with Chromium and computer use ready to go. Your agent can click through the app it just built, and you can watch or embed the stream in your own product.
Coding agents you drive from outside
Claude Code, Codex and five other agents come preinstalled, and you prompt, steer and follow them through one API. Keys stay in a credentials proxy, and a credential can switch to another account of the same type when one runs out of credits.
A whole machine you can log into
bochka exposes /dev/kvm for Android emulators and VMs, gives you SSH, raw TCP and your own IP, and offers machines up to 16 vCPU / 32 GB without a support ticket. It runs on dedicated AMD Ryzen 9 9950X hosts.
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
Superserve
Superserve sells virtual machines for long-horizon agents: Firecracker microVMs that pause, resume and run with no 24-hour limit.
Each Superserve sandbox is a Firecracker microVM built from a template based on a linux/amd64 Docker image, driven from TypeScript and Python SDKs, a REST API or an MCP server. Pausing saves memory, processes and files, and a call to the sandbox wakes it again. It is built for teams running headless code and agent jobs that need egress rules and keys kept out of the sandbox.
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 | Superserve: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker, a browser to test the app and often an Android emulator; bochka has all three, and Superserve has Docker but no desktop or /dev/kvm. | 3rd cheapest of 367 $634 a month | 304th of 367, with limits $6,007 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both can run an assistant all month, but on Superserve an idle running sandbox bills full vCPU and RAM unless your code pauses it. | 5th cheapest of 366 $657 a month | 294th of 366, with limits $6,123 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Superserve suits short code runs that pause with their memory and wake on the next call. | 186th of 345, with limits $2,000 a month | 134th of 345, with limits $278 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Each of your users can get a bochka machine with HTTPS hosting and a built-in agent, without asking support to raise a per-team sandbox cap. | Cheapest of 361 $209 a month | 152nd of 361, with limits $1,946 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Superserve's memory snapshots let many rollouts start from the exact same running state. | 34th of 360, with limits $2,000 a month | 135th 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 | 179th of 364, with limits $1,667 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 VM images need nested virtualization, which bochka has and Superserve does not. | 4th cheapest of 377 $86 a month | 178th of 377, with limits $805 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 315th of 368, with limits $246 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 screen; bochka streams a 60fps Linux desktop with Chromium, and Superserve sandboxes are headless. | 6th cheapest of 369 $200 a month | 285th of 369, with limits $1,667 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month bochka ships Chromium on a desktop, while on Superserve you install and run a browser yourself inside the VM. | 7th cheapest of 367 $200 a month | 292nd of 367, with limits $833 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 | 270th of 346, with limits $417 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 | 216th of 338, with limits $8,334 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 | 262nd of 360, with limits $421 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 | Superserve |
|---|---|---|
| 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, self-serve | Up to 10 vCPU / 20 GiB; new teams start at 2 vCPU / 2 GiB until support raises it |
| Session length | No cap on paid plans; you set the time to live | No 24-hour limit; optional auto-pause after a set active time |
| Pause and resume | Disk is saved every minute and on stop; resume boots the machine again | Pause saves memory, processes and files; resume picks up where processes left off |
| Fork | Fork a running sandbox with its disk, no pause | Snapshot memory and disk, then start forks from it; the source pauses briefly, usually under a second |
| Wake on request | No; a stopped sandbox is started by API | Yes; a command, file call or connect resumes a paused sandbox |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | Not documented |
| Desktop and browser | 60fps Linux desktop with Chromium and computer use | Headless; no desktop or managed browser |
| Shell access | SSH, plus exec and files API | SDK and API exec, terminal sessions over WebSocket, files API; no SSH |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; own IP | HTTPS preview URL per published port, public or private with a token; no raw TCP or own IP |
| Outbound rules | Open internet, no provider-side allowlist | Allow lists by CIDR or domain, deny lists by CIDR, and a log of every HTTP and HTTPS connection |
| Coding agents | Seven agents preinstalled, with a prompt, steer and events API | Templates such as superserve/claude-code; you run the agent in a terminal or through exec |
| 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 | Stand-in tokens swapped for real keys on the way out, scoped by host, with an audit log of every request |
| Self-hosting | No | Self-hostable, bring your own cloud, on-premise on Enterprise |
| 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 | Superserve |
|---|---|---|
| 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 | No |
| 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 | Yes |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | No |
| 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 | No |
| MCP server | No | Yes |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | Yes |
| BYOC | No | Yes |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | Yes |
| Audit logs | No | Yes |
| SSO | No | No |
| SOC 2 | No | Yes |
| HIPAA | No | Yes |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement: Superserve has not been run on the StarSling hpc-sandbox-benchmarks CPU test that bochka was measured on (26.69 runs per second at 4 vCPU / 8 GB). ComputeSDK's benchmark measured Superserve start times, with a median of about 316 ms to a ready sandbox, which is a different thing from CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Superserve 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 | Superserve, 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 | $62 · Pay-as-you-go |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $246 · 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 | $2,993 · Pay-as-you-go · 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 | $833 · 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 | $1,667 · 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.
Superserve: Superserve has no monthly fee and bills per second for the vCPU and RAM you allocate while a sandbox is active, idle time included, until you pause or delete it. A paused sandbox pays only for storage, which the pricing page lists at $0.000108 per GiB-hour.
Limits in those scenarios
Superserve caps how many sandboxes a team can have active at once, and the scenario table uses a cap of 20, so 50 agents, sandboxes for your users and 1,000 short jobs do not fit without asking support for more. New teams also start at 2 vCPU / 2 GiB per sandbox, so the 4 vCPU / 8 GiB shapes here need a support request first. bochka has room for the fleets, but at 1,000 short jobs at once even the $2,000 plan queues starts above 90 per minute.
| Scenario | bochka | Superserve |
|---|---|---|
| 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 Superserve when
your agents run headless and sleep between calls, so memory pause and wake on call matter, or when you need egress rules, self-hosting or US hosting.
- Memory pause, snapshots and wake on call. Useful for jobs that sleep between calls: a paused sandbox resumes with its processes running when the next command arrives.
- Egress rules and a network log. Superserve can limit which domains and CIDRs a sandbox reaches, and logs every HTTP and HTTPS connection it makes.
- Self-hosting and your own cloud. Teams that must keep sandboxes on their own hardware or cloud account can self-host, use bring your own cloud, or buy on-premise.
Use bochka when
your agents need a full machine: a desktop and browser, Docker and emulators, SSH, hosting, and built-in coding agents you prompt and steer from outside.
- A screen and a browser for the agent. Superserve sandboxes are headless. To test a UI or drive a website, you install a browser and a virtual display yourself and still have no stream to watch.
- Coding agents you drive from outside. On Superserve the agent template gives you the binary, then you start it in a terminal or wrap exec calls yourself, and build your own prompt queue and event stream around it.
- A whole machine you can log into. Without nested virtualization an Android emulator or a VM will not start at all. On Superserve a new team also starts at 2 vCPU / 2 GiB and must email support for a bigger shape.
Questions people ask
Is bochka cheaper than Superserve?
In four of the five scenarios on this page, yes, mostly because bochka's plan fee is usage credit and its hourly rate is lower. For 1,000 short jobs at once, Superserve's list price is lower, but neither fits: bochka queues the starts and Superserve's active-sandbox cap is far below 1,000.
Can Superserve sandboxes run as long as bochka's?
Yes. Superserve says it has no 24-hour limit, and auto-pause is off unless you set it. bochka has no session cap on paid plans either.
Can bochka pause a sandbox with its memory like Superserve?
No. bochka saves the disk every minute and when the sandbox stops, so files survive, but resuming boots the machine again. Superserve saves memory and processes and picks up where they left off.
Can I run Docker, a browser and Android emulators in each?
Both run Docker inside the sandbox. bochka also has a 60fps desktop with Chromium and exposes /dev/kvm for Android emulators, while Superserve sandboxes are headless and its docs do not mention nested virtualization.
Do both keep API keys out of the sandbox?
Yes. Both swap a stand-in for the real key as requests leave the sandbox, for model providers and other HTTPS APIs. bochka can also switch a credential to another account of the same type when one runs out of credits.
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