bochka vs StateSet Sandbox
Both give an AI agent a place to run code. bochka gives it a whole Linux VM with root that keeps its disk and runs as long as you need, while StateSet Sandbox gives it a locked-down Kubernetes pod that starts fast and ends on a timer.
Where bochka stands out
A whole machine with root
A bochka sandbox is a full VM with its own kernel, root, systemd and Docker, and it exposes /dev/kvm for Android emulators and VMs. StateSet runs each sandbox as a non-root user on a read-only root filesystem with every Linux capability dropped.
A disk that stays, for as long as you need
bochka saves the whole disk every minute and when the sandbox stops, a stop costs nothing, and paid plans have no session cap. On StateSet every sandbox ends at a timeout, and only an optional /workspace volume survives.
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 keys stay in a credentials proxy that works for 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
StateSet Sandbox
StateSet Sandbox is an execution layer for AI agents: an API that gives each agent run its own isolated Kubernetes pod.
Each sandbox is a Kubernetes pod that runs under gVisor, a user-space kernel, as a non-root user with a read-only root filesystem. You create it, run commands, read and write files, store artifacts and close it through a small API with Node and Python SDKs, and Claude Code comes preinstalled. It is built for short, contained agent runs, and you can use the hosted API or run the controller in your own Kubernetes cluster.
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 | StateSet Sandbox: 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 starts services, which needs root; StateSet runs as non-root on a read-only root filesystem. | 3rd cheapest of 367 $634 a month | 70th of 367, with limits $587 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 StateSet's maximum runtime and has to be recreated, while bochka can keep running. | 5th cheapest of 366 $657 a month | 108th of 366, with limits $575 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month StateSet is built for this: short code runs that start from warm pods and close when they are done. | 186th of 345, with limits $2,000 a month | 31st cheapest of 345 $301 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Both fit; bochka gives each user a full VM with hosting built in, while StateSet can run inside your own Kubernetes cluster. | Cheapest of 361 $209 a month | 17th cheapest of 361 $1,693 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 | 10th of 360, with limits $757 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 | 9th cheapest of 364 $197 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that build Docker images or Android apps need Docker and /dev/kvm, which bochka has and StateSet does not document. | 4th cheapest of 377 $86 a month | 86th cheapest of 377 $795 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs root, SSH and a disk that keeps everything, not only one workspace folder. | 18th cheapest of 368 $26 a month | 244th of 368, with limits $77 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month bochka streams a 60fps desktop with Chromium for computer use; StateSet's SDK has screenshot, mouse and keyboard calls but no live view. | 6th cheapest of 369 $200 a month | 110th of 369, with limits $234 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 7th cheapest of 367 $200 a month | 193rd of 367, with limits $164 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 | 211th of 346, with limits $159 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 | 56th of 338, with limits $1,499 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 | 140th of 360, with limits $99 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 | StateSet Sandbox |
|---|---|---|
| Full VM (own kernel) | Yes | No |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | No |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | Not published |
| Browser | Yes | No |
| Computer-use API | Yes | Not published |
| SSH | Yes | No |
| 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 | 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 | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | Yes |
| MCP server | No | No |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | Yes |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Yes |
| Spend limits | Yes | Yes |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Yes |
| 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 CPU measurement: StateSet Sandbox is not in the hpc-sandbox-benchmarks run that measured bochka at 26.69 runs per second at 4 vCPU / 8 GB. StateSet publishes its own start-time test, a median of 28 ms from create to first command using warm pods, which measures start time, 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. StateSet Sandbox 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 | StateSet Sandbox, 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 | $343 · Team · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $476 · Team · 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,356 · Team · 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 | $924 · Team |
| 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,467 · Team |
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.
StateSet Sandbox: StateSet charges a plan fee ($0, $49 or $299 a month) plus per-second usage, network egress and sandbox creations. Dedicated sandboxes use $0.128 per vCPU-hour ($0.10 on Team) billed on half their size, while shared sandboxes on Spot capacity cost $0.0055 per vCPU-hour and can be preempted.
Limits in those scenarios
StateSet does not fit the workday agent, the always-on machine or the agent fleet. Every sandbox ends at its plan's 24-hour maximum runtime, and only the /workspace volume survives, so packages installed elsewhere reset; the agent fleet also needs Docker inside, which StateSet's non-root pods do not offer. bochka has no session cap, but at 1,000 short jobs at once its $2,000 plan queues starts above 90 per minute, while StateSet's Team plan starts them all.
| Scenario | bochka | StateSet Sandbox |
|---|---|---|
| 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 StateSet Sandbox when
you run many short, contained code runs that must only reach approved hosts, or must run on your own Kubernetes cluster.
- Outbound rules that fail closed. Useful when agents must only reach approved hosts: an egress proxy allows or blocks domains and ports, and logs each decision.
- Run it in your own cluster. Teams that must keep agent code on their own infrastructure can run the controller in their own Kubernetes cluster.
- Fast starts and a shared class for retryable jobs. Short jobs that can retry start from warm pods and can use a low-rate shared class on Spot capacity.
Use bochka when
your agents need a real machine: root, Docker, emulators, a browser and a disk that keeps everything, running for hours or all month.
- A whole machine with root. Agents often need apt install, a Docker build or a local database. In a non-root, read-only pod those steps fail, so you bake everything into a template ahead of time.
- A disk that stays, for as long as you need. A long task on StateSet must be checkpointed and moved to a new sandbox before the timeout, and anything the agent installed outside /workspace has to be installed again.
- Agents and keys built in. StateSet's proxy covers three model providers; every other secret goes into the sandbox as an environment variable, where one prompt injection can read it.
Questions people ask
Is StateSet Sandbox a virtual machine?
Not by default. Each sandbox is a Kubernetes pod that runs under gVisor, a user-space kernel, and Kata microVM isolation is a per-sandbox option. A bochka sandbox is always a full VM with its own kernel.
Can I run Docker inside StateSet Sandbox?
StateSet's docs do not mention it, and its sandboxes run as a non-root user on a read-only root filesystem with all capabilities dropped. bochka gives you root, Docker and /dev/kvm in every sandbox.
How long can a StateSet sandbox run?
Each sandbox has a timeout you set within the plan's maximum runtime, and you can extend it up to that limit. Durable sandboxes on Pro and Team can be paused and last a few days. bochka has no session cap on paid plans.
Is bochka cheaper than StateSet Sandbox?
In the table on this page, bochka costs less in four of the five scenarios. StateSet costs less in the 1,000-job burst, where bochka also queues starts. StateSet's shared class has an even lower hourly rate, but it runs on Spot capacity that can be preempted, so it suits jobs that can retry.
Can I self-host StateSet Sandbox or bochka?
StateSet lets you run its controller in your own Kubernetes cluster. bochka is hosted only, on dedicated AMD Ryzen 9 9950X hosts in the EU.
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