bochka vs Archal
These are two different tools. bochka is the machine where an agent runs code, while Archal is a set of simulated services, like a fake GitHub or Slack, that an agent calls during a test.
Where bochka stands out
A real machine for the agent to work in
A bochka sandbox is a full VM with its own kernel, root, systemd, Docker and /dev/kvm. The agent can clone a repo, install packages, run builds and tests, and start services, on dedicated AMD Ryzen 9 9950X hosts.
Coding agents built in, driven from outside
Claude Code, Codex and five other agents come preinstalled. You drive agents inside from outside with one API: send a prompt, steer mid-run and follow the events.
Real APIs without real keys inside
bochka's credentials proxy adds the real keys to outbound HTTPS calls, so they never enter the sandbox, for model providers and any other HTTPS API. A credential can switch to another account of the same type 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
Archal
Archal is a Y Combinator startup that makes testing sandboxes for AI agents: isolated, stateful copies of the external services an agent calls.
An Archal sandbox holds one or more simulated environments, such as GitHub, Slack, Stripe, Jira or Supabase, each with its own REST or MCP endpoint and a short-lived scoped credential. You load a starting state, let the agent work, then diff what changed and reset to a known baseline. It is not a machine: there is no shell, no file system and no way to run your own code inside, so it is built for teams testing agents and integrations, alongside the harness, evaluator and CI they already use.
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 | Archal: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs installs, builds, Docker and tests, which Archal does not run because it has no machine to run them on. | 3rd cheapest of 367 $634 a month | 367th of 367, with limits $72,336 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant needs a machine that keeps its files all month; Archal sandboxes expire and keep only small API state. | 5th cheapest of 366 $657 a month | 366th of 366, with limits $219 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 | 343rd of 345, with limits $19,667 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Giving your users a place to run code needs a real machine per user, which is what bochka makes and Archal does not. | Cheapest of 361 $209 a month | 353rd of 361, with limits $61,750 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Archal resets each rollout to an identical API state, which suits RL against SaaS tools, but rollouts that run code or tests need a real machine. | 34th of 360, with limits $2,000 a month | 340th of 360, with limits $298 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month Archal is built for one part of this: giving each eval run a clean fake GitHub, Slack or Stripe and diffing what the agent changed; the agent itself still needs a machine to run on, like bochka. | 10th cheapest of 364 $200 a month | 344th of 364, with limits $24,000 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Archal can stand in for third-party APIs inside a CI job; the build and tests themselves run on a machine such as a bochka sandbox. | 4th cheapest of 377 $86 a month | 369th of 377, with limits $7,200 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 367th of 368, with limits $4,380 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 desktop and a browser; bochka streams one at 60fps, and Archal has no screen at all. | 6th cheapest of 369 $200 a month | 369th of 369, with limits $21,600 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 | 367th of 367, with limits $21,600 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 | 346th of 346, with limits $29,250 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 | 338th of 338, with limits $585 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 | 357th of 360, with limits $14,250 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 | Archal |
|---|---|---|
| What you get | A full Linux VM with root, systemd and a persistent disk | Simulated copies of third-party APIs, each with a REST or MCP endpoint |
| Run your own code inside | Yes, any language or tool, as root | No; the API covers sandbox lifecycle, state and provider calls only |
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | One sandbox per run with scoped credentials; environments run in containers Archal manages |
| Docker and nested virtualization | Docker inside, plus /dev/kvm for Android emulators and VMs | Not offered; there is no machine to run them on |
| Simulated SaaS services | No; agents call the real services | 22 services, such as GitHub, Slack, Stripe, Jira and Supabase, with 110 starting states |
| Diff and reset | Disk snapshots every minute and on stop; fork a running sandbox | Diff API state against a saved before, and reset to a versioned starting state |
| What persists | The whole disk, kept free while the sandbox is stopped | JSON or SQL state per environment until reset or destroy; state input up to 2 MiB |
| Session length | No cap on paid plans; you set the time to live | Each sandbox has a time to live, an idle limit and a hard expiry; no plan maximum published |
| Coding agents | Seven agents preinstalled, with a prompt, steer and events API | A setup prompt and five skills for the agent you already run; Archal does not own the harness |
| MCP | No hosted MCP server; REST API | Hosted lifecycle MCP server, and MCP endpoints on environments |
| Credentials | Credentials proxy keeps real keys outside the sandbox, for model providers and any HTTPS API | Short-lived fake credentials scoped to one environment; never send a real provider key |
| Desktop and browser | 60fps Linux desktop and Chromium, with computer use | None |
| Inbound access | HTTPS URLs for up to 50 ports, raw TCP, dedicated IP | An HTTPS URL per environment that reaches Archal's simulation, not your own ports |
| 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 | Archal |
|---|---|---|
| Full VM (own kernel) | Yes | No |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | Not published |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | No |
| Browser | Yes | No |
| Computer-use API | Yes | No |
| SSH | Yes | No |
| Persistent disk | Yes | No |
| Pause/resume | Yes | No |
| Automatic snapshots | Yes | No |
| Fork/clone | Yes | No |
| Live fork (no pause) | Yes | No |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Not published |
| ≥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 | No |
| Secret proxy | Yes | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | No |
| Agent harness API | Yes | No |
| MCP server | No | Yes |
| 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 | No |
| SOC 2 | No | No |
| HIPAA | No | No |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement. Archal does not run customer code, so a CPU benchmark does not apply to it. bochka scored 26.69 runs per second on the hpc-sandbox-benchmarks Node.js test at 4 vCPU / 8 GB.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Archal 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 | Archal, 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 | $950 · Current applicable tariff unverified · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $4,380 · Current applicable tariff unverified · 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 | $47,520 · Current applicable tariff unverified · 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 | $27,000 · Current applicable tariff unverified · 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 | $59,667 · Current applicable tariff unverified · 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.
Archal: Archal bills $0.10 per minute for each ready environment, prorated by the second, so a sandbox with three environments pays three times. New workspaces get $20 of one-time credit, and paid continuation is not yet open to self-serve workspaces. The scenario prices treat one environment as if it were a machine, which it is not.
Limits in those scenarios
Archal does not fit any of the five scenarios, because it does not give you a machine: there is no disk, no Docker, and no published machine size. Its concurrent sandboxes are capped by a workspace policy with no published number, and new sandbox creation pauses when the one-time credit runs out. bochka fits four of the five; at 1,000 short jobs at once, starts above 90 a minute are queued.
| Scenario | bochka | Archal |
|---|---|---|
| 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 Archal when
you test agents that call SaaS tools like GitHub, Slack or Stripe and want fake, resettable copies of those services instead of real accounts.
- Fake GitHub, Slack, Stripe and 19 more. Teams testing agents that call SaaS tools can do it without test accounts, rate limits or touching production.
- Diff and reset of API state. Graders can see exactly what an agent changed in a service and put it back to the same starting point.
- MCP endpoints out of the box. Agents that speak MCP can reach every environment and the sandbox lifecycle without extra glue.
Use bochka when
your agents need somewhere to actually work: a full VM where they install, build, test, run Docker and a browser, with coding agents built in.
- A real machine for the agent to work in. Archal has no shell or file system, so the agent's code, builds and tests must run somewhere else, and you still need to find and pay for that machine.
- Coding agents built in, driven from outside. Archal says it does not own the harness: it gives your agent skills to call its fake services, but running the agent and its loop is still your job.
- Real APIs without real keys inside. Archal's credentials only open its own simulations. Once an agent has to reach the real GitHub or Stripe, a key has to live somewhere it can't leak.
Questions people ask
Is bochka an alternative to Archal?
Mostly not; they solve different problems. bochka is the machine an agent runs on, and Archal is a set of simulated services the agent calls during a test. Many teams would use both.
Can I use bochka and Archal together?
Yes. Run the agent and its code in a bochka sandbox, and point it at Archal's environment URLs with the scoped credentials Archal returns. Archal then diffs and resets the API state after each run.
Can Archal run my code or Docker?
No. Archal's API covers sandbox lifecycle, state and calls to its simulated services, with no shell or exec. Code, builds and Docker need a machine like a bochka sandbox.
Is bochka cheaper than Archal?
They bill for different things, so the scenario table is only a rough guide. Archal charges per environment-minute for simulated services, and bochka charges per second for a whole VM. bochka costs less in all five scenarios, and Archal does not fit any of them, because there is no machine to run the work.
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