bochka vs Solari
Solari sells microVM sandboxes, desktops and stealth cloud browsers from one API, with sessions capped by plan. bochka gives each agent a full VM with Docker, root and /dev/kvm, a disk that stays, and coding agents built in, with no session cap on paid plans.
Where bochka stands out
No session cap, and a disk that stays
On bochka's paid plans a sandbox runs as long as you want, and its disk stays between runs, with snapshots every minute and a stop that costs nothing. Solari stops sessions after 1, 5 or 24 hours depending on the plan, and only Enterprise is unlimited. Its files live on through pause, snapshots or beta volumes, not a plain disk.
A whole Linux machine, documented
Every bochka sandbox has root, systemd, Docker and /dev/kvm ready, so agents can run compose stacks, services and Android emulators. Solari's default sandbox is also a microVM of your own, but its docs do not cover Docker, root or nested virtualization, and the size stops at 8 vCPU and 16 GB.
Coding agents you drive from outside
bochka ships Claude Code, Codex, OpenCode and other agents in each sandbox, and you drive agents inside from outside with a prompt, steer and events API. Its credentials proxy keeps real AI keys out of the sandbox and can switch to another account when one runs out of credits. Solari gives your agent an MCP server and SDKs, but no agent comes installed.
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
Solari
Solari is cloud infrastructure for agents: stealth Chrome browsers, Linux desktops and code sandboxes behind one API key.
A Solari sandbox is a microVM of your own by default, with no screen, that you drive through TypeScript or Python SDKs, an API or an MCP server. Desktops are Ubuntu VMs with a live screen you can watch and take over, and cloud browsers are a separate product with stealth mode, captcha solving and proxies. It is built for teams whose agents browse, use computers and run code in short sessions.
- Regions
- One region: US West (Oregon)
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 | Solari: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month bochka fits fully: agents build and test for hours on a disk that stays, while Solari's sessions stop at 24 hours on Professional and only 10 machines run at once. | 3rd cheapest of 367 $634 a month | 177th of 367, with limits $1,937 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that never stops needs no session cap and a lasting disk, which bochka has on every paid plan; Solari needs Enterprise for unlimited sessions. | 5th cheapest of 366 $657 a month | 218th of 366, with limits $2,505 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Solari ranks higher here: short code runs suit its per-second rates and fast pause, while bochka's start limits make big bursts a compromise. | 186th of 345, with limits $2,000 a month | 107th of 345, with limits $187 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month 300 users at once is far above Solari's 10 concurrent sandboxes on Professional, so it needs an Enterprise deal; bochka's $100 plan allows 300. | Cheapest of 361 $209 a month | 90th of 361, with limits $826 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 | 68th of 360, with limits $3,968 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 | 130th of 364, with limits $638 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 | 157th of 377, with limits $383 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 273rd of 368, with limits $143 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both have a Linux desktop you can watch and control; bochka streams it at 60fps and you can embed it, and Solari adds $0.02 an hour for the live screen. | 6th cheapest of 369 $200 a month | 48th of 369, with limits $575 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month Solari's separate cloud browsers bring stealth mode, captcha solving and proxies, which helps on sites that block bots; bochka runs Chromium inside your own VM. | 7th cheapest of 367 $200 a month | 68th of 367, with limits $287 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month For sites that fight bots, Solari's stealth browsers and residential proxies do work bochka leaves to you; for scrapers that also need code, Docker and a disk, bochka fits better. | 6th cheapest of 346 $90 a month | 90th of 346, with limits $200 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 | 133rd of 338, with limits $3,890 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month Both come out at the same monthly amount, but bochka runs many more machines at once and gives each one root and /dev/kvm. | 2nd cheapest of 360 $200 a month | 24th of 360, with limits $200 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 | Solari |
|---|---|---|
| Isolation | Every sandbox is a full VM with its own kernel | A microVM per sandbox by default; shared mode is a process tree in a shared VM |
| Docker, root and nested virtualization | Docker, root, systemd and /dev/kvm on every machine | apt-get works in templates; Docker, root and /dev/kvm are not documented |
| Session length | No cap on paid plans; 2 hours on the trial | 1 hour (Free), 5 hours (Starter), 24 hours (Professional), unlimited on Enterprise |
| Machines at once | 100 on the $20 plan, up to 2,000 on the $2,000 plan | 1, 2 or 10 sandboxes by plan; 50 and up on Enterprise |
| Files after a stop | A disk that stays, snapshots every minute and on stop; a stopped sandbox costs nothing | Pause saves the whole machine; kill shuts it down; volumes are in beta and not on desktops yet |
| Snapshots and fork | Fork a running sandbox; resume reboots from disk (no memory snapshots) | Snapshots keep memory and disk while the machine runs; fork any number of copies or revert in place |
| Desktop and computer use | 60fps desktop and Chromium, computer use and browser control, embeddable stream | Ubuntu desktop with a live view to watch and take over, mouse and keyboard input, screenshots; $0.02 an hour extra |
| Managed cloud browsers | Chromium inside your own sandbox; no separate browser product | Cloud browsers with stealth mode, captcha solving and residential, ISP or mobile proxies |
| Reaching the sandbox | HTTPS URLs for up to 50 ports, token-protected; raw TCP; SSH; its own IP | Signed preview URL per port with a one-hour token, or opened with no token; no SSH, no public IP |
| Outbound internet | Open internet on every plan; no provider-side allowlist | Open internet, or hardened mode with all outbound blocked |
| Coding agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | None preinstalled; an MCP server lets your agent drive sandboxes, desktops and browsers |
| Keeping keys out of the sandbox | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out | Git credentials are passed per call; other keys go in as environment variables |
| Regions | EU only: Germany, Finland, France | One US region: US West (Oregon) |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | Not published |
Every feature Battleships tracks (43)
| Feature | bochka | Solari |
|---|---|---|
| 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 | Yes |
| Browser | Yes | Yes |
| Computer-use API | Yes | Yes |
| SSH | Yes | No |
| Persistent disk | Yes | No |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| 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 | 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 | 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 | No |
| SOC 2 | No | Not published |
| HIPAA | No | Yes |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement for Solari: it was not in StarSling's public hpc-sandbox-benchmarks run. In that run of 2026-09-29, bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X (Zen 5) hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Solari 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 | Solari, 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 | Can't run it |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | Can't run it |
| 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 | Can't run it |
| 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 | $359 · Professional · 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 | $794 · Professional · with limits |
bochka: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Solari: Solari charges a monthly plan fee that comes back as credit, then bills sandboxes per vCPU-hour and per GB-hour, with lower rates on higher plans and $0.02 an hour more for a desktop's live screen. Snapshots above 10 GB cost $0.05 per GB-month from October 2026, and when credit runs out new machines stop launching instead of running up overage.
Limits in those scenarios
Solari's tightest limit is how many machines run at once: 1, 2 or 10 by plan, and 50 or more only on Enterprise. That is why 300 sandboxes for your users and 1,000 short jobs at once do not fit its Professional plan, and why 50 agents in parallel and an agent that never stops (past the 24-hour session cap) have no self-serve price there; disk above the 4 GB included has no published price either. On bochka, 1,000 short jobs at once also does not fit: starts above 90 a minute are queued, and the job needs more starts a day than the $2,000 plan allows.
| Scenario | bochka | Solari |
|---|---|---|
| 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 Solari when
your agents mostly browse sites that block bots, need memory snapshots to pause and rewind, or must run in the US.
- Memory snapshots, revert and fork. Useful if your agent must come back with its memory: Solari snapshots a running machine with memory and disk, then forks or rewinds it.
- Stealth browsers with captcha solving. Useful for agents on sites that block bots: Solari's cloud browsers add stealth mode, captcha solving and residential proxies.
- A US region and an MCP server. Useful if your users are in the US or your agent speaks MCP: Solari runs in US West and ships a hosted MCP server.
Use bochka when
your agents do long, real work: hours of installs, builds and tests on a full VM with Docker and /dev/kvm, a disk that stays, many machines at once, and coding agents built in.
- No session cap, and a disk that stays. A coding agent that builds for a day, or an assistant that stays on all week, gets cut off at Solari's 24-hour Professional limit. The workaround is Enterprise or pausing and resuming around the cap yourself.
- A whole Linux machine, documented. Agents that run Docker builds, databases as services or emulators need these to work on day one. On Solari you would have to test each one yourself before you depend on it.
- Coding agents you drive from outside. On Solari you install the agent, pass it your real keys as environment variables, and write the code that starts and watches it. An agent that reads its own environment can then leak those keys.
Questions people ask
Is bochka cheaper than Solari?
For 300 sandboxes for your users it comes to $200 a month on bochka against $359 on Solari, and Solari's Professional plan only runs 10 at once. For 1,000 short jobs at once, Solari comes to $794 against $2,000 on bochka, but neither fits without higher limits. For one coding agent, one agent that never stops, or 50 in parallel, Solari has no self-serve plan we could price.
How long can a Solari sandbox run?
One hour on Free, 5 hours on Starter, 24 hours on Professional and unlimited on Enterprise. An idle sandbox pauses after 30 minutes by default and resumes when you connect again. On bochka's paid plans a sandbox has no session cap.
Can I run Docker in a Solari sandbox?
Solari's docs do not say. Its default sandbox is a microVM of your own and its templates install packages with apt-get, but Docker, root and /dev/kvm are not documented. On bochka, Docker, root, systemd and /dev/kvm are ready on every machine.
Does bochka have stealth browsers like Solari?
No. bochka runs Chromium inside your sandbox, with a 60fps desktop and computer use, but it has no managed stealth browser, captcha solving or proxy service. If your agents mostly fight bot checks, Solari's cloud browsers are made for that.
Where does my data run?
bochka runs only in the EU (Germany, Finland and France), with EU data residency and a zero data retention option. Solari runs in one region, US West (Oregon).
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. Solari's pricing page lists HIPAA compliance on its Enterprise plan.
Start a sandbox
Install the CLI, then run bochka new.
Product preview