bochka vs SF Compute
SF Compute is a GPU cloud: it sells H100 and newer GPU time, plus Autoresearch nodes and RL sandboxes that agents drive over MCP. bochka is an agent sandbox: a full Linux VM per agent with Docker, a desktop, hosting and coding agents already inside.
Where bochka stands out
A whole machine the agent can build on
Each bochka sandbox is a full VM with root, systemd and Docker, plus /dev/kvm for Android emulators and VMs. You can SSH in, and the whole disk is kept when it stops, with a snapshot every minute.
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 in a credentials proxy outside the sandbox, and a credential can switch to another account when one runs out of credits.
A desktop and hosting in the box
Every sandbox has a 60fps Linux desktop with Chromium for computer use, HTTPS URLs on up to 50 ports and raw TCP. An agent can open a browser, build an app and serve it from the same 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
SF Compute
SF Compute is a GPU cloud from San Francisco that builds its own clusters and runs a market where teams buy and resell GPU time.
The main product is GPU capacity: VMs, bare metal and managed Slurm on 8-GPU nodes, bought on an order book and resold when plans change. Autoresearch, its platform for agents, adds H100 and CPU nodes (containers with a persistent disk), batch GPU jobs, and small microVM sandboxes that bake once and fork with their memory for RL rollouts. It is made for teams that train, fine-tune and evaluate models, and it is driven over MCP, an HTTP API or a CLI rather than an interactive shell.
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 | SF Compute: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent building a full app needs Docker, a disk that keeps installed packages, and ports to host from, which bochka gives every sandbox. | 3rd cheapest of 367 $634 a month | 190th of 367, with limits $2,196 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month needs the whole disk kept, a desktop and its own agents; an Autoresearch node keeps only its home folder across stops. | 5th cheapest of 366 $657 a month | 284th of 366, with limits $5,650 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month SF Compute sandboxes fork in milliseconds and park after about 1.5 seconds idle, so short code runs that sit idle between calls pay little. | 186th of 345, with limits $2,000 a month | 138th of 345, with limits $305 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 | 181st of 361, with limits $7,691 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Autoresearch sandboxes are built for RL: bake an environment once, then fork up to 256 copies with memory and running processes in one call. | 34th of 360, with limits $2,000 a month | 140th of 360, with limits $9,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month Both run evals; SF Compute can also run them on real H100s, while bochka gives each eval a full VM with Docker and agents preinstalled. | 10th cheapest of 364 $200 a month | 137th of 364, with limits $720 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month | 4th cheapest of 377 $86 a month | 93rd cheapest of 377 $864 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box you sit in needs SSH and a whole disk that persists, which bochka has; Autoresearch nodes are reached through commands over the API. | 18th cheapest of 368 $26 a month | 264th of 368, with limits $113 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 machine, which bochka streams at 60fps and SF Compute does not offer. | 6th cheapest of 369 $200 a month | 201st of 369, with limits $660 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 | 279th of 367, with limits $720 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 | 274th of 346, with limits $446 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 | 224th of 338, with limits $8,915 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 | 265th of 360, with limits $437 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month SF Compute rents H100 nodes by the minute and larger GPU clusters on its market; bochka has no GPUs. | Can't run it | 42nd of 98, with limits $1,260 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
Every feature Battleships tracks (43)
| Feature | bochka | SF Compute |
|---|---|---|
| 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 | 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 | 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 | No |
| 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 | Yes |
| 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 | Yes |
| Audit logs | No | Yes |
| SSO | No | No |
| SOC 2 | No | Yes |
| HIPAA | No | No |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement: SF Compute was not in the hpc-sandbox-benchmarks CPU run. On that benchmark's Node.js build-and-test loop at 4 vCPU / 8 GB, bochka did 26.69 runs per second.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. SF Compute 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 | SF Compute, 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 · Prepaid credit (pay as you go) · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $118 · Prepaid credit (pay as you go) · 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 | $1,426 · Prepaid credit (pay as you go) · 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 | $810 · Prepaid credit (pay as you go) · 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 | $1,800 · Prepaid credit (pay as you go) · 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.
SF Compute: SF Compute runs on prepaid credit with no plan fee. Sandboxes bill per GiB of RAM per minute while running, with 4 GiB counted per core, and much less for memory handed back while parked; nodes bill per minute through a 15-minute idle window, with Friday and weekend discounts. Market GPU prices are set by the order book.
Limits in those scenarios
The table prices SF Compute on an Autoresearch cpu-2 node, the closest match to a 4 vCPU / 8 GiB machine that keeps a disk. Only its home folder survives a stop, so packages installed elsewhere reset, which is why no scenario fits fully, and SF Compute publishes no price for disk beyond that. Its account limits on how many machines run at once are readable through its API but not published, so the 300 and 1,000 machine scenarios are unconfirmed. bochka keeps every disk, but for 1,000 short jobs at once even the $2,000 plan queues starts above 90 a minute.
| Scenario | bochka | SF Compute |
|---|---|---|
| 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 SF Compute when
the work needs GPUs, from one H100 to a cluster, or you run RL rollouts that fork many copies of one running environment with its memory.
- Real GPUs, from one to a cluster. For training, fine-tuning and GPU evals: H100 nodes by the minute and larger clusters you can resell.
- Memory forks for RL rollouts. For RL and evals that branch from one state: fork up to 256 sandboxes per call with memory and processes intact.
- Hermetic sandboxes and US capacity. A sandbox can have no network device at all, and GPU capacity runs in the US as well as the EU.
Use bochka when
your agents need a whole machine to work in: Docker, emulators, a desktop and a browser, apps they host, coding agents you drive from outside, and a disk that keeps everything.
- A whole machine the agent can build on. On an Autoresearch node only the home folder survives a stop, so installed packages reset, there is no SSH, and Docker inside is not documented, so docker compose test setups have nowhere to run.
- Agents you drive from outside, with keys kept out. SF Compute lets your local agent call its platform over MCP, but nothing runs an agent inside the machine for you, and secrets arrive as environment variables an agent with a shell can read.
- A desktop and hosting in the box. SF Compute machines are headless and reached through commands, so a browser or computer-use agent has no screen to drive, and services that need raw TCP cannot be reached from outside.
Questions people ask
Is bochka cheaper than SF Compute?
For CPU agent work, in four of the five scenarios on this page, yes: one workday coding agent is $20 a month on bochka and $29 on SF Compute. For 1,000 short jobs at once, SF Compute's estimate is $1,800 against $2,000 on bochka, but neither fully fits that scenario. For GPU work there is no comparison, because bochka has no GPUs.
Does SF Compute have GPUs?
Yes, that is its main business. Autoresearch rents H100 nodes with 1 or 8 GPUs by the minute and runs batch GPU jobs, and the SF Compute market sells H100, H200 and B200 nodes. bochka does not offer GPUs.
Can I SSH into an SF Compute machine?
Not on Autoresearch: its docs say there is no SSH, and commands run through MCP, the HTTP API or the autor CLI. SF Compute market VMs do support SSH. Every bochka sandbox has full SSH and SCP.
Can I run Docker in each?
bochka runs Docker inside every sandbox and also exposes /dev/kvm for Android emulators and VMs. SF Compute can import a Docker image as a sandbox's filesystem, but its docs do not mention running Docker inside a sandbox or a node.
Can bochka fork a sandbox with its memory like SF Compute?
No. bochka forks a running sandbox with its disk, and the copy boots fresh. SF Compute sandboxes fork from a snapshot with memory and running processes, up to 256 per call.
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