bochka vs Arker
Arker and bochka both give each agent a full Linux VM with root, Docker and forks. bochka builds more on top: coding agents you drive from outside, a 60fps desktop and hosting with raw TCP, while Arker leans on memory forks, GPUs and network policies.
Where bochka stands out
Coding agents you drive from outside
Both put Claude Code and Codex inside the VM. On bochka you drive agents inside from outside with a prompt, steer and events API. On Arker you sign each agent in yourself and run it as a command through the generic runs API.
A 60fps desktop for computer use
bochka streams a 60fps desktop with Chromium, computer use and browser control, and you can embed the stream in your own app. Arker's desktop image runs noVNC with screenshots, mouse and keyboard control and recordings.
Host anything, not only HTTPS
A bochka sandbox serves HTTPS on up to 50 ports with tokens, takes raw TCP, and gets its own IPv6 or IPv4. Arker exposes ports as HTTPS hostnames on arker.app, with no public IP, and does not document raw TCP.
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
Arker
Arker runs fast-starting, durable virtual machines for AI agents on its own hypervisor.
Each Arker machine is a VM that you create by forking a public image or another of your VMs, with its disk and running memory. Idle machines keep their memory and disk and wake on the next run or request, and network policies can block traffic, inject secrets or suspend billing while a request waits for a model. It is built for teams that run many agents and want low VM spend, through a REST API, a CLI and Python and TypeScript clients.
- Isolation
- Full VMs on Arker's own hypervisor
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 | Arker: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run full VMs with Docker; on Arker /dev/kvm is an opt-in for image or Dockerfile VMs, while bochka has it on every machine. | 3rd cheapest of 367 $634 a month | 28th of 367, with limits $4,485 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both fit; Arker can suspend an assistant while it waits on a model reply, and bochka keeps each one on a VM with snapshots every minute. | 5th cheapest of 366 $657 a month | 23rd cheapest of 366 $5,893 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Arker fits short runs better here: it bills run time with fast starts, while bochka's start limits make big bursts a compromise. | 186th of 345, with limits $2,000 a month | 155th of 345, with limits $615 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Arker publishes no limit on how many machines run at once, so 300 sandboxes for your users is not confirmed there; bochka's $100 plan allows 300. | Cheapest of 361 $209 a month | 151st of 361, with limits $1,932 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 | 143rd of 360, with limits $9,335 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 | 171st of 364, with limits $1,488 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month | 4th cheapest of 377 $86 a month | 312th of 377, with limits $893 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both keep a machine running; bochka's stop is free and Arker's idle VMs keep memory and wake on the next request. | 18th cheapest of 368 $26 a month | 104th cheapest of 368 $234 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both fit: Arker has a noVNC desktop with screenshots, mouse and keyboard control, and bochka streams a 60fps desktop you can embed in your app. | 6th cheapest of 369 $200 a month | 31st cheapest of 369 $1,339 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Both ship Chromium ready for automation; bochka adds computer use and browser control on the same 60fps desktop. | 7th cheapest of 367 $200 a month | 30th cheapest of 367 $676 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 | 71st cheapest of 346 $915 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 | 279th of 338, with limits $18,304 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 | 40th of 360, with limits $446 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 | Arker |
|---|---|---|
| Isolation | Every sandbox is a full VM with its own kernel | Every machine is a full VM on Arker's own hypervisor |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 26.69 runs/s | No result in that benchmark |
| Docker and nested virtualization | Docker, root, systemd and /dev/kvm on every machine | Docker and systemd images; /dev/kvm is opt-in for image or Dockerfile VMs, and unsupported placements return 400 |
| Fork and memory | Fork a running sandbox; resume reboots from disk (no memory snapshots) | Warm fork copies disk and running processes; disk-only fork also offered |
| Idle and resume | Snapshots every minute and on stop; a stopped sandbox costs nothing | Idle VMs keep memory and disk on object storage and wake on the next run or request; a policy can suspend billing during model waits |
| Desktop and computer use | 60fps desktop and Chromium, computer use and browser control, embeddable stream | noVNC desktop with screenshots, mouse and keyboard control and recordings; a Chromium image |
| Coding agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | Claude Code, Codex, OpenCode, Cursor Agent and Aider preinstalled; you sign in and run them as commands |
| 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 | Policy rewrites insert named secrets into outbound HTTPS requests as they leave the machine |
| Outbound rules | Open internet on every plan; no provider-side allowlist | Per-VM rules on hosts, IPs, ports, paths and headers; unmatched traffic is blocked once rules exist; external approval gate |
| Reaching the sandbox | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 | HTTPS hostnames per port on arker.app, API key, token or open; no public IP; raw TCP not documented |
| Published limits | 100 to 2,000 sandboxes at once by plan, with published starts per minute | No public limit on machines at once |
| GPUs | None | A100 80GB and H200 in US West, fractional vGPU from 0.125 |
| Regions | EU only: Germany, Finland, France | EU and US on Arker, AWS and GCP hardware, plus private regions on your VPC or on-prem |
| Windows | No Windows guests; Wine for Windows apps | A Windows image at 1 to 2 vCPU and 8 GiB in EU and US West |
| 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 | Arker |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | Yes |
| Root | Yes | Yes |
| Systemd | Yes | Yes |
| 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 | Yes |
| 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 | Yes |
| Secret proxy for any API | Yes | Yes |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | No |
| MCP server | No | No |
| GPU | No | Yes |
| Windows | No | Yes |
| Arm64 | No | Yes |
| Self-hosting | No | No |
| BYOC | No | Yes |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No |
| 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 CPU measurement: Arker has no result in StarSling's public hpc-sandbox-benchmarks run, where bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. ComputeSDK's benchmark measured fast starts for Arker, with a burst of 100 machines all started and a p95 of 267 ms.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Arker 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 | Arker, 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 | $59 · Paid account (pay as you go) |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $244 · Paid account (pay as you go) |
| 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,946 · Paid account (pay as you go) |
| 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 | $845 · Paid account (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,867 · Paid account (pay as you go) · 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.
Arker: Arker says it charges for run time, not machine time, but its rate card needs a sign-in and how run time is metered is not public. The table uses the last per-machine prices Arker published, from a capacity-planning table since removed from its docs, billed for every hour the machine is up; a live pool quote in its docs comes out about 3% higher; the 4 vCPU rows use its 4 vCPU / 16 GiB size, and suspending during model waits could lower real bills.
Limits in those scenarios
Arker publishes no limit on how many machines run at once, so the 50-agent fleet, 300 sandboxes for your users and 1,000 short jobs at once are not confirmed there, and egress and disk beyond 32 GiB have no public price. On bochka the limit is a sandbox count (100 to 2,000 by plan) plus starts per minute: the 1,000-job burst gets queued at 90 starts a minute and needs more starts per day than the $2,000 plan allows.
| Scenario | bochka | Arker |
|---|---|---|
| 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 Arker when
your agents need GPUs, forks that keep memory, billing paused while they wait on models, strict per-machine network rules, or a US or private region.
- Memory forks and paying only while running. Useful if your agents wait on models a lot: Arker can suspend billing during those waits and fork with memory kept.
- GPUs and Windows. Useful if your agents train or test models on A100 or H200 GPUs, or need a small Windows machine.
- Network policies, US regions, your own hardware. Useful if each agent must reach only approved hosts, run in the US, or run on your VPC or on-prem machines.
Use bochka when
you run coding and computer-use agents for hours: driven from outside by API, on a VM with Docker and /dev/kvm everywhere, a 60fps desktop and hosting on 50 ports with raw TCP.
- Coding agents you drive from outside. Without a driving API you write the code that starts, prompts, steers and watches each agent. When an account runs out of credits, bochka switches the credential, so the agent keeps working instead of stopping.
- A 60fps desktop for computer use. A computer-use agent and the person watching it both work from the picture. A VNC page in a browser tab is fine for checks, but it is harder to embed smoothly in a product your users see.
- Host anything, not only HTTPS. Agents that run databases, game servers, SSH tunnels or webhooks need more than HTTPS hostnames. On Arker those have to go through its HTTPS relay or a tunnel you build and keep running.
Questions people ask
Is bochka cheaper than Arker?
In the scenarios we priced from Arker's last published figures, yes: one coding agent on workdays comes to $20 a month on bochka and $59 on Arker, and one agent running all month comes to $26 versus $244. 50 agents in parallel come to $317 versus $2,946. Arker bills run time, so agents that spend long stretches suspended could cost less there than the table shows.
Does Arker bill only when the VM is running?
Arker says it charges for run time, not machine time. Idle machines keep their memory and disk, and a policy can stop compute billing while a request waits for a reply. The exact metering rule and storage prices are not public.
Can both fork a running sandbox?
Yes. Arker's warm fork copies the disk and the running processes, so the copy resumes where the source was. bochka forks a running sandbox from its disk, and the copy boots fresh.
Does bochka have GPUs or Windows like Arker?
No. bochka has no GPUs and no Windows guests; it runs Linux VMs on dedicated AMD Ryzen 9 9950X (Zen 5) hosts and has Wine docs for Windows apps. Arker has A100 and H200 GPUs in US West and a small Windows image.
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. Arker runs in EU and US regions on its own, AWS and GCP hardware, and can run private regions on your VPC or on-prem machines.
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