bochka vs Specific
Specific is an app platform: your coding agent writes one config file and Specific runs the services, Postgres, storage and workflows it describes. bochka is where the agent itself works, a full VM with root, Docker and a desktop, with coding agents built in that you drive from outside.
Where bochka stands out
A full VM, not a service container
Every bochka sandbox has its own kernel, with root, systemd, Docker and /dev/kvm ready, and you can SSH in. On Specific your code runs as a container built from a base image or your Dockerfile, made to serve one app, with no shell to log into.
The agent runs inside, driven from outside
bochka ships Claude Code, Codex, OpenCode and other agents in each sandbox, and your app can start one, steer it mid-task and stream its events through an API. On Specific the agent runs on your laptop or your own server and calls the CLI.
A desktop and a disk that stays
Each bochka sandbox streams a 60fps desktop with Chromium and computer use. Its whole disk is saved every minute and on stop, and you can fork a running sandbox to try two paths at once.
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
Specific
Specific is a cloud platform for deploying apps that coding agents build, from a single config file.
Your agent writes the app and a specific.hcl file that declares services, Postgres, object storage, Redis and Temporal workflows. Specific runs it all locally with specific dev and deploys it with specific deploy, where services run as containers built from a managed base or your Dockerfile. It is built for teams that let Claude Code, Cursor or Codex ship and run production apps, not for running the agents themselves.
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 | Specific: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Specific is a good home for the apps a software factory ships, but the agents doing the work need a machine with a shell, Docker and a disk, which is what bochka gives each one. | 3rd cheapest of 367 $634 a month | 272nd of 367, with limits $4,551 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant on Specific would be a long-running service container with no shell or desktop; on bochka it gets its own VM that keeps its disk. | 5th cheapest of 366 $657 a month | 269th of 366, with limits $4,539 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Neither is a clean fit: Specific deploys services from config rather than starting a fresh sandbox per run, and bochka's start limits make big bursts a compromise. | 186th of 345, with limits $2,000 a month | 218th of 345, with limits $89 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Specific has no API for giving each of your users a machine of their own; bochka starts one VM per user with HTTPS on up to 50 ports. | Cheapest of 361 $209 a month | 262nd of 361, with limits $1,446 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 | 270th of 360, with limits $6,107 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 | 287th of 364, with limits $1,225 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that build images need Docker inside the machine, which bochka has on every VM and Specific's service containers do not offer. | 4th cheapest of 377 $86 a month | 307th of 377, with limits $782 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Specific has no SSH or interactive machine, so a dev box means bochka, or Specific's local specific dev on your own computer. | 18th cheapest of 368 $26 a month | 289th of 368, with limits $187 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Specific has no desktop or browser product; bochka streams a 60fps desktop with Chromium and computer use from every VM. | 6th cheapest of 369 $200 a month | 259th of 369, with limits $1,248 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 | 272nd of 367, with limits $637 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 | 216th of 346, with limits $175 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 | 112th of 338, with limits $3,053 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 | 238th of 360, with limits $319 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 | Specific |
|---|---|---|
| Kind of product | Sandboxes: full VMs where agents and their tools run | App platform: deploys the services, databases and workflows an agent defines in one config file |
| Isolation | Every sandbox is a full VM with its own kernel | Each service runs as a container built from a managed base or your Dockerfile |
| Docker and nested virtualization | Docker, root, systemd and /dev/kvm on every machine | Docker is used to build the service image; no docs for Docker or /dev/kvm inside a running service |
| Getting a shell | SSH and a terminal into any sandbox, plus exec from the API | No SSH; one-off jobs run a command with a service's environment and stream logs |
| Files over time | The whole disk persists, with snapshots every minute and on stop; a stopped sandbox costs nothing | Volumes you declare persist across deploys and restarts; no snapshots |
| Copies and forks | Fork a running sandbox, disk included | Preview environments branch Postgres and clone volumes copy-on-write, per pull request or by hand |
| Coding agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | Your agent runs on your own machine and drives Specific through its CLI; a docs MCP server helps it |
| Keeping keys out of the machine | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out | Secrets are stored per environment and injected into services as environment variables |
| Desktop and computer use | 60fps desktop and Chromium, computer use and browser control, embeddable stream | None; services are headless web apps, workers and cron jobs |
| Reaching what runs inside | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 | Public HTTPS on *.spcf.app or your own domain, several endpoints per service, internal-only endpoints |
| Managed databases and workflows | None; run your own inside a sandbox | Managed Postgres with zero-downtime migrations, Redis, Temporal workflows and S3-compatible storage |
| Scaling an app | One VM per sandbox, resized by you; no load-balanced replicas | Horizontal auto-scaling of services and database, rolling deploys behind health checks |
| Regions | EU only: Germany, Finland, France | EU only: one AWS region in Frankfurt |
| Your own cloud | Hosted by bochka only | Bring your own cloud or on-prem on Enterprise |
| 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 | Specific |
|---|---|---|
| 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 | No |
| 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 | Yes |
| Raw TCP inbound | Yes | Not published |
| Public IPv4 | No | No |
| Egress allowlist | No | Not published |
| 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 | No |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | Yes |
| BYOC | No | Yes |
| Open source | No | No |
| Scoped API keys | Yes | Yes |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Not published |
| SSO | No | Yes |
| SOC 2 | No | No |
| HIPAA | No | No |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
Performance
There is no comparable measurement. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's public benchmark, but Specific is an app platform and has no result in that benchmark, so we cannot say which is faster.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Specific 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 | Specific, 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 | $52 · Pro · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $187 · Pro · 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 | $2,271 · Pro · 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 | $637 · Pro · 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,225 · Pro · 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.
Specific: Specific bills each running service per hour by size, from Tiny (0.25 vCPU) to 2XL (8 vCPU / 32 GB), plus volume storage per GB-month and egress per GB. Pro is $25 a month and Scale $299, each paid back as the same amount of usage credit, and Postgres, workflows and object storage bill on their own meters on top.
Limits in those scenarios
Specific does not fit any of the five scenarios cleanly because it hosts apps, not machines for agents, so its bills here are the closest service size running for the same hours. It does not publish how many services can run at once, which matters for 300 sandboxes for your users or 1,000 jobs at once, and its service containers have no Docker inside for the 50-agent fleet. On bochka, the 1,000-job burst is queued above 90 starts a minute and needs more starts per day than the $2,000 plan allows.
| Scenario | bochka | Specific |
|---|---|---|
| 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 Specific when
you want the app your coding agent built to run in production, with Postgres, workflows, storage and preview environments from one config file.
- A full backend from one config file. Useful if you want the app your agent wrote in production: Specific runs services, Postgres, Redis, workflows and storage together.
- Preview environments with real data. Useful for testing a pull request against real data: each preview branches the database and clones volumes copy-on-write.
- Your own cloud or on-prem. Useful if your apps must run inside your own cloud account or data center: Specific Enterprise offers both.
Use bochka when
you need somewhere for the agents themselves to work: a full VM with root, Docker and a desktop, with coding agents built in that you drive by API while their keys stay outside.
- A full VM, not a service container. An agent installs packages, runs docker compose, starts databases and boots emulators while it works. A service container that runs one command and has no shell gives it nowhere to do that.
- The agent runs inside, driven from outside. Running many agents on Specific means finding and managing their machines yourself. On bochka, its credentials proxy keeps each agent's real keys outside, where Specific puts secrets in environment variables code can read.
- A desktop and a disk that stays. Specific has no screen, so an agent cannot test a web app in a real browser there. Its volumes keep only the folders you declare, with no snapshots to roll back a bad step.
Questions people ask
Is bochka cheaper than Specific?
For agent work, yes in four of the five scenarios we priced: one coding agent on workdays comes to $20 a month on bochka and $52 on Specific, one agent running all month to $26 versus $187, and 50 agents in parallel to $317 versus $2,271. For 1,000 short jobs at once Specific is lower, $1,225 against $2,000, but it is not a sandbox and neither fits that burst cleanly.
Is Specific a sandbox for AI agents?
No. Specific is a platform for deploying the apps that coding agents write: services, Postgres, Redis, workflows and storage, all from one config file. The agent itself runs on your machine and uses Specific's CLI. bochka is the machine the agent runs on.
Can I run Docker or get a shell on Specific?
Specific uses your Dockerfile to build a service image, then runs it as a container; its docs describe no Docker inside a running service and no SSH. You can run one-off jobs with a service's environment. Every bochka sandbox has Docker, root and SSH.
Can I use bochka and Specific together?
Yes. A coding agent can work inside a bochka sandbox, install Specific's CLI there, test the app with specific dev, and deploy it with specific deploy. Specific's docs say its CLI runs fully headless for agents on remote machines.
Where does my data run?
Both stay in the EU. bochka runs in Germany, Finland and France, with EU data residency and a zero data retention option. Specific runs every deployment in one AWS region in Frankfurt, and offers your own cloud or on-prem on Enterprise.
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