bochka vs YepCode Run
YepCode Run takes a piece of JavaScript or Python, runs it in a short-lived microVM and hands back the result. bochka gives an agent a whole Linux machine that keeps its disk, runs Docker and stays up as long as the work takes.
Where bochka stands out
A whole machine, not a script runner
A bochka sandbox is a full Linux VM where the agent is root. It runs Docker, systemd, databases, any language and Android emulators through /dev/kvm, with up to 16 vCPU / 32 GB. YepCode Run gives each run a fixed JavaScript or Python runtime with 300 MB or 600 MB of RAM.
A disk that stays and no session cap
bochka saves the disk every minute and when the sandbox stops, and a stopped sandbox costs nothing and keeps its files. Paid plans have no session cap, and you can fork a running sandbox. A YepCode run ends after 1 hour on Starter or 12 hours on Growth, and its local disk goes with it.
Agents you drive from outside, with keys kept out
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 it 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
YepCode Run
YepCode is a code automation platform, and YepCode Run is its service for running AI-generated JavaScript and Python safely in isolated sandboxes.
You send code through an SDK, the REST API, a webhook or the MCP server, and YepCode runs it in a fresh Firecracker microVM with any npm or PyPI package, then returns the result. Each run has a fixed amount of memory, a temporary local disk and a time limit set by your plan, and files that must last go to YepCode Storage through API calls. It is a different kind of product from bochka: a serverless code runner and automation platform, not a machine you keep, and it is built for teams that want to run scripts and integrations without managing servers.
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 | YepCode Run: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker, databases and builds in any language, which a 600 MB JavaScript and Python runner cannot hold; bochka gives each agent a full VM. | 3rd cheapest of 367 $634 a month | 71st of 367, with limits $599 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month outlasts YepCode's 12-hour run limit and loses its local disk at the end of each run; bochka keeps both. | 5th cheapest of 366 $657 a month | 109th of 366, with limits $599 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month This is what YepCode Run is built for: short JavaScript or Python runs that start, finish and return a result. | 186th of 345, with limits $2,000 a month | 223rd of 345, with limits $119 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month YepCode suits giving users a place to run scripts, while bochka gives each user a whole machine with hosting, a desktop and a disk that persists. | Cheapest of 361 $209 a month | 207th of 361, with limits $387 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 | 224th of 360, with limits $749 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 | 345th of 364, with limits $149 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs need Docker, toolchains in any language and often more than 600 MB of RAM, which a bochka VM has. | 4th cheapest of 377 $86 a month | 237th of 377, with limits $119 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs a disk and a shell that stay, and YepCode runs have neither; a bochka sandbox keeps its disk and runs as long as you want. | 18th cheapest of 368 $26 a month | 267th of 368, with limits $119 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 a Linux desktop at 60fps, and YepCode Run is headless. | 6th cheapest of 369 $200 a month | 89th of 369, with limits $149 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 | 185th of 367, with limits $149 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month Scrapers that drive a real browser need Chromium and more memory than a YepCode sandbox has; bochka ships Chromium on a full VM. | 6th cheapest of 346 $90 a month | 206th of 346, with limits $149 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 | 64th of 338, with limits $1,649 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 | 151st of 360, with limits $119 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 | YepCode Run |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Firecracker microVM per run |
| What runs inside | Any Linux software, as root, with systemd | JavaScript (Node.js) and Python processes, with npm and PyPI packages |
| Machine size | Up to 16 vCPU / 32 GB on the $100 plan and above | 300 MB RAM on Starter, 600 MB on Growth; vCPU not published |
| How long it runs | No cap on paid plans; you set the time to live | Up to 1 hour on Starter, 12 hours on Growth |
| Disk | Persistent disk, saved every minute and on stop; a stopped sandbox keeps it for free | Temporary local disk (250 MB on Starter, 5 GB on Growth) that ends with the run; lasting files go to Storage by API |
| Docker and nested virtualization | Docker inside, and /dev/kvm for Android emulators and VMs | Neither; fixed JavaScript and Python runtimes |
| Fork and snapshots | Fork a running sandbox with its disk; snapshots every minute | No fork or snapshot; each run starts fresh |
| Desktop and browser | Linux desktop streamed at 60fps, Chromium and computer use | Headless code runner, no desktop or browser |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; its own IP | Sandboxes API can expose public HTTP ports with basic auth; processes start from HTTPS webhooks |
| Reaching private services | Open internet; as root you can run your own tunnel or VPN client | One fixed outbound IP to allow in your firewall, plus built-in SSH tunnels on paid plans |
| Coding agents | Seven agents preinstalled, with a prompt, steer and events API | Yep Agent writes YepCode processes from the web app; no API to drive it |
| Keeping API keys out of the sandbox | Credentials proxy for model providers and any HTTPS API; real keys never enter the sandbox | Team variables injected as environment variables; the code sees the real value |
| MCP server | No hosted MCP server; agents use the API or CLI | Open-source MCP server with run_code, storage, variables and your processes as tools |
| Self-hosting | No | Executors on your own infrastructure on Growth; full stack on Enterprise |
| 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 | YepCode Run |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| 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 | No |
| ≥24 h sessions | Yes | No |
| Idle auto-stop | No | No |
| 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 | Yes |
| 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 | 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. YepCode does not publish how many vCPU a sandbox gets, and it has not been run on the hpc-sandbox-benchmarks CPU test. bochka did 26.69 runs per second on that 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. YepCode Run 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 | YepCode Run, 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 | $599 · Growth · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $599 · Growth · 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 | $599 · Growth · 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 | $599 · Growth · 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 | $599 · Growth · 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.
YepCode Run: YepCode charges a flat monthly plan fee that includes a pool of Yeps, where one Yep is one second of a running process, and each extra Yep is billed at the plan's fixed rate. Unused Yeps do not carry over, and you pay per running process whatever CPU it uses, so the scenarios here use the Growth plan, the only self-serve plan with runs up to 12 hours.
Limits in those scenarios
YepCode does not fit any of the five scenarios as a like-for-like sandbox: its runs have no disk that persists, no Docker and a published size of only 600 MB of RAM on Growth. A run stops after 12 hours on Growth, so an agent that never stops has to be restarted by your code, and Growth allows 50 runs at once, which caps the user-sandboxes and burst scenarios. 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 | YepCode Run |
|---|---|---|
| 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 YepCode Run when
you want to run short JavaScript or Python scripts and integrations from webhooks, schedules or an MCP tool, or must run the executors on your own infrastructure.
- Run code on your own infrastructure. Teams that must keep execution inside their own network can run YepCode's executors on-premise on Growth, or the full stack on Enterprise.
- An automation platform around the code. If you want scripts with webhooks, schedules, forms, storage and an MCP server already wired up, YepCode gives you that platform.
- One fixed outbound IP and SSH tunnels. Scripts that must reach databases behind a firewall get one fixed outbound IP to allow, plus SSH tunnels on paid plans.
Use bochka when
your agents need a real machine: installs, builds, tests, Docker, a browser and a desktop, on a disk that stays, for as long as the work takes.
- A whole machine, not a script runner. Coding agents install tools, start Docker and run test suites in many languages. In a 600 MB Node.js or Python runtime with no Docker, most of that work cannot start at all.
- A disk that stays and no session cap. An agent that works for days on one repo would lose its checkout, installs and build cache at the end of every YepCode run, and your code would have to copy files to Storage by API and back.
- Agents you drive from outside, with keys kept out. Yep Agent only runs from the YepCode web app, and YepCode team variables reach the code as plain environment variables, so a prompt-injected agent could read and leak them.
Questions people ask
Is bochka cheaper than YepCode?
In the scenarios on this page, yes: one coding agent on workdays costs $20 a month on bochka, and YepCode's Growth plan, which the scenarios use for its 12-hour runs, comes to $599. YepCode also does not fit any of them as a like-for-like sandbox, since its runs have no persistent disk or Docker.
Can YepCode Run host a coding agent like Claude Code?
Not as a long-lived machine. YepCode runs JavaScript and Python processes for up to 12 hours with 600 MB of RAM and a disk that ends with the run. Its own Yep Agent works from the web app, while bochka preinstalls seven coding agents you drive by API.
Can I run Docker in YepCode?
No. YepCode runs code in fixed Node.js and Python runtimes and documents no way to start containers inside a run. A bochka sandbox runs Docker inside and also exposes /dev/kvm for VMs and Android emulators.
Does a YepCode sandbox keep its files?
Only what your code uploads to YepCode Storage. The local disk is temporary and ends with each run. bochka keeps the whole disk, saved every minute and when the sandbox stops.
Can I self-host YepCode or bochka?
YepCode can run its executors on your own infrastructure on Growth, and the full stack on Enterprise. bochka is a hosted service only, running in the EU.
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