bochka vs orkestr
Both give each agent its own VM with its own kernel, hosted only in the EU. orkestr keeps it small and fast to boot with tight network rules, while bochka gives the agent a whole Linux machine with a desktop, a browser and coding agents built in.
Where bochka stands out
A whole Linux machine, not a trimmed guest
A bochka sandbox is full Ubuntu with root, systemd, Docker and /dev/kvm, reached over SSH, on machines up to 16 vCPU / 32 GB. orkestr runs a stripped-down guest from a Python, Node or Debian image, driven by exec calls, and stops at 4 vCPU / 8 GB.
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 API keys stay outside the sandbox in a credentials proxy, and a credential can switch to another account when one runs out of credits.
Desktop, browser and forks
Each bochka sandbox can show a Linux desktop at 60fps with Chromium, so agents can use a browser and click through apps. You can also fork a running sandbox into copies that start from the same disk.
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
orkestr
orkestr is an EU hosting platform with two products: always-on app hosting billed per seat, and pay-as-you-go Sandboxes for AI agents.
orkestr Sandboxes are small Linux VMs, each with its own kernel, that boot in about 150 ms from a Python, Node or Debian base image. You drive them with exec and file calls from Python and JS SDKs, a CLI, a REST API or an MCP server, and you can pause one with its memory and resume it later. It is built for agents that run untrusted code, tests and builds, and the network is off unless you turn it on.
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 | orkestr: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker, root and bigger machines for builds; bochka has all three documented and goes up to 16 vCPU, while orkestr stops at 4 vCPU / 8 GB. | 3rd cheapest of 367 $634 a month | 62nd of 367, with limits $469 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month runs on bochka with no countdown, while on orkestr your code has to keep resetting a timer of at most 24 hours. | 5th cheapest of 366 $657 a month | 140th of 366, with limits $984 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month orkestr fits short code runs well: a code-interpreter image keeps variables between calls, sandboxes boot in about 150 ms, and the network can stay off. | 186th of 345, with limits $2,000 a month | 85th of 345, with limits $121 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month orkestr can wake a paused sandbox on the first web request, but its 32 GB RAM budget for all live sandboxes on Pay as you go limits how many users run at once. | Cheapest of 361 $209 a month | 52nd of 361, with limits $382 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 | 115th of 360, with limits $7,005 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 | 122nd of 364, with limits $529 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI that builds containers or Android apps needs Docker and /dev/kvm, which bochka documents and orkestr does not. | 4th cheapest of 377 $86 a month | 282nd of 377, with limits $492 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box you work in every day wants SSH and a disk that stays; bochka has both, while orkestr offers exec calls and a RAM-backed workspace. | 18th cheapest of 368 $26 a month | 211th of 368, with limits $24 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 to see and click; bochka streams one at 60fps, and orkestr sandboxes are headless. | 6th cheapest of 369 $200 a month | 80th of 369, with limits $119 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 for browser agents; orkestr has no browser in its base images. | 7th cheapest of 367 $200 a month | 166th of 367, with limits $102 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 | 226th of 346, with limits $202 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 | 140th of 338, with limits $4,045 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 | 213th of 360, with limits $226 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 | orkestr |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | VM with its own kernel per sandbox; hypervisor not named |
| Biggest machine | Up to 16 vCPU / 32 GB on the $100 plan and above | 4 vCPU / 8 GB, size fixed at create |
| Root, systemd and Docker | Root, systemd and Docker preinstalled on full Ubuntu | Not documented; base images are Python 3.12, Node 22 or Debian 12 |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | Not documented |
| Access | SSH and SCP, plus an API | Exec and file calls over SDK, CLI, REST or MCP; no SSH |
| Session length | No cap on paid plans; you set the time to live | No running-time cap on Pay as you go, but a countdown of up to 24 hours that your code must keep resetting with set_timeout; 1 hour of continuous running on Free |
| Pause and resume | Disk saved every minute and on stop; resume boots the machine again | Pause saves memory and disk, resume continues running processes; 10 paused sandboxes held on Pay as you go |
| Wake on request | No; a stopped sandbox is started by API | Yes, with auto_resume: the next exec, file call or preview URL hit wakes it |
| Fork | Fork a running sandbox with its disk | No fork; a snapshot resumes only the same sandbox, once |
| Outbound rules | Open internet, no provider-side allowlist | Off by default, HTTPS allowlist by hostname, or open egress |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; own IP | HTTPS preview URL per port, public by default unless you turn on a token; needs a card |
| Desktop and browser | 60fps Linux desktop with Chromium for computer use | Headless; no desktop or browser |
| Coding agents | Seven agents preinstalled, with a prompt, steer and events API | A guide to install Claude Code and run it through exec; an MCP server to start sandboxes from agents |
| 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 are env vars or files that any code in the sandbox can read |
| 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 | orkestr |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| 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 | No |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| Fork/clone | Yes | No |
| 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 | 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 | 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 | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | Yes |
| Audit logs | No | Not published |
| SSO | No | Yes |
| 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 orkestr: it has not been run on the hpc-sandbox-benchmarks CPU test. bochka did 26.69 runs per second on that test at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. orkestr 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 | orkestr, 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 | $22 · Pay as you go · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $90 · Pay as you go · 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,081 · 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 | $307 · 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,265 · 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.
orkestr: orkestr bills sandboxes per second in euros, with no monthly fee, and the estimates here assume the vCPU and RAM are fully used. Its pricing FAQ says it bills real on-CPU time and working-set RAM, so idle time costs almost nothing, but its docs say it bills wall-clock time while the sandbox is alive, and its product page says final rates are not published yet.
Limits in those scenarios
On Pay as you go, all live orkestr sandboxes share a 32 GB RAM budget, which is four sandboxes at 4 vCPU / 8 GB or eight at 2 vCPU / 4 GB, so 50 agents or hundreds of users need Enterprise. Each sandbox runs on a countdown of up to 24 hours that your code must keep resetting. Disk and egress prices are not published, and open internet needs a card on file. bochka has no session cap, but at 1,000 short jobs at once its $2,000 plan queues the starts.
| Scenario | bochka | orkestr |
|---|---|---|
| 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 orkestr when
you run short, untrusted code jobs that need the network off or allowlisted, pause with their memory between steps, and boot in a fraction of a second.
- Memory pause and wake on request. Good for agents that sleep between steps: a paused sandbox resumes with its processes running, even on the first web request.
- Network off by default. Useful when agents run untrusted code: sandboxes start with no network, and an allowlist can limit them to chosen hosts.
- Fast boots and app hosting on one account. Fits teams that want tiny sandboxes that boot in about 150 ms, next to always-on app hosting from the same EU provider.
Use bochka when
your agents do real work on a whole machine: Docker, builds, emulators, a browser and a desktop, with coding agents built in and keys kept out of the sandbox.
- A whole Linux machine, not a trimmed guest. Agents that build containers, start databases as services or run Android emulators hit walls on orkestr, where Docker and nested virtualization are not documented and every build shares at most 4 vCPU.
- Agents and keys built in. orkestr's own docs say secrets in a sandbox are readable by any code there, including code a model wrote, so one prompt injection can leak your model key. You also write the agent harness yourself over exec.
- Desktop, browser and forks. orkestr sandboxes are headless, so computer-use and browser agents have nothing to see. Its snapshots resume only the same sandbox once, so branching ten attempts from one setup means setting it up ten times.
Questions people ask
Is bochka cheaper than orkestr?
In four of the five scenarios on this page, bochka costs less, with orkestr priced as if its vCPU and RAM are fully used. For 1,000 short jobs at once, orkestr's estimate is lower at $1,265 vs $2,000, though neither fits that burst. If orkestr bills only on-CPU time as its pricing FAQ says, idle-heavy work on orkestr costs less than shown.
Can I run Docker in an orkestr sandbox?
orkestr's docs do not say. Each sandbox has its own kernel and you can install packages on the Debian image, but Docker, systemd and /dev/kvm are not documented. On bochka, Docker and systemd are preinstalled and /dev/kvm is exposed.
Can an orkestr sandbox run for days?
On a paid account it can, if your code keeps calling set_timeout: each call sets a countdown of up to 24 hours. On the free tier, a sandbox stops after 1 hour of continuous running. bochka has no session cap on paid plans.
Can bochka pause a sandbox with its memory like orkestr?
No. bochka saves the disk every minute and when the sandbox stops, so files survive, but resuming boots the machine again. orkestr pauses with memory and resumes running processes, and can wake on the next request.
Are both hosted in the EU?
Yes. orkestr runs in Falkenstein, Helsinki and Roubaix, and bochka also runs only in the EU, with zero data retention.
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