bochka vs Archil
Archil started as a cloud filesystem for AI and added persistent sandboxes on top of its disks. bochka is built around the machine itself: a bigger full VM with nested virtualization, a desktop and coding agents you drive from outside.
Where bochka stands out
A whole machine, as big and as long as you need
bochka sells full VMs from 2 to 16 vCPU and up to 32 GB, all priced, on dedicated AMD Ryzen 9 9950X hosts. Each one has Docker, systemd, root and /dev/kvm, and there is no session cap on paid plans. Archil publishes a price for one size, 2 vCPU / 4 GB, and pauses every session after at most 24 hours.
A screen for computer use
Every bochka sandbox can run a Linux desktop with Chromium, streamed at 60fps, with a computer-use API and a view you can embed in your app. Archil sandboxes are headless: shells, processes and ports.
Coding agents you drive from outside
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
Archil
Archil is a cloud filesystem for AI that syncs to your own S3 bucket, with persistent sandboxes and serverless code runs built on top of it.
Archil's main product is the Archil disk: a POSIX filesystem backed by your bucket that many agents can mount and share, with checkpoints and branches. Persistent sandboxes, now in preview, are Linux microVMs placed next to that data, with pause and resume, forks, exposed ports and an egress firewall. It is built for agent platforms that want their agents working on real, shared data.
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 | Archil: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs machines bigger than 2 vCPU / 4 GB, Docker and often emulators; bochka prices 4 to 16 vCPU machines with /dev/kvm, while Archil only prices one 2 vCPU size. | 3rd cheapest of 367 $634 a month | 287th of 367, with limits $5,237 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month gets paused by Archil's 24-hour session limit and has to be resumed; bochka can simply keep running. | 5th cheapest of 366 $657 a month | 300th of 366, with limits $6,347 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Archil fits short code runs well: serverless execution bills from 100 ms per call against your disk, with no sandbox to manage. | 186th of 345, with limits $2,000 a month | 171st of 345, with limits $1,091 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Archil wakes a paused sandbox on the next request to its port, which suits idle user sandboxes; bochka gives each user a full VM with hosting and a desktop built in. | Cheapest of 361 $209 a month | 161st of 361, with limits $2,378 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Archil can fork a running sandbox with its memory, so rollouts can branch from the same live state. | 34th of 360, with limits $2,000 a month | 146th of 360, with limits $9,583 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 | 302nd of 364, with limits $1,959 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that build Android apps or VM images need nested virtualization, which bochka has and Archil does not document. | 4th cheapest of 377 $86 a month | 334th of 377, with limits $1,387 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box wants SSH, a desktop and no session cap; bochka has all three, while Archil works through its process API. | 18th cheapest of 368 $26 a month | 335th of 368, with limits $349 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 screen; bochka streams a 60fps desktop with Chromium, and Archil sandboxes are headless. | 6th cheapest of 369 $200 a month | 295th of 369, with limits $1,813 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 | 308th of 367, with limits $982 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 | 318th of 346, with limits $1,323 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 | 278th of 338, with limits $18,181 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 | 295th of 360, with limits $654 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 | Archil |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Linux microVM with its own kernel, on AWS |
| Machine sizes with a price | 2 to 16 vCPU and up to 32 GB, all priced per second | One priced size, 2 vCPU / 4 GB; the API accepts up to 32 vCPU / 64 GiB without a public price |
| Session length | No cap on paid plans; you set the time to live | Each session pauses after at most 24 hours; resuming starts a new session |
| Docker, systemd and nested virtualization | Docker, root, systemd and /dev/kvm on every machine | Root inside the microVM; Docker, systemd and /dev/kvm are not documented, services run under archil services |
| Pause and resume | Disk is saved every minute and on stop; resume boots the machine again | Pause saves memory and disk, and resume picks up with processes still running |
| Fork | Fork a running sandbox with its disk | Fork a running sandbox with its memory and disk; sandboxes with mounted disks must be stopped first |
| Wake on request | No; a stopped sandbox is started by API | Traffic to an exposed port or a valid port token starts or resumes the sandbox |
| Desktop, browser and computer use | 60fps Linux desktop with Chromium and computer use, embeddable in your app | Headless; shells and processes only |
| Coding agents | Seven agents preinstalled, with a prompt, steer and events API | None preinstalled; you run commands through the process API |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6; SSH | Exposed ports take any TCP over TLS with SNI, public with no auth, or private through port tokens; no SSH or dedicated IP |
| Outbound rules | Open internet, no provider-side allowlist | Allow and deny lists by CIDR or domain, changeable while running, plus forwarding to your own gateway (Team plan and above) |
| 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 | Header rules on the egress proxy add keys to outgoing HTTPS requests (Team plan and above) |
| Shared data across sandboxes | Each sandbox has its own persistent disk with snapshots | Mount S3-backed Archil disks, shared read-only or with write locks across many sandboxes |
| Regions | EU only (Germany, Finland, France) | AWS US East, US West and EU West (Ireland) |
| 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 | Archil |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | No |
| Root | Yes | Yes |
| 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 | 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 | Yes |
| Public IPv4 | No | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | Yes |
| Preinstalled agents | Yes | No |
| Agent harness API | Yes | No |
| MCP server | No | No |
| GPU | No | No |
| Windows | No | No |
| Arm64 | No | No |
| 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 | Yes |
| HIPAA | No | Yes |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
No comparable measurement: Archil has not been run on the hpc-sandbox-benchmarks CPU test that bochka was measured on, where bochka did 26.69 runs per second at 4 vCPU / 8 GB. Archil's sandboxes run on AWS, and its only priced size is 2 vCPU / 4 GB. ComputeSDK's public benchmark measures Archil's start time, which is a different test from CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Archil 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 | Archil, 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 | $564 · Team · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $744 · Team · 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 | $3,548 · Team · 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 | $1,319 · Team · 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 | $2,314 · Team · 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.
Archil: Archil bills sandbox time by the hour for its one priced size, 2 vCPU / 4 GB: $0.27 an hour on the free Developer plan after 30 minutes, or $0.18 an hour on the $500 Team plan after 1,000 included minutes. The Team fee is not usage credit, and a paused sandbox has no compute charge.
Limits in those scenarios
Archil only prices a 2 vCPU / 4 GB sandbox, so the scenarios that need 4 vCPU / 8 GB do not fit, and its sandboxes pause after 24 hours, which breaks an agent that never stops. On the free Developer plan all outbound internet is blocked, so real agent work needs the Team plan, and Archil publishes no limit on how many sandboxes run at once and no price for internet egress. bochka has no session cap, but at 1,000 short jobs at once its $2,000 plan queues starts above 90 a minute.
| Scenario | bochka | Archil |
|---|---|---|
| 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 Archil when
your agents mainly work on large shared data in your own S3 bucket, or you need sandboxes that pause with memory and wake on request in a US region.
- Memory pause and wake on request. Useful for sandboxes that sit idle between requests: they pause with memory and wake when traffic reaches their port.
- Agents on shared, real data. Its S3-backed disks let many sandboxes read and write the same files, synced to your own bucket.
- Egress rules and US regions. Its firewall limits which domains and CIDR ranges a sandbox reaches, and it runs in two US regions as well as Ireland.
Use bochka when
your agents need a real machine: bigger VMs with Docker, emulators and a desktop, coding agents built in, and runs that go on for days without a forced pause.
- A whole machine, as big and as long as you need. On Archil, a build that needs 8 GB has no listed price, a long agent run is paused at 24 hours and has to be resumed by your code, and Android emulators or VMs need /dev/kvm, which Archil does not document.
- A screen for computer use. An agent that has to click through a web app, test a UI or log in somewhere needs a real screen. On Archil you would install and stream a desktop yourself inside a 2 vCPU / 4 GB machine.
- Coding agents you drive from outside. On Archil you install each agent, start it through the process API and parse its output yourself. That harness is code you write and keep working for every agent you support.
Questions people ask
Is bochka cheaper than Archil?
In all five scenarios on this page, yes. Part of the gap is that Archil only prices a 2 vCPU / 4 GB sandbox and real internet access needs its Team plan, whose fee is not usage credit.
Is Archil a sandbox or a storage product?
Both, but storage came first. Archil's core product is an S3-backed filesystem for AI, and its persistent sandboxes, now in preview, are Linux microVMs placed next to that data.
Can an Archil sandbox run for days?
Not in one session. Archil pauses a sandbox after at most 24 hours, keeping its memory, and you resume it to start a new session. bochka has no session cap on paid plans.
Can bochka pause a sandbox with its memory like Archil?
No. bochka saves the disk every minute and when the sandbox stops, so files survive, but resuming boots the machine again. Archil can pause with memory and resume running processes, and wake a sandbox when traffic reaches it.
Can I run Docker and Android emulators in each?
bochka runs Docker and exposes /dev/kvm for Android emulators and VMs on every machine. Archil sandboxes run as root in a microVM, but its docs do not cover Docker inside a sandbox or nested virtualization.
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