bochka vs Hugging Face Jobs
Hugging Face Jobs runs a command in a container on the CPU or GPU you pick, then throws the machine away. bochka gives each agent a whole VM with Docker and a disk that stays, so it can come back to its work tomorrow.
Where bochka stands out
A whole Linux machine, not one command
A bochka sandbox is a full VM with root, systemd, Docker and /dev/kvm. An agent can run docker compose, start an Android emulator or install a system service. A Job runs one container without the rights that Docker needs.
Work that is still there tomorrow
bochka saves the disk every minute and when the sandbox stops. A stopped sandbox costs nothing and comes back days later with every package and file, and you can fork a running one. There is no session cap on paid plans.
Agents, desktop and keys 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. Every sandbox also has a 60fps desktop and Chromium, and a credentials proxy keeps real API keys outside the machine.
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
Hugging Face Jobs
Hugging Face Jobs is a pay-as-you-go compute service on the Hugging Face Hub: you run a Python script or a Docker image on CPUs or GPUs and pay by the minute.
Jobs is a batch compute product, not an agent sandbox. Each Job runs one command in a container inside its own VM, with your models, datasets and Storage Buckets mounted from the Hub, and it is built for training, inference over datasets and data processing. A sandbox layer on top (first the hf-sandbox package, now an experimental Sandbox API in huggingface_hub) adds run, files and process calls, which is where it overlaps with bochka.
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 | Hugging Face Jobs: 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 desktop and a disk that survives between sessions; a Job cannot run Docker and its disk is gone when it ends. | 3rd cheapest of 367 $634 a month | 53rd of 367, with limits $362 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month does not fit a Job, whose disk resets and whose sandbox API stops after 24 hours at most. | 5th cheapest of 366 $657 a month | 98th of 366, with limits $365 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Hugging Face's sandbox pools pack many short code runs into one Job VM, which suits cheap bursts of your own code. | 186th of 345, with limits $2,000 a month | 208th of 345, with limits $33 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month | Cheapest of 361 $209 a month | 194th of 361, with limits $105 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Rollouts that run your own code fit Hugging Face's sandbox pools, which created and ran 1,000 sandboxes in about 16 seconds in its own test. | 34th of 360, with limits $2,000 a month | 221st of 360, with limits $500 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 | 229th of 364, with limits $120 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI runners that build Docker images or Android apps need Docker and /dev/kvm, which bochka has and a Job does not. | 4th cheapest of 377 $86 a month | 217th of 377, with limits $36 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs to keep its packages and files from one day to the next, which bochka does with a disk saved every minute. | 18th cheapest of 368 $26 a month | 136th of 368, with limits $22 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month bochka ships a 60fps desktop, Chromium and a computer-use API; Jobs has no desktop. | 6th cheapest of 369 $200 a month | 79th of 369, with limits $110 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 | 152nd of 367, with limits $40 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 | 156th of 346, with limits $49 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 | 43rd of 338, with limits $975 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 | 101st of 360, with limits $24 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Hugging Face Jobs rents GPUs from T4 to H200 by the minute and bochka has none, so Jobs is the pick for GPU work. | Can't run it | 55th of 98, with limits $688 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 | Hugging Face Jobs |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | A VM per Job, with your code in a container as namespaced root |
| Docker inside | Yes, in every sandbox | No; a Job has no CAP_SYS_ADMIN, and unshare and mount fail |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | Not documented |
| Disk after a stop | Saved every minute and on stop; resume later with every file in place | Ephemeral disk does not survive the Job; keep files in a mounted Storage Bucket |
| Session length | No cap on paid plans; you set the time to live | Jobs: 30-minute default timeout you can raise; Sandbox API: fixed 24-hour maximum |
| Fork | Fork a running sandbox with its disk | Not offered; each Job starts fresh from an image |
| Desktop, browser, computer use | 60fps desktop, Chromium and computer-use API built in | Not offered |
| Coding agents | Seven agents preinstalled, with a prompt, steer and events API | None built in; the Sandbox API runs commands, moves files and lists processes |
| Keeping API keys out of the sandbox | Credentials proxy for model providers and any HTTPS API | Secrets are encrypted at rest but arrive as environment variables; docs say to treat reachable credentials as exposed |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default, plus raw TCP | HTTPS URL per exposed port behind an HF token or public; SSH with port forwarding |
| GPUs | None | T4, L4, L40S, A10G, A100, H200 and RTX PRO 6000, up to 8 per Job |
| Biggest machine | Up to 16 vCPU / 32 GB on the $100 plan and above | CPU up to 32 vCPU / 256 GB; GPU flavors up to 192 vCPU |
| Many small sandboxes | One VM per sandbox, with a start rate set by your plan | Sandbox pools pack many sandboxes into one Job VM, for code within one trust boundary |
| Models and datasets | Download them over the network | Mount Hub models, datasets and buckets as folders, fetched lazily |
| 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 | Hugging Face Jobs |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | Yes |
| 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 | 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 | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | Yes |
| 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 | No |
| 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 | No |
| Audit logs | No | Not published |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | Yes |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement: Hugging Face Jobs has not been run on the hpc-sandbox-benchmarks CPU test, so this page makes no speed claim for it. bochka scored 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. Hugging Face Jobs 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 | Hugging Face Jobs, 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 | $5 · Positive prepaid credit balance · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $22 · Positive prepaid credit balance · 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 | $238 · Positive prepaid credit balance · 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 | $45 · Positive prepaid credit balance · 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 | $100 · Positive prepaid credit balance · with limits |
bochka: bochka charges one hourly rate per machine size, by the second, only while the sandbox runs. Plans start at $20 a month and the whole fee becomes usage credit; a stopped sandbox costs nothing and keeps its disk.
Hugging Face Jobs: Jobs bill per minute for the hardware flavor while a Job is Starting or Running, with no charge during the build, from $0.01 an hour for cpu-basic. Exposing ports adds $0.01 per Job-hour; you need a positive credit balance, and PRO, Team or Enterprise credits count toward it.
Hugging Face Jobs: Jobs sizes are fixed flavors, so the table picks the nearest one: cpu-upgrade (8 vCPU / 32 GB) against bochka's 4 vCPU / 8 GB, and cpu-basic (2 vCPU / 16 GB) against bochka's 2 vCPU / 4 GB.
Limits in those scenarios
Jobs does not fit any of the five scenarios as a like-for-like sandbox: files survive only in mounted buckets, so packages installed anywhere else reset each time, and a Job cannot run Docker, which the 50-agent fleet needs. Hugging Face does not publish how many Jobs can run at once or what egress costs, so 300 user sandboxes or 1,000 jobs at once are not confirmed. On bochka, the limit that bites is start speed: the $2,000 plan starts 90 sandboxes a minute and 2,400 a day, so 1,000 short jobs at once queue.
| Scenario | bochka | Hugging Face Jobs |
|---|---|---|
| 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 Hugging Face Jobs when
your work needs GPUs, lives next to models and datasets on the Hub, or fans out many short runs of your own code.
- GPUs by the minute. Useful if your jobs train or run models: Jobs rents GPUs from T4 up to 8x H200, billed per minute.
- Cheap fan-out of your own code. Useful for RL rollouts and evals of your own code: sandbox pools pack many small sandboxes into one VM.
- Close to the Hub. Useful for teams already on the Hub: Jobs mounts models, datasets and buckets, and runs on a schedule or webhook.
Use bochka when
your agents work for hours or days on real projects: Docker, emulators, a desktop and a browser, on a machine that keeps its disk and its keys outside.
- A whole Linux machine, not one command. On Jobs, docker build, unshare and mount all fail, so an agent cannot run the project's own containers or test stack, and you rebuild the setup as one big image.
- Work that is still there tomorrow. A Job's disk is gone when it ends and its sandbox API stops after 24 hours at most, so an agent reinstalls everything each session unless you sync files to a bucket yourself.
- Agents, desktop and keys built in. On Jobs you build the harness and the screen yourself, and keys arrive as environment variables that any code in the Job, including an injected prompt, can read.
Questions people ask
Is bochka cheaper than Hugging Face Jobs?
No, not on raw hardware price: Jobs costs less in every scenario on this page, for example $238 against $317 a month for 50 agents. But Jobs does not fit any of them as a sandbox, because its disk resets after each Job and it cannot run Docker.
Can Hugging Face Jobs run Docker inside?
No. A Job runs your image as a container without CAP_SYS_ADMIN, and Hugging Face's docs say unshare and mount fail. Every bochka sandbox runs Docker with no extra setting.
What is hf-sandbox?
hf-sandbox was a prototype that turned Hugging Face Jobs into a sandbox you could run commands in. It is now archived and moving into huggingface_hub as an experimental Sandbox API, where each sandbox is still a Job.
How long can a Hugging Face sandbox run?
A plain Job stops after 30 minutes unless you set a longer timeout. A sandbox from the Sandbox API stops after 10 idle minutes by default and has a fixed 24-hour maximum. bochka has no session cap on paid plans.
Does bochka have GPUs?
No. bochka sandboxes are CPU machines. If your workload needs a GPU, Hugging Face Jobs is the better fit.
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