bochka vs Orgo
Orgo and bochka both give each AI agent its own virtual machine with a desktop, a browser and a terminal. bochka's machines can each serve apps and webhooks to the internet, run by the hundred without a sales call, and run coding agents you steer from outside, while Orgo adds Windows, Mac and phone desktops.
Where bochka stands out
Machines the internet can reach
Every bochka sandbox can serve HTTPS on up to 50 ports, token-protected by default, take raw TCP, and have its own IP. On Orgo, public HTTPS comes only through custom domains, one on Growth and three on Scale; any other computer is reached through Orgo's proxy with your API key.
Bigger machines and bigger fleets
bochka machines go up to 16 vCPU / 32 GB, and plans run from 100 to 2,000 sandboxes at once. Orgo caps a computer at 4 vCPU, and its plans hold 1, 4 or 16 computers, plus up to 100 extra you can add yourself; past that you ask for a higher cap or sign an annual Enterprise contract.
Coding agents you drive from outside, keys kept out
Claude Code, Codex and five other agents come preinstalled, and you prompt, steer and follow them 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.
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
Orgo
Orgo sells always-on cloud computers for AI agents: each agent gets its own desktop that keeps working after you log off.
Every Orgo computer is a virtual machine with a full desktop, a browser and a terminal, which you launch from a dashboard or create by REST, SDKs, a CLI or MCP. You can set up Hermes, OpenClaw, Claude Code or Codex in one click, or have Orgo's own computer-use agent drive the screen through an OpenAI-style chat API. Plans are flat monthly bundles of computers and RAM, built for people and teams running managed agents and for products that give each user a computer.
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 | Orgo: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent that runs a dev server others must open needs public inbound access, which bochka has on up to 50 ports per machine, while Orgo offers it only through a custom domain (one on Growth, three on Scale) or its authenticated API proxy. | 3rd cheapest of 367 $634 a month | Can't run it |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month fits Orgo's always-on model, but Orgo's docs say webhooks cannot reach a computer unless you point one of your custom domains at it (one on Growth, three on Scale), so most Slack or Telegram bots run in outbound mode; on bochka every machine can take webhooks over HTTPS. | 5th cheapest of 366 $657 a month | 10th cheapest of 366 $1,504 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month | 186th of 345, with limits $2,000 a month | Can't run it |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Orgo lets you add up to 100 extra computers yourself on top of a plan's 16 at most, so 300 user sandboxes need a cap raise on request there, while bochka's plans cover them without a sales call. | Cheapest of 361 $209 a month | Can't run it |
| 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 | Can't run it |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 10th cheapest of 364 $200 a month | Can't run it |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs want more CPU than Orgo's 4 vCPU per computer cap; bochka machines go up to 16 vCPU / 32 GB. | 4th cheapest of 377 $86 a month | Can't run it |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both fit a box that runs all month; Orgo charges a flat plan for its computer slots, while bochka bills per second and keeps a stopped machine for free. | 18th cheapest of 368 $26 a month | 74th cheapest of 368 $99 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both have a desktop for computer use; Orgo adds Windows, Mac and phone screens and its own computer-use agent, while bochka streams Linux at 60fps. | 6th cheapest of 369 $200 a month | Can't run it |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Both run a real Chrome or Chromium on a desktop; Orgo exits from data-center IPs with an optional browser proxy, and bochka gives each machine a dedicated IP. | 7th cheapest of 367 $200 a month | 43rd cheapest of 367 $1,504 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month Scrapers on Orgo leave from shared data-center addresses unless you bring a proxy or rent a dedicated egress IP; bochka gives each machine its own IP. | 6th cheapest of 346 $90 a month | 76th cheapest of 346 $1,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 | Can't run it |
| 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 | Can't run it |
| 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 | Orgo |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | Not published |
| 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 | No |
| 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 | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | No |
| MCP server | No | Yes |
| GPU | No | Yes |
| Windows | No | Yes |
| Arm64 | No | No |
| Self-hosting | No | Yes |
| BYOC | No | Yes |
| Open source | No | No |
| Scoped API keys | Yes | Yes |
| Spend limits | Yes | Yes |
| 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 | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement: Orgo was not part of the hpc-sandbox-benchmarks run, so we have no CPU score for it. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB on dedicated AMD Ryzen 9 9950X hosts. Note that 4 vCPU is the largest size an Orgo computer can have.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Orgo 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 | Orgo, 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 | $99 · Self-serve (fee carried in pool tiers) |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $99 · Self-serve (fee carried in pool tiers) |
| 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 | Can't run it |
| 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 | Can't run it |
| 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 | Can't run it |
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.
Orgo: Orgo charges a flat monthly fee for a bundle of computer slots and a RAM pool: Starter $29 for 1 computer, Growth $99 for 4, Scale $399 for 16, and extra computers at $32.50 each. You pay the same whether the computers run or not, and stopped computers still hold their slot until you delete them.
Limits in those scenarios
Orgo's limits are a computer count and a RAM pool per plan: 1 computer and 8 GB on Starter, 4 and 32 GB on Growth, 16 and 128 GB on Scale, with no computer above 4 vCPU, and extra computers have a published price only at the 2 vCPU / 8 GB size. That is why 50 agents in parallel at 4 vCPU have no public Orgo price, and 300 sandboxes for your users and 1,000 short jobs at once go past the 100 extra computers you can add yourself and need a higher cap on request or Enterprise. bochka's limits are a sandbox count (100 to 2,000 by plan) plus starts per minute, so the 1,000-job burst is queued and needs more starts per day than the $2,000 plan allows.
| Scenario | bochka | Orgo |
|---|---|---|
| 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 Orgo when
your agents must work on Windows, Mac or phone screens, need a memory fork of a live desktop, or must run in the US or on your own hardware.
- Windows, Mac and phone desktops. Useful if your agents must work in Windows or Mac apps, or on an Android or iPhone screen.
- Fork with live memory. Useful for trying two next steps from the same moment: a fork keeps open apps, windows and running processes.
- Outbound rules, GPUs and on-prem. Orgo can limit which hosts a computer reaches, attach small GPU slices, and run on-prem for Enterprise customers.
Use bochka when
your agents build, test and serve real software: bigger Linux VMs that the internet can reach, fleets of hundreds, and coding agents you drive by API with keys kept outside.
- Machines the internet can reach. Orgo's guides say to run chat bots in outbound mode because webhooks cannot reach the computer. Past your custom domains, a preview link, an OAuth callback or a Stripe webhook needs a tunnel you set up and keep alive yourself.
- Bigger machines and bigger fleets. At 4 vCPU a big build or test suite queues on the CPU, and every Orgo agent past the plan's count is another computer you pay $32.50 a month for, whether it runs or not.
- Coding agents you drive from outside, keys kept out. Orgo writes your secrets into /root/.env inside the computer, where the agent can read them, and its chat API drives the screen rather than the coding agent, so you script the terminal yourself.
Questions people ask
Is bochka cheaper than Orgo?
In the scenarios we priced, yes. One coding agent on workdays comes to $20 a month on bochka and $99 on Orgo, and one agent running all month comes to $26 versus $99. 50 agents at 4 vCPU, 300 user sandboxes and 1,000 short jobs have no public Orgo price: its extra computers are priced only at 2 vCPU, and the last two go past the 100 extras you can add yourself.
Can I host a website or receive webhooks on an Orgo computer?
Only through a custom domain: one on Growth, three on Scale, none on Starter. Without one, Orgo's docs say a computer has no public inbound hostname, so webhooks cannot reach it and bots should run in outbound mode; its API is reached through an authenticated proxy. Every bochka sandbox serves HTTPS on up to 50 ports, takes raw TCP and has its own IP.
Does bochka run Windows or macOS like Orgo?
No. bochka runs Linux VMs, with Wine for some Windows apps. Orgo offers Windows on its Scale plan or as an add-on, and macOS and iPhones by request.
Can I run Claude Code or Codex on both?
Yes. Orgo sets them up in one click and runs them in a terminal session on the computer. bochka ships seven coding agents preinstalled and lets you prompt, steer and follow them through an API, with real keys kept outside the sandbox.
Where does my data run?
bochka runs only in the EU (Germany, Finland and France), with EU data residency and a zero data retention option. Orgo says only that computers run in the US, with no choice of city, and offers on-prem deployment on Enterprise.
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