bochka vs Capy
Capy is a finished coding agent: you give it a task and it opens a pull request, working on a VM that sleeps when it stops. bochka gives you the machine itself, a full VM where you run any agent you like, for as long as you like, and drive it from your own code.
Where bochka stands out
Run the agent you choose
bochka comes with Claude Code, Codex and five other agents preinstalled inside the VM, and you prompt, steer and follow them from outside through one API. You can also run your own agent or plain code. Capy runs only its own agents, and their loop lives on Capy's servers.
A machine that stays awake and hosts things
A bochka sandbox runs until you stop it, with no session cap on paid plans. It serves HTTPS on up to 50 ports, raw TCP and its own IP, and its disk is saved every minute. A Capy machine sleeps about two minutes after its agent stops, and every process dies with it.
Full control of the VM
You get SSH, root and systemd, /dev/kvm for Android emulators and VMs, and a 60fps desktop your agent can control. You can fork a running sandbox to try two ideas from the same point. Real API keys stay outside the VM in a credentials proxy that works for any HTTPS API.
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
Capy
Capy is a hosted AI software engineer: parallel coding agents that plan, build and ship, from task to merged pull request.
Capy is a coding-agent product, not a sandbox API. Its own agents (Captain plans, Build writes code, Review checks pull requests) run on Capy's servers, and each thread gets an isolated Ubuntu 24.04 VM where the work runs. You start threads from the app, Slack, Linear or an API, and it is built for software teams that want pull requests without running agent infrastructure.
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 | Capy: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Capy is made for this if you want its agent and its pull request flow; bochka fits when you want Claude Code, Codex or your own agent on a machine that also runs emulators and hosts previews. | 3rd cheapest of 367 $634 a month | 29th of 367, with limits $4,852 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month needs the machine to stay awake, and a Capy machine sleeps about two minutes after its agent stops working. | 5th cheapest of 366 $657 a month | 26th cheapest of 366 $7,080 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Neither is built for short code runs; Capy threads always run its own coding agent, and bochka's start limits queue very large bursts. | 186th of 345, with limits $2,000 a month | 164th of 345, with limits $774 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Capy gives sandboxes to your own team's agent threads, not to your product's users; bochka gives each user a VM you control by API. | Cheapest of 361 $209 a month | 160th of 361, with limits $2,258 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 | 172nd of 360, with limits $16,611 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month Evals need to run your agent, not Capy's, so a sandbox you drive by API fits better. | 10th cheapest of 364 $200 a month | 182nd of 364, with limits $1,800 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Capy fixes CI failures on its pull requests; bochka can be the CI runner itself, with Docker and /dev/kvm for Android and VM builds. | 4th cheapest of 377 $86 a month | 106th cheapest of 377 $1,120 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs SSH and a machine that stays up, which bochka has; Capy machines are reached through its app and sleep when idle. | 18th cheapest of 368 $26 a month | 288th of 368, with limits $187 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Capy shows a live desktop so you can watch its agent drive Chrome; bochka gives your own agent a 60fps desktop and Chromium to control. | 6th cheapest of 369 $200 a month | 34th cheapest of 369 $1,487 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 | 98th of 367, with limits $700 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 | 25th cheapest of 346 $273 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 | 233rd of 338, with limits $9,850 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 | 42nd of 360, with limits $508 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 | Capy |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Isolated Ubuntu 24.04 VM per thread, on Daytona infrastructure |
| Which agent runs | Claude Code, Codex and five other agents preinstalled, or any agent or code you bring | Capy's own Captain, Build and Review agents only, on many models |
| API | Sandbox API for machines, files and commands, plus a prompt, steer and events API for the agents inside | Threads API: create a thread, send messages, stream the transcript; no documented call to run commands on the machine |
| How long a machine stays up | Runs until you stop it; no session cap on paid plans | Sleeps about 2 minutes after the agent stops; extensions of 5 minutes, up to 30 minutes ahead |
| Disk and state | Disk saved every minute and on stop; a stopped sandbox keeps its disk for free | Files survive sleep, processes do not; colder storage after 2 days asleep, deleted after 30 |
| Fork | Fork a running sandbox with its disk | No fork; new machines boot from a project setup snapshot in about 1 to 2 seconds |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | Not documented (Pro lists mobile builds, with no docs page on them); Docker runs inside |
| Shell access | SSH, root, systemd | Passwordless sudo for the agent; no SSH, you watch through the app |
| Desktop and browser | 60fps desktop with Chromium and a computer use API for your agent | Desktop with Chrome that Capy's agent drives; a live view to watch it |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 | Public URL per exposed port, only while the machine is awake; four ports reserved |
| Keeping API keys out of the sandbox | Credentials proxy for model providers and any HTTPS API; real keys never enter the VM | Model keys stay server-side and git goes through a proxy; your own secrets are env vars the agent's code can read |
| Private network | Install Tailscale or a VPN yourself as root | Built-in Tailscale integration; machines join your tailnet and follow your ACLs |
| Team workflow | Agents can use git and gh inside the VM; no pull request or review app | Opens pull requests, fixes CI, reviews PRs; starts from Slack, Linear, GitHub and schedules |
| Data location | EU only (Germany, Finland, France) | United States and other AWS regions |
| 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 | Capy |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | No |
| Root | Yes | Yes |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | Yes |
| Browser | Yes | Yes |
| Computer-use API | Yes | No |
| SSH | Yes | No |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | No |
| 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 | No |
| 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 | 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 | Not published |
| 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 for Capy: it is not in the hpc-sandbox-benchmarks results. bochka did 26.69 runs per second on that Node.js build-and-test benchmark 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. Capy 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 | Capy, 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 | $44 · Lite monthly |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $187 · Pro monthly |
| 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,963 · Max base monthly |
| 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 | $1,100 · Pay-as-you-go balance (no plan) · 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 | $3,322 · Pay-as-you-go balance (no plan) · 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. Model tokens are billed by your model provider through the credentials proxy.
Capy: Capy plans (Lite, Pro, Max from $200 in $100 steps) are monthly credit, and one balance pays for both model tokens and machine time. Machines bill by the hour by size while awake, plus a two-minute wind-down, and cost nothing asleep. The scenario prices here count machine time only; model tokens on Capy credits come on top.
Limits in those scenarios
Each Capy plan caps machine size and how much machine RAM runs at once: 128 GB on Lite, 512 GB on Pro and 1 TB on Max, which is 64 Large machines at most. That is enough for 50 agents on Max, but no plan holds 300 user sandboxes or 1,000 short jobs, and Capy publishes no capacity for pay-as-you-go, so those two are not confirmed to run. A Capy machine also sleeps about two minutes after its agent stops, so an agent that never stops only stays up while it keeps working. bochka has no session cap, but at 1,000 short jobs at once its $2,000 plan queues the starts.
| Scenario | bochka | Capy |
|---|---|---|
| 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 Capy when
you want a hosted coding agent that turns tasks into pull requests for your team, with Slack, Linear and code review built in, and you do not need to run your own agent.
- A finished coding agent, from task to pull request. Teams that want pull requests, not agent infrastructure, get planning, coding, CI fixes and code review in one product.
- Private network through Tailscale. Agents that must reach private databases or staging APIs can join a tailnet and follow its ACLs, with no setup inside the VM.
- Many models on your own subscriptions. Teams with ChatGPT, Copilot or SuperGrok plans can run Capy's agent on them and fall back to other keys when one runs out.
Use bochka when
you run your own agents or Claude Code and Codex on cloud machines you control: long jobs, hosting, emulators, a desktop and forks, driven from your code.
- Run the agent you choose. If your product is the agent, or your evals test your agent, Capy cannot run it. You would be paying for a coding product to do work your own harness is meant to do.
- A machine that stays awake and hosts things. A dev server, a preview link or a bot on Capy stops when the agent goes quiet, and its docs say traffic to an exposed URL does not keep the machine awake.
- Full control of the VM. On Capy you reach the machine only through its app, and your own secrets sit on the machine as env vars. Its docs say code the agent runs can read them.
Questions people ask
Is Capy a sandbox like bochka?
Not quite. Capy is a coding-agent product that gives each thread its own VM, but you only use that VM through Capy's agent. bochka is the machine itself, and you choose what runs on it.
Can I run Claude Code or Codex on Capy?
You can run Claude and GPT models inside Capy's own agent, including on a connected Codex subscription. Capy does not run the Claude Code or Codex agents themselves, while bochka ships them preinstalled with an API to prompt and steer them.
Is bochka cheaper than Capy?
For machine time, yes, in the scenarios on this page: one coding agent on workdays is $20 a month on bochka and $44 on Capy, and 50 agents in parallel are $317 against $2,963. Capy's prices here leave out model tokens, which it bills from the same balance.
Can a Capy machine run around the clock?
Only while its agent keeps working. It sleeps about two minutes after the thread stops, you can add 5 minutes at a time up to 30 minutes ahead, and processes do not survive sleep. A bochka sandbox runs until you stop it.
Can I SSH into the machine?
On bochka, yes, with root and systemd. Capy's docs say you never need SSH: you watch the terminal, diff, files and desktop in its app.
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