bochka vs Datalayer
Datalayer is a platform for data agents built on Jupyter, and its sandboxes are Python kernels that run notebook code. bochka gives each agent a whole Linux machine, so it can install anything, run Docker and host what it builds.
Where bochka stands out
A whole Linux machine, not a Python kernel
Each bochka sandbox is a full VM with its own kernel, root, systemd, Docker and /dev/kvm. An agent can install any language, run a database, build containers or start an Android emulator. A Datalayer sandbox runs Python code in a notebook kernel, and its environment spec only accepts Python.
Room to work, for as long as it takes
bochka machines go up to 16 vCPU / 32 GB, with no session cap on paid plans. The disk is saved every minute and when the sandbox stops, so it picks up where it left off. Datalayer's one available size today is 1 vCPU / 1 GiB, and each runtime ends when the time you reserved runs out.
Coding agents and hosting built in
Claude Code, Codex and five other agents come preinstalled, and you drive agents inside from outside with a prompt, steer and events API. What they build is live on HTTPS URLs for up to 50 ports, and real API keys stay outside the sandbox in a credentials proxy.
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
Datalayer
Datalayer builds open and trusted agent applications for data analysis, on top of Jupyter notebooks.
Datalayer is a different kind of product: an agent studio and notebook platform, with Runtimes and Code Sandboxes as the place where agent code runs. A Datalayer sandbox is a Python Jupyter kernel in a Kubernetes pod, launched from an environment you build from Datalayer's approved base images, and reached through notebooks, the CLI or a hosted MCP server. It is made for teams whose agents read data, run Python and report results, so this page compares the two where they overlap: running agent code in the cloud.
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 | Datalayer: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker, any language and a real build machine; Datalayer sandboxes run Python notebook code, so bochka is the one built for this. | 3rd cheapest of 367 $634 a month | 363rd of 367, with limits $42,240 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month needs a persistent Linux box it can install tools on, which is what a bochka sandbox is. | 5th cheapest of 366 $657 a month | 362nd of 366, with limits $43,800 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month This is closest to what Datalayer does: Python code runs in a notebook kernel, and the kernel state can be snapshotted and loaded elsewhere. | 186th of 345, with limits $2,000 a month | 323rd of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Giving each of your users a machine means hosting their apps on HTTPS ports, which bochka has built in and Datalayer sandboxes do not offer. | Cheapest of 361 $209 a month | 347th of 361, with limits $13,950 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 | 330th of 360, with limits $60,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month Agent evals that run coding agents need a full machine; bochka has seven agents preinstalled with an API to drive them from outside. | 10th cheapest of 364 $200 a month | 338th of 364, with limits $12,000 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs need Docker, Node and other toolchains, and Datalayer's environment spec only accepts Python. | 4th cheapest of 377 $86 a month | 367th of 377, with limits $5,760 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs SSH, root and a disk that stays; bochka gives all three, while Datalayer sandboxes are reached through notebooks and MCP. | 18th cheapest of 368 $26 a month | 365th of 368, with limits $1,752 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 in the sandbox; bochka streams one at 60fps, and Datalayer has none. | 6th cheapest of 369 $200 a month | 361st of 369, with limits $12,000 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 | 359th of 367, with limits $6,000 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 | 336th of 346, with limits $3,000 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 | 322nd of 338, with limits $60,000 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 | 345th of 360, with limits $3,000 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
Every feature Battleships tracks (43)
| Feature | bochka | Datalayer |
|---|---|---|
| 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 | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | No |
| Fork/clone | Yes | Yes |
| Live fork (no pause) | Yes | Yes |
| Memory fork | No | No |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | No |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | No |
| 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 | 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 | Yes |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Yes |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | No |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement for Datalayer: it is not in the hpc-sandbox-benchmarks CPU test, and its one available size is 1 vCPU / 1 GiB, smaller than the 4 vCPU / 8 GB test shape. bochka did 26.69 runs per second on that test, 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. Datalayer 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 | Datalayer, 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 | $422 · Free · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $1,752 · Free · 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 | $21,120 · Free · 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 | $6,000 · Free · 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 | $12,000 · Free · 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.
Datalayer: Datalayer charges wallet credits while a runtime is reserved, idle or not. You pick a time reservation at launch, it is taken from your credits at once, and unused time comes back if you stop early; the one priced size is 1 vCPU / 1 GiB at $0.30 an hour. Plans add run caps and credits: Free, Team at $49 a month plus $15 per active member, and Enterprise on request.
Limits in those scenarios
Datalayer does not fit any of the five scenarios, mainly because its largest available size is 1 vCPU / 1 GiB, so a 4 vCPU / 8 GiB agent machine has no match; the table prices the nearest stand-in, several of those small runtimes. It also has no Docker inside for the agent fleet, and it does not publish how many sandboxes can run at once or what extra disk costs. bochka fits four of the five; for 1,000 short jobs at once, its $2,000 plan queues starts above 90 a minute.
| Scenario | bochka | Datalayer |
|---|---|---|
| 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 Datalayer when
your agents do Python data analysis in Jupyter notebooks that your team shares, and you want them reached over MCP or deployed on your own servers.
- Notebooks and MCP for data agents. Good for data teams: any MCP agent can read, edit and run the notebooks your team already shares.
- Python state you can move. Useful for analysis work: a kernel's Python variables can be saved and loaded into another sandbox.
- Other clouds, GPUs and on-premise. One environment builds for Datalayer, E2B, Daytona and Modal, and Enterprise can run on your own servers.
Use bochka when
your agents need a real computer: any language, Docker, a browser and a desktop, enough CPU and memory to build and test, and URLs to show what they made.
- A whole Linux machine, not a Python kernel. Coding agents need npm, cargo, Docker and test servers. In a Python-only kernel those steps fail, so you end up running a second sandbox provider next to it.
- Room to work, for as long as it takes. A build or a test suite that needs 8 GB will not fit in 1 GiB, and a job that runs past its reservation stops, so the agent has to guess its time up front.
- Coding agents and hosting built in. On Datalayer, Claude Code runs on your side and reaches notebooks over MCP, so the agent never gets a machine of its own and there is no URL to show the app it built.
Questions people ask
Is Datalayer a sandbox provider like bochka?
Partly. Datalayer is a platform for data agents built on Jupyter, and its Code Sandboxes run Python notebook code in a Kubernetes pod. bochka gives each agent a full Linux VM with root, Docker and SSH.
Is bochka cheaper than Datalayer?
In the scenarios on this page, yes: an always-on 4 vCPU / 8 GB agent costs $26 a month on bochka against $1,752 a month for the nearest Datalayer stand-in. Datalayer's one available size is 1 vCPU / 1 GiB, so it does not fully fit any of them.
Can I run Docker or Node.js in a Datalayer sandbox?
Datalayer's environment spec only accepts Python, and its docs describe no Docker daemon inside a running sandbox. bochka sandboxes run Docker, Node.js and any other Linux software, with root.
Can Claude Code use Datalayer?
Yes, as an MCP client: Claude Code, Codex and Cursor connect to Datalayer's hosted MCP server to read and run notebooks. On bochka, Claude Code and six other agents run inside the sandbox, and you drive them from outside with an API.
Does Datalayer have GPUs?
Its own GPU sizes are listed as unavailable today, but one environment can build for Modal and Daytona, which run it on their GPUs with your own account. bochka does not offer GPUs.
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