bochka vs Koyeb
Both run each sandbox in its own virtual machine. bochka gives an agent a whole machine that keeps its disk and comes with agents and hosting built in, while Koyeb shines at sandboxes that sleep when idle, run on GPUs, or live in many regions.
Where bochka stands out
A disk that stays, and forks of a running machine
A bochka sandbox keeps its disk when it stops, saves it every minute, and can be forked while it runs. On Koyeb the local disk is lost on redeploy and a deep sleep discards the VM, so lasting files need a volume, which is in preview at 1 to 10 GB in two regions.
Root, systemd, Docker and /dev/kvm
bochka runs full VMs on dedicated AMD Ryzen 9 9950X hosts, with root, systemd, Docker and /dev/kvm for Android emulators and VMs. Koyeb sandboxes run Docker images in a microVM, and Koyeb does not document nested virtualization.
Agents, desktop and hosting built in
Claude Code, Codex and five other agents come preinstalled, and you prompt, steer and follow them through one API, while real API keys stay outside the sandbox in a credentials proxy. Each sandbox also has a 60fps desktop with Chromium and HTTPS on up to 50 ports.
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
Koyeb
Koyeb is a serverless cloud for apps, inference and sandboxes, and in February 2026 it agreed to join Mistral AI.
A Koyeb sandbox is a Koyeb service: a microVM started from any Docker image and driven from Python or JavaScript SDKs that run commands, read files and expose a port. It can scale to zero when idle and wake on the next request, and it can run on CPU or GPU instance types. It is built for teams that run AI agents or untrusted code next to apps they already host on Koyeb.
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 | Koyeb: 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 disk that survives restarts and room to build; bochka keeps the disk by default, while Koyeb's local disk is lost on redeploy unless you add a volume. | 3rd cheapest of 367 $634 a month | 54th of 367, with limits $366 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month needs its files to stay put; on bochka they do, on Koyeb a deep sleep throws away the VM. | 5th cheapest of 366 $657 a month | 135th of 366, with limits $923 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Koyeb fits short code runs well: small instances, scale to zero after 5 minutes, and a wake on the next request. | 186th of 345, with limits $2,000 a month | 4th cheapest of 345 $66 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Both fit; Koyeb wakes a sleeping sandbox on request and runs in more regions, while bochka gives each user a fuller machine with up to 50 HTTPS ports. | Cheapest of 361 $209 a month | 6th cheapest of 361 $495 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 | 237th of 360, with limits $1,631 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 | 19th cheapest of 364 $429 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI that builds Android apps or VM images needs /dev/kvm, which bochka exposes and Koyeb does not document. | 4th cheapest of 377 $86 a month | 142nd of 377, with limits $88 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 217th of 368, with limits $37 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; bochka streams a 60fps Linux desktop with Chromium, and Koyeb sandboxes have no desktop. | 6th cheapest of 369 $200 a month | 81st of 369, with limits $123 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month bochka ships Chromium on a desktop in every sandbox; on Koyeb you install and run a headless browser yourself. | 7th cheapest of 367 $200 a month | 172nd of 367, with limits $123 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 | 172nd of 346, with limits $89 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 | 65th of 338, with limits $1,683 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 | 233rd of 360, with limits $299 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Koyeb runs GPU instances from small RTX cards up to H100 and H200, and bochka has no GPUs. | Can't run it | 3rd cheapest of 98 $628 a month |
| 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 | Koyeb |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | MicroVM per instance |
| CPU share | vCPUs on dedicated AMD Ryzen 9 9950X hosts; 26.69 runs/s on the CPU benchmark | At least 0.25 dedicated vCPU per GB of memory, bursting to all cores; not benchmarked |
| Biggest machine | Up to 16 vCPU / 32 GB on the $100 plan and above | Instance types up to 40 vCPU / 128 GB, and GPU types far larger |
| Disk that survives | Disk is kept across stops and saved every minute, with snapshots | Local disk is lost on redeploy; volumes (preview, 1 to 10 GB, Frankfurt and Washington) persist |
| Sleep and wake | Stop and start by API; a stopped sandbox costs nothing and keeps its disk | Scales to zero after an idle period (5 minutes minimum) and wakes on the next request; Light Sleep wakes in about 200 ms |
| Snapshots and fork | Fork a running sandbox with its disk | SDK snapshots of the filesystem, or with running processes, then new sandboxes from a snapshot (experimental) |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | Not documented |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 | One exposed HTTPS port at a time, plus an optional TCP proxy to one port; no dedicated IP |
| Outbound rules | Open internet, no provider-side allowlist | Block all outbound traffic, or allow only listed IPs and CIDRs |
| Desktop and browser | 60fps Linux desktop with Chromium and computer use | No desktop or browser in the sandbox SDK |
| Coding agents | Seven agents preinstalled, with a prompt, steer and events API | Tutorials that run agents through the command API; an MCP server lets agents manage Koyeb |
| 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 are set as environment variables inside the service |
| GPUs | No | RTX 4000 SFF Ada up to H100, H200 and multi-GPU |
| Regions | EU only (Germany, Finland, France) | EU, US and Asia |
| 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 | Koyeb |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| 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 | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| Fork/clone | Yes | Yes |
| Live fork (no pause) | Yes | Not published |
| 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 | No |
| Secret proxy for any API | Yes | No |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | No |
| MCP server | No | Yes |
| GPU | No | Yes |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | Yes |
| BYOC | No | Yes |
| Open source | No | No |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | No |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Yes |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | No |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement for Koyeb: it was not part of the hpc-sandbox-benchmarks run. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB. Koyeb publishes a CPU share of at least 0.25 dedicated vCPU per GB of memory, bursting to all cores, so its speed depends on how busy the host is.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Koyeb 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 | Koyeb, 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 | $29 · Pro |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $57 · 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 | $475 · Pro |
| 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 | $329 · Scale |
| 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 | $485 · 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.
Koyeb: Koyeb bills each instance per second from the moment it starts, at a fixed price per instance type, and Deep Sleep costs nothing (Light Sleep is free during its preview). Pro costs $29 a month with $10 of usage included and Scale $299 a month with $100 included; the rest of the fee is not credit, and bandwidth above 1 TB is extra.
Limits in those scenarios
Koyeb's priced shape here is eco-xlarge, which has a 20 GiB disk and no published price for more, and eco instances guarantee only half of each vCPU. Its Pro plan allows 100 services and Scale 1,000, and Scale is also capped at about 1 TB of running memory. At 1,000 short jobs at once, neither fits as priced: bochka's $2,000 plan queues starts above 90 a minute, and Koyeb's burstable CPU throttles under load.
| Scenario | bochka | Koyeb |
|---|---|---|
| One coding agent, workdays | None that bite |
|
| One agent that never stops | None that bite |
|
| 50 agents in parallel | None that bite | None that bite |
| Sandboxes for your users | None that bite | None that bite |
| 1,000 short jobs at once |
|
|
Which one should you use?
Use Koyeb when
your sandboxes need GPUs, sleep most of the time and must wake on a request, or have to run in the US or Asia.
- GPUs in the same platform. Useful when an agent or eval needs a GPU: Koyeb runs instances from RTX 4000 cards up to H100 and H200.
- Sleep when idle, wake on request, many regions. Good for sandboxes that sit idle between requests, or that must run in the US or Asia.
- Egress rules and your own infrastructure. Koyeb can block or allowlist outbound traffic by IP, and offers on-premise and edge deployments for Enterprise.
Use bochka when
your agents do real work for hours on a machine that keeps its disk: builds, Docker, emulators, a desktop browser and preview servers, with agents and keys handled for you.
- A disk that stays, and forks of a running machine. An agent's repo, installs and caches are its working memory. On Koyeb you either keep the sandbox awake and paying, or wire up volumes or experimental snapshots so a sleep does not wipe hours of setup.
- Root, systemd, Docker and /dev/kvm. Android emulators, Firecracker or QEMU VMs and some CI jobs cannot start without /dev/kvm, so on Koyeb that part of the work has to run somewhere else.
- Agents, desktop and hosting built in. On Koyeb you build the agent harness on top of exec, keep keys as environment variables the agent can read, and can expose only one port at a time, so a dev server plus an API needs workarounds.
Questions people ask
Is bochka cheaper than Koyeb?
In the four scenarios that both fit on this page, yes: for example $26 against $57 a month for one agent that never stops, and $317 against $475 for 50 agents in parallel. For 1,000 short jobs at once neither fits as priced.
Does a Koyeb sandbox keep its files?
Not by default. Its local disk is lost on redeploy and a deep sleep discards the VM, so lasting files need a volume (in preview) or an SDK snapshot. A bochka sandbox keeps its disk across stops and saves it every minute.
Can I run Docker and Android emulators in each?
Both start from Docker images, and bochka runs Docker inside the sandbox with root and systemd. bochka also exposes /dev/kvm for Android emulators and VMs, which Koyeb does not document.
Does Koyeb have GPU sandboxes?
Yes. Koyeb runs instances from an RTX 4000 SFF Ada up to H100 and H200, billed per second. bochka is CPU only.
What happened to Koyeb after Mistral AI?
Koyeb announced on February 17, 2026 that it agreed to join Mistral AI. It says the platform keeps running and will become part of Mistral Compute, and that new users now pick Pro, Scale or Enterprise instead of Starter.
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
More comparisons
- bochka vs E2B
- bochka vs Daytona
- bochka vs Modal
- bochka vs Vercel Sandbox
- bochka vs Blaxel
- bochka vs Runloop
- bochka vs Tensorlake
- bochka vs Cloudflare Sandbox
- bochka vs exe.dev
- bochka vs Agent 37
- bochka vs Oracle Cloud
- bochka vs IONOS Cloud
- E2B vs Koyeb
- Daytona vs Koyeb
- Modal vs Koyeb
- Vercel Sandbox vs Koyeb
- Cloudflare Sandbox vs Koyeb
- Blaxel vs Koyeb
- Runloop vs Koyeb
- Tensorlake vs Koyeb