bochka vs StarSling
StarSling is a CI service: it runs your GitHub Actions jobs on faster single-use Ubuntu runners and sends AI agents to open PRs that speed up your workflows. bochka gives each agent its own full VM that you start by API, keep as long as you like and reach from outside.
Where bochka stands out
A machine that stays
A bochka sandbox runs until you stop it, with no session cap on paid plans. Its whole disk is saved every minute and on stop, a stopped sandbox costs nothing, and you can fork a running one. On StarSling each machine is destroyed when its job ends, and nothing on its disk is kept.
Reach in: hosting and a desktop
bochka gives each sandbox HTTPS URLs on up to 50 ports and raw TCP, so an agent can run an app and you can open it. It also streams a 60fps Linux desktop with Chromium for computer use.
Agents you drive from outside, keys kept out
Claude Code, Codex, OpenCode and other agents come preinstalled, and you prompt, steer and follow them through one API from your own backend. 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
StarSling
StarSling is AI-native CI for GitHub Actions: drop-in Ubuntu runners plus agents that open PRs to make your workflows faster.
You install the StarSling GitHub App and change the runs-on label in your workflow, and each job runs on a fresh single-use machine that is destroyed when the job ends. Its CPU runners go from 2 to 64 vCPU on 5th Gen AMD EPYC, GPU runners on NVIDIA cards are in private beta, and Review Runners run your own code review agents as Actions jobs. It is built for teams that want faster, cheaper GitHub Actions, not as a sandbox you create and drive by API.
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 | StarSling: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Agents that build and run whole apps need hosting, a kept disk and forks, which bochka has; StarSling runs only the CI part of that loop. | 3rd cheapest of 367 $634 a month | 228th of 367, with limits $2,895 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 disk that survives and a way to reach it, and a CI job that ends after at most 6 hours has neither. | 5th cheapest of 366 $657 a month | 326th of 366, with limits $8,760 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month | 186th of 345, with limits $2,000 a month | 297th of 345, with limits $800 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 sandbox means starting machines from your own backend, which bochka does by API and StarSling does only through GitHub workflows. | Cheapest of 361 $209 a month | 295th of 361, with limits $2,520 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 | 292nd of 360, with limits $12,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month Short eval runs can be Actions jobs on StarSling, but each one starts clean, so bochka's forks of a set-up sandbox save the setup every time. | 10th cheapest of 364 $200 a month | 279th of 364, with limits $960 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both fit; StarSling is the easy pick if your CI already lives in GitHub Actions, while bochka fits CI you start by API or that needs a machine to stay up. | 4th cheapest of 377 $86 a month | 109th cheapest of 377 $1,152 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box has to keep its files and stay reachable, but a StarSling machine is destroyed with everything on it when its job ends. | 18th cheapest of 368 $26 a month | 284th of 368, with limits $175 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 screen to look at; bochka streams a 60fps Linux desktop, and StarSling runners are headless. | 6th cheapest of 369 $200 a month | 227th of 369, with limits $880 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 | 305th of 367, with limits $960 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 | 316th of 346, with limits $1,170 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 | 294th of 338, with limits $23,400 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 | 288th of 360, with limits $580 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month StarSling has NVIDIA GPU runners in private beta for GitHub Actions jobs, and bochka has no GPUs. | 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 | StarSling |
|---|---|---|
| What it is | A full VM per agent that you create, stop and start by API | GitHub Actions runners; each machine lives for one workflow job |
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Single-use microVM, or a privileged container on its own dedicated EC2 instance |
| How a machine starts | One API call, SDK or CLI, from anywhere | A GitHub Actions job with a StarSling runs-on label |
| How long it lives | Until you stop it; no session cap on paid plans | Until the job ends, at most GitHub's 6 hour job limit |
| What survives a stop | The whole disk, saved every minute and on stop; a stopped sandbox costs nothing | Nothing; the filesystem is destroyed with the machine, and caching goes through GitHub's actions/cache |
| Fork | Fork a running sandbox with its disk | No; every job starts on a fresh machine |
| Docker and nested virtualization | Docker, root, systemd and /dev/kvm on every machine | Docker builds as normal CI steps; no /dev/kvm documented |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP | No ports, URLs or SSH; Tailscale lets jobs reach your private network outward |
| Desktop and computer use | 60fps Linux desktop with Chromium and computer use | Headless runners |
| Coding agents | Claude Code, Codex, OpenCode and other agents preinstalled, with a prompt, steer and events API | Its own agents open CI optimization PRs; Review Runners run your code review agents as Actions jobs (early access) |
| Keeping API keys out of the machine | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out | GitHub secrets go to the runner and sit in memory and on disk while the job runs |
| GPUs | None | NVIDIA RTX PRO 6000, RTX 5090 and RTX 4090 runners, billed per minute (private beta) |
| Biggest machine | Up to 16 vCPU / 32 GB on the $100 plan and above | Up to 64 vCPU / 256 GB |
| Regions | EU only (Germany, Finland, France) | Runners in multiple regions; control plane and logs in the US; pin a region on request |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | No SOC 2 report published |
Every feature Battleships tracks (43)
| Feature | bochka | StarSling |
|---|---|---|
| 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 | 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 | Not published |
| ≥24 h sessions | Yes | No |
| Idle auto-stop | No | Yes |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | No |
| 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 | Not published |
| Usage per sandbox (API) | Yes | Yes |
| Audit logs | No | Not published |
| SSO | No | Yes |
| SOC 2 | No | No |
| HIPAA | No | No |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement for StarSling's own runners. StarSling publishes the hpc-sandbox-benchmarks where bochka did 26.69 runs per second on the Node.js loop at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts, but its own runners were not part of that run. StarSling points to RunsOn's GitHub Actions benchmark instead, which uses different tests and machines, so the numbers cannot be set side by side.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. StarSling 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 | StarSling, 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 | $76 · Usage · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $350 · Usage · 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 | $3,802 · Usage · 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 | $1,080 · Usage · 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 | $2,400 · Usage · 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.
StarSling: StarSling bills per minute of job time, with a one minute minimum, no seat fees and no charge for queue time: from $0.004 a minute for 2 vCPU / 8 GB to $0.128 for 64 vCPU / 256 GB. New accounts get 2,000 free minutes in the first month, and the estimates here use its 4 vCPU / 16 GB CPU runner at $0.008 a minute, not the $0.004 Review Runner meant for code review jobs.
Limits in those scenarios
None of these scenarios fit StarSling cleanly, because it is a CI runner: a machine exists only while a GitHub Actions job runs, a job stops at 6 hours, and nothing on the disk survives. An agent that should run all day has to be restarted as new jobs and set up again each time. StarSling advertises unlimited concurrency but publishes no number, so 300 or 1,000 machines at once are not confirmed. For the 1,000 short jobs at once, bochka's $2,000 plan queues starts above 90 per minute and allows fewer starts per day than the burst needs.
| Scenario | bochka | StarSling |
|---|---|---|
| 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 StarSling when
you want your GitHub Actions jobs to run faster by changing one label and get PRs that tune your workflows, or need GPU runners in CI.
- Faster GitHub Actions with one label. If your CI already lives in GitHub Actions, you switch by changing one runner label, and its agents open PRs that make the workflows faster.
- GPU runners for CI. Teams that test models or GPU code in CI can run those jobs on NVIDIA RTX PRO 6000, RTX 5090 or RTX 4090 runners.
- Bigger machines and other regions. It offers runners up to 64 vCPU and 256 GB, with runner compute spread over several regions.
Use bochka when
your agents need their own machine outside CI: one you start by API, that keeps its disk, hosts what it builds, shows a desktop and runs coding agents you drive from outside.
- A machine that stays. An agent that installs tools, clones repos and builds up state loses all of it when a StarSling job ends, and a job stops at GitHub's 6 hour limit, so every run starts by setting the machine up again.
- Reach in: hosting and a desktop. A StarSling runner has no ports, URLs or SSH, and its Tailscale link only lets the job reach out, so you cannot preview what an agent built or give a computer-use agent a screen.
- Agents you drive from outside, keys kept out. On StarSling an agent runs only as a GitHub Actions step, so you would build the start, prompt and stream loop yourself on top of workflows, with real keys sitting in the runner's memory and disk.
Questions people ask
Is bochka cheaper than StarSling?
For agent work, yes in the scenarios on this page, for example $26 against $350 a month for one always-on machine and $317 against $3,802 a month for 50 agents in parallel. For 1,000 short jobs at once, neither fits cleanly, and the estimates are $2,000 against $2,400 a month. For plain GitHub Actions CI, StarSling is built for it and bills per minute of job time.
Can I run an AI agent on StarSling?
Only as a step in a GitHub Actions job. Its Review Runners, in early access, run your own code review agents that way, with your model key. Its own agents work on StarSling's side and open PRs to speed up your CI; there is no API to start a machine and drive an agent inside it.
Does StarSling keep files between runs?
No. Each machine is single-use and destroyed when the job ends, with its filesystem; caching goes through GitHub's actions/cache. bochka saves a sandbox's whole disk every minute and when it stops.
Can bochka run my GitHub Actions jobs?
A bochka sandbox is a full Linux VM with root, so you can install the GitHub Actions self-hosted runner on it and keep caches on its disk. StarSling does that work for you as a managed drop-in and adds optimization PRs.
Did StarSling benchmark bochka?
Yes. StarSling runs the public hpc-sandbox-benchmarks, and in its run bochka led the Node.js Web Tooling test at 26.69 runs per second and had the fastest Better Auth workflow. StarSling's own runners were not in that run.
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