bochka vs Kedge
Kedge is a global app platform that also runs short sandboxes and coding agents in persistent workspaces. bochka is built for the agent itself: a full VM with root, Docker, nested virtualization and a desktop, which your code drives through an API.
Where bochka stands out
A whole machine the agent can own
Every bochka sandbox is a full VM with root, systemd, Docker and /dev/kvm, so agents can run compose stacks, Android emulators and VM images. Kedge documents Docker and sudo on its CI runners, but its workspace docs do not, and no Kedge product documents nested virtualization.
Agents you drive from outside
bochka ships seven coding agents and a prompt, steer and events API, so your code can start agents inside many sandboxes, redirect them and follow every step. Real API keys stay outside the sandbox in a credentials proxy that works with any HTTPS API.
A desktop and a browser built in
bochka streams a 60fps Linux desktop with Chromium, and agents can drive it with computer use while you watch or embed it in your app. Kedge has no desktop or managed browser.
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
Kedge
Kedge is a lightweight, globally distributed cloud platform for apps, with disposable sandboxes and coding-agent workspaces built in.
Kedge is mainly an app platform, closer to a global Heroku than to a sandbox API. You deploy sites, handlers, container services and databases, each app gets a replicated SQLite database and file tree, and services scale to zero by restoring VM snapshots taken after startup. It also offers one-shot and held sandboxes, GitHub Actions runners, and persistent workspaces where its own agent, Claude Code or Codex builds and deploys apps for you.
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 | Kedge: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker, a browser for tests and long builds on one machine; bochka documents all of these inside the sandbox, while Kedge documents Docker only on its CI runners. | 3rd cheapest of 367 $634 a month | 45th of 367, with limits $275 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Kedge workspaces sleep after ten quiet minutes by default and wake on the next request; bochka keeps the machine running and lets your code prompt and steer the agent by API. | 5th cheapest of 366 $657 a month | 101st of 366, with limits $441 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Kedge's disposable sandboxes come from warm pools and bill only the CPU time they use, which suits short code runs; a held one lasts up to an hour. | 186th of 345, with limits $2,000 a month | 57th of 345, with limits $45 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Kedge can give each user an app with its own HTTPS URL that scales to zero; bochka gives each user a full VM with hosting, a desktop and agents built in. | Cheapest of 361 $209 a month | 32nd of 361, with limits $154 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 | 49th of 360, with limits $2,841 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 | 98th of 364, with limits $213 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Kedge runs GitHub Actions jobs in fresh 4 vCPU / 8 GiB VMs with Docker; bochka adds nested virtualization for Android emulators and VM images. | 4th cheapest of 377 $86 a month | 149th of 377, with limits $201 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Kedge machine that goes idle pauses and bills no CPU or memory, which suits a part-time dev box; bochka gives root, systemd and /dev/kvm on a disk saved every minute. | 18th cheapest of 368 $26 a month | 116th of 368, with limits $7.64 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Kedge has no desktop to drive; bochka streams a 60fps Linux desktop with Chromium and computer use. | 6th cheapest of 369 $200 a month | 72nd of 369, with limits $51 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Kedge does not offer a browser for automation; bochka ships Chromium on a desktop you can watch and embed. | 7th cheapest of 367 $200 a month | 153rd of 367, with limits $41 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 | 171st of 346, with limits $83 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 | 67th of 338, with limits $1,702 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 | 134th of 360, with limits $90 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 | Kedge |
|---|---|---|
| Kind of product | Agent sandbox: a full Linux VM for each agent or user | App platform with sandboxes, CI runners and coding-agent workspaces |
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Hardware-isolated VM with its own Linux kernel |
| Root, Docker and nested virtualization | Root, systemd, Docker and /dev/kvm in every sandbox | Docker and passwordless sudo documented on CI runners; no nested virtualization documented |
| Desktop and browser | 60fps Linux desktop with Chromium and computer use, embeddable in your app | None; the workspace UI is an agent session in a browser tab |
| Coding agents | Seven agents preinstalled, driven from outside with a prompt, steer and events API | Built-in app agent, Claude Code and Codex, started from the CLI, SSH or the web |
| 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 | Secrets as environment variables or files mounted under /run/secrets inside the VM |
| Session length | No cap on paid plans; you set the time to live | Workspaces and machines have no stated cap; held sandboxes last up to 1 hour, 10 minutes per command |
| Idle and wake | Runs until you stop it or its time to live ends; started again by API | Workspaces sleep after ten quiet minutes and wake on the next request; idle machines bill no CPU or memory |
| Persistent disk | Disk saved every minute and on stop; a stopped sandbox costs nothing | Workspace volume keeps the whole filesystem; storage is billed while it sleeps |
| Fork | Fork a running sandbox with its disk | Copy an app and its current data with kedge fork; no fork of a running workspace or sandbox |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP | HTTPS at name.kedge.run or your own domain, with CDN and app login; no static addresses |
| App hosting extras | Host what the sandbox runs on its ports | Scale to zero, replicated SQLite in every app, domain registration, pull-request previews |
| Regions | EU only (Germany, Finland, France) | Ten compute regions on six continents, including Germany and Finland |
| 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 | Kedge |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Not published |
| 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 | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| Fork/clone | Yes | Yes |
| 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 | Yes |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | No |
| Public IPv4 | No | No |
| Egress allowlist | No | No |
| Secret proxy | Yes | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | Yes |
| 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 | Yes |
| 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 | Yes |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement: Kedge has not been run on the hpc-sandbox-benchmarks CPU test, so this page does not compare CPU speed. bochka did 26.69 runs per second at 4 vCPU / 8 GB on dedicated AMD Ryzen 9 9950X hosts. Kedge publishes start times instead: 0.6 ms for a fresh sandbox from its warm pool, measured on its own hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Kedge 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 | Kedge, 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 | $6 · Public preview · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $34 · Public preview · 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 | $480 · Public preview · 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 | $124 · Public preview · 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 | $510 · Public preview · 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.
Kedge: Kedge is in public preview, and its rates are estimates that may change: $15 per vCPU-month of CPU time actually used, $5 per GiB-month of recently touched memory, $0.05 per GiB-month of stored data and $0.01 per GiB of egress. Every account gets $5 of usage a month.
Limits in those scenarios
Every Kedge scenario is marked as not fitting because its prices are preview estimates, not a paid service you can sign up for today. Kedge also does not publish how many machines an account can run at once, and past its cap a new sandbox fails with an error instead of waiting in a queue, so 300 user sandboxes or 1,000 jobs at once are not confirmed. bochka's plans fit every scenario except 1,000 short jobs at once, where even the $2,000 plan queues starts above 90 a minute.
| Scenario | bochka | Kedge |
|---|---|---|
| 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 Kedge when
you want agents to build and ship web apps onto a global host that scales to zero, or need compute outside Europe.
- Regions around the world. Useful when users are far from Europe: it runs in ten compute regions across six continents.
- Scale to zero and wake on request. Good for agents and apps that sit idle most of the day: an idle machine bills no CPU or memory.
- A full app platform. Fits teams that want agents to ship apps straight to production hosting with a database and domain.
Use bochka when
the agent needs a real machine to work in: root, Docker, emulators and a browser, driven from your own code with keys kept out of reach.
- A whole machine the agent can own. Agent tasks often end in docker compose up or an emulator boot. If the machine cannot do that, the agent stops and a person has to finish the job somewhere else.
- Agents you drive from outside. Kedge starts its agents from a terminal, SSH or a web page, and secrets are mounted inside the VM. Running agents from your own backend means scripting the CLI, and one prompt injection can read the keys.
- A desktop and a browser built in. Agents that test a web app, fill a form or use a site without an API need a screen. On Kedge you would have to bring and host that stack yourself.
Questions people ask
Is bochka cheaper than Kedge?
It depends on the job. Kedge's estimates are lower for one workday agent, sandboxes for your users and 1,000 short jobs, because it bills only CPU time used. bochka is lower for an agent that never stops and for 50 agents in parallel ($317 against $480 a month), and Kedge's rates are still preview estimates.
Is Kedge a sandbox or a hosting platform?
Mainly a hosting platform. Kedge deploys apps, services and databases worldwide, and adds disposable sandboxes, CI runners and coding-agent workspaces on the same VMs. bochka is a sandbox first: a full machine for each agent.
Can I run Docker and Android emulators in each?
Kedge documents Docker and passwordless sudo on its GitHub Actions runners, and its workspace docs do not say either way. Neither nested virtualization nor /dev/kvm appears in Kedge's docs. bochka gives root, Docker and /dev/kvm in every sandbox.
Can a Kedge agent use a browser or desktop?
Kedge does not offer one. Its workspace UI is a chat and terminal session in your browser. bochka has a 60fps Linux desktop with Chromium that agents drive with computer use.
Is Kedge faster than bochka?
There is no comparable CPU measurement for Kedge. bochka did 26.69 runs per second on the hpc-sandbox-benchmarks test at 4 vCPU / 8 GB. Kedge reports fresh sandboxes ready in 0.6 ms from a warm pool, which measures start time, not CPU speed.
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