bochka vs Amp Orbs
Amp Orbs are cloud machines where Amp's coding agent works on your threads. bochka is a sandbox platform you build on: a full VM with Docker, /dev/kvm and SSH, where you run Claude Code, Codex or your own agent and drive it from outside with an API.
Where bochka stands out
Any agent, driven from outside
bochka ships Claude Code, Codex, OpenCode, pi and other agents inside each sandbox, and you drive them from outside with a prompt, steer and events API. Amp's SDK can send work to an orb, but the agent it runs is always Amp's. To run another agent in an orb you install it yourself and have no API to steer it.
A full machine your tools can reach
A bochka sandbox is a full VM with Docker ready, /dev/kvm for Android emulators and Firecracker, SSH, raw TCP and HTTPS on up to 50 ports. An orb is an E2B microVM with a link-local network, reached through Amp's terminal tab and HTTP portals. Docker must be added in a setup script, and no /dev/kvm or SSH is documented.
Fork a running sandbox, keep keys outside
bochka snapshots the disk every minute and can fork a running sandbox into copies, so you can try several fixes from the same point. Its credentials proxy keeps real API keys out of the machine and can switch to another account when one runs out of credits. Orbs reuse a setup snapshot for new threads, have no fork, and get secrets as environment variables.
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
Amp Orbs
Amp is a coding agent made by Amp Frontier Corporation, which spun out of Sourcegraph in December 2025. Orbs are the remote machines where Amp's agent works.
Every orb thread gets a fresh Debian 12 machine with your repository, run as an E2B microVM in Google Cloud us-west1. You start orbs from the Amp app, the CLI or the TypeScript and Python SDKs, and you watch them through a web terminal, a Linux desktop with Chrome and authenticated portal URLs. It is built for developers and teams who use Amp and want its agent to work off their laptop, not as a general sandbox API for other agents or for your own users.
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 | Amp Orbs: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both fit; Amp works well if your team already codes with Amp, while bochka lets you run any agent and gives it /dev/kvm, SSH and forks. | 3rd cheapest of 367 $634 a month | 12th cheapest of 367 $2,861 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both fit, but an orb pauses when idle and bills by the hour while awake, so an assistant that stays on all month costs more on Amp. | 5th cheapest of 366 $657 a month | 18th cheapest of 366 $4,176 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Neither is built for one-minute bursts; Amp bills by the minute with no plan fee on Hobby, which suits small, rare runs. | 186th of 345, with limits $2,000 a month | 230th of 345, with limits $159 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Orbs are built for Amp threads, not for handing a sandbox to each of your own users through an API, so this is a compromise on Amp. | Cheapest of 361 $209 a month | 222nd of 361, with limits $625 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 | 273rd of 360, with limits $7,340 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month Amp's SDK drives only Amp's agent, so evals of other agents or models need your own setup inside the orb; bochka ships several agents behind one API. | 10th cheapest of 364 $200 a month | 234th of 364, with limits $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Amp has no CI hooks for orbs beyond its own threads and automations; bochka gives a plain VM with SSH that a CI system can drive. | 4th cheapest of 377 $86 a month | 257th of 377, with limits $200 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 262nd of 368, with limits $103 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Amp's desktop has Chrome, but Amp calls computer use there early and unsupported; bochka streams a 60fps desktop with computer use built in. | 6th cheapest of 369 $200 a month | 61st of 369, with limits $200 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 | 124th of 367, with limits $200 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 | 122nd of 346, with limits $200 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 | 186th of 338, with limits $6,720 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Both fit well: each run gets its own VM, on Amp as a fresh orb per thread and on bochka as a sandbox per run. | 2nd cheapest of 360 $200 a month | 23rd of 360, with limits $200 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 | Amp Orbs |
|---|---|---|
| What you get | A sandbox platform: VMs you create and control from an API, CLI or SSH | Remote machines where Amp's own agent works on a thread |
| Isolation | Every sandbox is a full VM with its own kernel | Every thread gets its own E2B microVM |
| Docker and nested virtualization | Docker, root, systemd and /dev/kvm ready on every machine | sudo and systemd; Docker is not installed by default (add it in a setup script); no /dev/kvm documented |
| Coding agents | Claude Code, Codex, OpenCode, pi and more preinstalled, driven from outside with a prompt, steer and events API | Amp's agent only, driven from the TypeScript or Python SDK with the orb executor |
| Desktop and computer use | 60fps desktop and Chromium, computer use and browser control, embeddable stream | High-resolution Linux desktop with Chrome; computer use is early and unsupported |
| Shell access | SSH, a web terminal and an exec API | Terminal tab in the Amp app (shared tmux session); no SSH documented |
| Pause and wake | Stop and start by API; a stopped sandbox costs nothing; resume reboots from disk | Pauses on its own when idle and wakes on a new prompt or portal request with files and services in place |
| Snapshots and fork | Snapshots every minute and on stop; fork a running sandbox into copies | A per-project setup snapshot reused for up to 72 hours; no fork of an orb |
| Reaching the sandbox | HTTPS URLs for up to 50 ports, token-protected; raw TCP; own IP | Portals: HTTP URLs open to thread viewers, public links for up to 7 days, custom domains; no raw TCP documented |
| Keeping keys out of the sandbox | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out | Secrets arrive in the orb as environment variables; short-lived OIDC tokens for cloud providers |
| Starting many at once | 12 to 90 starts a minute depending on plan | A burst of 20 orbs per user, then one new orb every five minutes; more through support |
| Your own machines | None; bochka runs every machine itself | Runners: run Amp threads on a machine you already have, including your Mac, free on Hobby; Amp itself stays a hosted service with no self-hosted deployment |
| Regions | EU only: Germany, Finland, France | US only: Google Cloud us-west1 |
| 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 | Amp Orbs |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | No |
| Root | Yes | Yes |
| Systemd | Yes | Yes |
| Desktop GUI | Yes | Yes |
| Browser | Yes | Yes |
| Computer-use API | Yes | Yes |
| 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 | No |
| Secret proxy | Yes | No |
| 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 | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Yes |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Yes |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | No |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's public hpc-sandbox-benchmarks run, but Amp Orbs were not in that benchmark, so we cannot compare their CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Amp Orbs 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 | Amp Orbs, 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 | $20 · Megawatt — a1.medium allowance |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $113 · Megawatt — a1.medium allowance |
| 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,494 · Gigawatt — a1.medium allowance |
| 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 | $200 · Gigawatt — a1.tiny allowance · 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 | $540 · Gigawatt — a1.small allowance · with limits |
bochka: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Amp Orbs: Orbs bill by the minute at a fixed hourly price per size, from $0.08 for a1.tiny to $2.13 for a1.3xlarge, including start-up time. Paid plans include a monthly allowance of orb minutes for one person that does not pool across a team or roll over; model usage is billed apart from orb time.
Limits in those scenarios
On Amp the limit that bites first is start pacing: each user can start a burst of 20 orbs, then one new orb every five minutes, so at most 32 starts in an hour and 308 in a day, and later orbs wait in line. 50 agents in parallel still fit but take hours to all get running, while sandboxes for your users (about 1,000 starts a day) and 1,000 short jobs at once do not fit unless support raises the limit. The subscription allowance is per person and does not pool, so a team running many orbs pays standard prices once one person's minutes run out. On bochka the limit is a sandbox count 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 | Amp Orbs |
|---|---|---|
| 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 Amp Orbs when
your team already works with Amp's agent and wants its threads to run off your laptop, or on your own Mac, with portals that wake an idle machine.
- An agent and a machine in one product. Useful if your team already codes with Amp: each thread gets a machine, terminal, desktop and shareable portals with nothing to wire up.
- Sleeps when idle, wakes on request. Useful for agents that work in short bursts: an orb pauses on its own when idle and wakes on a new prompt or portal visit.
- Runs on your own machines, and in the US. Useful if work must run on a specific computer such as your Mac, or your data must stay in the US.
Use bochka when
you build on agents yourself: any coding agent on a full VM with Docker, /dev/kvm, SSH, forks and a credentials proxy, driven from your own code.
- Any agent, driven from outside. If you build your own agent, compare agents in evals, or give each of your users a sandbox, Amp Orbs tie you to one agent and one app. On bochka the machine and the agents are separate, so you pick both.
- A full machine your tools can reach. An agent that boots an emulator, runs a database other tools connect to over TCP, or is debugged from your own editor over SSH has no documented way to do that in an orb.
- Fork a running sandbox, keep keys outside. Without a fork, trying five fixes from one state means five fresh orbs that each rerun setup. With keys as environment variables, any code the agent runs can read and leak them.
Questions people ask
Is bochka cheaper than Amp Orbs?
It depends on the scenario. One coding agent on workdays costs $20 a month on both. One agent running all month comes to $26 on bochka against $113 on Amp, and 50 agents in parallel come to $317 against $1,494. Sandboxes for your users cost $200 a month on bochka, while Amp does not fit that scenario within its start pacing, and neither fits 1,000 short jobs at once within its start limits.
Can I run Claude Code or Codex in an Amp orb?
You can install them yourself in the orb's setup script, since you have sudo. But Amp's SDK and app only drive Amp's own agent, so there is no API to prompt, steer or watch another agent there. bochka ships Claude Code, Codex and others and drives them through one API.
Are Amp Orbs real VMs?
Yes. Amp's security page says e2b provides the compute for orbs, and its docs call them E2B microVMs, running Debian 12 in Google Cloud us-west1. bochka sandboxes are also full VMs, with /dev/kvm for nested virtualization, on dedicated AMD Ryzen 9 9950X (Zen 5) hosts.
Can I SSH into an Amp orb?
Amp documents a Terminal tab that opens a shared tmux session in the orb, and HTTP portals for web servers. It does not document SSH or raw TCP. bochka gives every sandbox SSH, raw TCP and HTTPS on up to 50 ports.
Where does my data run?
Amp's primary infrastructure is on Google Cloud in the US, and its hosted orbs run in us-west1. bochka runs only in the EU (Germany, Finland and France), with EU data residency and a zero data retention option.
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. Amp says on its security page that it is SOC 2 Type II certified.
Start a sandbox
Install the CLI, then run bochka new.
Product preview