bochka vs Shardflux
Both give each agent its own Linux VM that can run for as long as you like. bochka gives it a fuller machine you can SSH into, with its keys kept outside, while Shardflux is strongest at agents that park between calls and wake in a fraction of a second.
Where bochka stands out
A whole machine you can SSH into
A bochka sandbox is a full VM with root, systemd, Docker and /dev/kvm, so Android emulators and nested VMs run inside it. You can SSH in, open raw TCP ports and use its own IP address. Shardflux gives you exec, terminals and files through its API, and does not document Docker, systemd or nested virtualization.
Real API keys never enter the sandbox
bochka keeps model keys and keys for any HTTPS API in a credentials proxy outside the sandbox, so the agent uses them without ever seeing them. Shardflux hides secrets from its API, but every command and terminal in the workspace gets them as environment variables.
Your data stays in the EU
bochka runs only in the EU, in Germany, Finland and France, and offers zero data retention. Shardflux workspaces and its API run only in AWS us-west-2, in Oregon.
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
Shardflux
Shardflux sells serverless VMs for cloud agents: persistent Linux workspaces that park when idle and wake on the next call.
Each Shardflux workspace is a Linux microVM with its own kernel, disk and memory, started from a versioned template. Your agent drives it through tools (exec, files, terminals, git, browser, computer use) from the TypeScript and Python SDKs, a CLI or an MCP server, and the shard command can also launch Claude Code or Codex in a cloud VM for you. It is a hosted service built for agent products and for developers who want their coding agents to keep working in the cloud.
- Maker
- Helios One Oy
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 | Shardflux: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker, systemd and often /dev/kvm for emulators; bochka documents all three, and Shardflux documents none of them. | 3rd cheapest of 367 $634 a month | Cheapest of 367 $299 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both keep a workspace alive with no session cap; Shardflux parks it between calls, while bochka keeps a full machine with SSH and its own IP. | 5th cheapest of 366 $657 a month | 2nd cheapest of 366 $299 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Shardflux is built for this: an idle workspace parks with its memory and wakes in about a tenth of a second on the next call. | 186th of 345, with limits $2,000 a month | 30th cheapest of 345 $299 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Both can give each user a VM with an HTTPS URL; bochka adds public URLs, raw TCP and its own IP, while Shardflux URLs are always private and wake the workspace. | Cheapest of 361 $209 a month | 44th of 361, with limits $299 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 | 88th of 360, with limits $5,043 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 | 103rd of 364, with limits $299 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI runners that build Android apps or VM images need nested virtualization, which bochka has and Shardflux does not document. | 4th cheapest of 377 $86 a month | 18th cheapest of 377 $242 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box you SSH into every day fits bochka; Shardflux gives terminals through its API and CLI instead of SSH. | 18th cheapest of 368 $26 a month | 208th of 368, with limits $13 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both have a Linux desktop an agent drives with screenshots and clicks; bochka streams it at 60fps and can be embedded in your app. | 6th cheapest of 369 $200 a month | 2nd cheapest of 369 $79 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 | Cheapest of 367 $79 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 | 4th cheapest of 346 $79 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 | 102nd of 338, with limits $2,694 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Both fit; Shardflux can limit outbound traffic per workspace, and bochka keeps the real API keys out of the machine the agent attacks from. | 2nd cheapest of 360 $200 a month | 5th cheapest of 360 $299 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 | Shardflux |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Linux microVM with its own kernel, disk and memory, on AWS |
| Session length | No cap on paid plans; you set the time to live | A persistent workspace ends only when you delete it; it suspends when idle |
| Pause and resume | Disk is saved every minute and on stop; resume boots the machine again | Idle workspaces park or suspend with memory and processes kept; wakes in about 0.1 s |
| Fork | Fork a running sandbox with its disk | Fork a running or suspended workspace with its disk and memory |
| Wake on request | No; a stopped sandbox is started by API | Yes; a request to a port URL wakes a parked or suspended workspace |
| Shell access | SSH, plus exec and files through the API | Exec, terminals and files through the API, CLI and MCP; no SSH documented |
| Docker and nested virtualization | Docker, systemd and /dev/kvm for Android emulators and VMs | Root via sudo; Docker, systemd and nested virtualization are not documented |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default or public; raw TCP; dedicated IPv4 or IPv6 | Private HTTPS URL for any TCP port, reached with a port token, signed link or callback URL; no raw TCP or own IP documented |
| Outbound rules | Open internet, no provider-side allowlist | Allow all, allowlist or deny all, by host, port and CIDR, per project or workspace |
| Desktop and computer use | Linux desktop streamed at 60fps, Chromium and computer use, embeddable in your app | Linux desktop, 1280x800 by default, driven with screenshots, clicks and keys; live view link |
| Coding agents | Claude Code, Codex and several more preinstalled, with a prompt, steer and events API | Claude Code and Codex in cloud VMs through the shard command and a conversations API |
| Keeping API keys out of the sandbox | Credentials proxy for model providers and any HTTPS API; real keys never enter the sandbox | Secrets reach every command as environment variables; vault logins for browser fills are sent encrypted end to end |
| GPU | No | GPU rendering through its own Vulkan driver on Startup and Scale |
| Regions | EU only (Germany, Finland, France) | US only (AWS us-west-2, Oregon) |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | Not published |
Every feature Battleships tracks (43)
| Feature | bochka | Shardflux |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Not published |
| Nested virtualization | Yes | No |
| Root | Yes | Yes |
| Systemd | Yes | Not published |
| 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 | 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 | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | Yes |
| MCP server | No | Yes |
| GPU | No | Yes |
| 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 | Yes |
| Audit logs | No | Yes |
| SSO | No | Not published |
| SOC 2 | No | Not published |
| HIPAA | No | Not published |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
No comparable measurement: Shardflux was not part of the hpc-sandbox-benchmarks CPU run. bochka did 26.69 runs per second on that Node.js build-and-test loop 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. Shardflux 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 | Shardflux, 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 | $11 · Developer |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $29 · Pro |
| 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 | $299 · Scale |
| 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 | $299 · Scale · 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 | $361 · Scale · 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.
Shardflux: Each plan includes CPU-hours, counted only for CPU time your processes actually use, and RAM GiB-hours, counted for the memory a running workspace holds (what its processes use, at least 1 GiB); a parked workspace counts little and a suspended one nothing. Overage is off until you turn it on, at $0.04 per CPU-hour and $0.015 per GiB-hour, and outbound transfer is capped per plan with no price for more.
Limits in those scenarios
Shardflux's Scale plan runs at most 200 workspaces at once, so 1,000 user sandboxes or a burst of 1,000 jobs needs Enterprise. Its overage is capped at the plan price, so past that point new starts are refused and running workspaces are suspended. When a plan's outbound transfer runs out, every workspace in the organization loses internet until the next period. bochka has no session cap, but at 1,000 short jobs at once its $2,000 plan queues the starts.
| Scenario | bochka | Shardflux |
|---|---|---|
| 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 Shardflux when
your agents sit idle between tool calls and must wake with their memory in a fraction of a second, when you need per-workspace outbound rules, or when you want GPU rendering or US hosting.
- Park, wake and fork with memory. Useful for agents that sit idle between tool calls: a parked workspace keeps its memory and wakes in about a tenth of a second.
- Outbound rules per workspace. Shardflux can limit which hosts, ports and IP ranges a workspace reaches, per project or per workspace.
- GPU rendering and a US region. On Startup and Scale, workspaces can render with Vulkan on a GPU, and they run in Oregon for teams that want US hosting.
Use bochka when
your agents need a whole machine: SSH, Docker, emulators, raw TCP and an own IP, with the real API keys kept outside and the data kept in the EU.
- A whole machine you can SSH into. Agents that build containers, run emulators or host a game server or database over raw TCP need those parts of a real machine. Without them the job stalls or needs a second service beside the workspace.
- Real API keys never enter the sandbox. A secret in an environment variable can be read by any code the agent runs. One prompt injection that prints the environment can leak it, and then you have to rotate every key.
- Your data stays in the EU. Teams whose code or customer data must stay in Europe cannot place it in a US-only region, and Shardflux offers no region to choose from, so the workspace and everything the agent touches sit in Oregon.
Questions people ask
Is bochka cheaper than Shardflux?
In the scenario table on this page, Shardflux costs less for one agent that works a normal workday and for 50 agents in parallel, and bochka costs less for one agent that runs all month. Shardflux counts only the CPU time and memory your processes use, so light, mostly idle work favors it, but its Scale plan runs at most 200 workspaces at once, so sandboxes for 1,000 users need its Enterprise plan.
Can I SSH into a Shardflux workspace?
Its docs do not describe SSH. You run commands, open terminals and move files through the Shardflux API, CLI or MCP server. A bochka sandbox has an SSH server as well as an API.
Can bochka park a sandbox with its memory like Shardflux?
No. bochka saves the disk every minute and when the sandbox stops, so files survive, but resuming boots the machine again. Shardflux keeps memory and processes and wakes a parked workspace in about a tenth of a second.
Can I run Docker and Android emulators in each?
bochka runs Docker and exposes /dev/kvm, so Android emulators and nested VMs work. Shardflux's docs do not mention Docker or nested virtualization inside a workspace.
Where does each one run?
bochka runs only in the EU, in Germany, Finland and France. Shardflux runs only in AWS us-west-2, in Oregon, United States.
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