bochka vs Render
Render is a platform for hosting web apps, databases and background jobs, with a sandbox product in early access. bochka gives each agent its own full VM, with Docker, root, a desktop and coding agents you drive from outside, and a disk that keeps everything when it stops.
Where bochka stands out
A whole machine, not an app container
Each bochka sandbox is a full VM with its own kernel, root, systemd, Docker and /dev/kvm. A Render service runs your image as a container, and its docs do not offer Docker inside it or nested virtualization.
A disk that keeps everything
A bochka sandbox saves its whole disk every minute and when it stops, and a stopped sandbox costs nothing. On Render only the persistent disk's mount path survives a restart or redeploy, and a paid service bills until you suspend it.
Agents, keys and a screen built in
Claude Code, Codex and five other agents come preinstalled, and you prompt, steer and follow them through one API. Real API keys stay outside in a credentials proxy, and every sandbox has a 60fps desktop with Chromium for computer use.
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
Render
Render is a cloud platform for deploying and scaling web apps, APIs, databases, background workers, cron jobs and workflows.
You connect a Git repo or a Docker image and Render builds and runs it as a service, with managed Postgres and Key Value next to it on a private network. Workflows run Python or TypeScript tasks in their own instances with retries and scale to zero, and Render Sandboxes, for running untrusted code, is in early access. It is built for teams shipping apps, not for handing each agent its own machine, so this page compares the parts that overlap.
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 | Render: 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 browser and a disk that keeps every installed package; a Render service only keeps files under its disk's mount path and has no Docker inside. | 3rd cheapest of 367 $634 a month | 256th of 367, with limits $3,817 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on one machine all month fits a Render background worker, but each one bills its full plan around the clock and resets everything outside the disk on restart. | 5th cheapest of 366 $657 a month | 268th of 366, with limits $4,514 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Render fits short code runs better: workflow tasks spin up in seconds, scale to zero and the flex plan bills on CPU actually used. | 186th of 345, with limits $2,000 a month | 86th of 345, with limits $122 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Render Sandboxes are early access in Oregon only at 2 CPU / 4 GB, so a product that gives users their own machines today fits bochka more easily. | Cheapest of 361 $209 a month | 130th of 361, with limits $1,463 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 | 97th of 360, with limits $6,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month Render Sandboxes can snapshot memory and restore it into new sandboxes, which helps evals that branch from one state, but they are early access. | 10th cheapest of 364 $200 a month | 159th of 364, with limits $1,240 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI that builds containers or Android apps needs Docker and /dev/kvm, which bochka has on every machine and Render does not document. | 4th cheapest of 377 $86 a month | 164th of 377, with limits $555 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Render service can run for months, but it is a container built from your repo, so tools you install by hand vanish on the next deploy unless they sit on the disk. | 18th cheapest of 368 $26 a month | 175th of 368, with limits $158 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Render has no desktop or browser product, so a computer-use agent would have to bring its own virtual screen inside a container. | 6th cheapest of 369 $200 a month | 230th of 369, with limits $902 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 | 273rd of 367, with limits $644 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 | 246th of 346, with limits $254 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 | 149th of 338, with limits $4,345 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 | 241st of 360, with limits $327 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 | Render |
|---|---|---|
| What you get | A full VM with its own kernel per sandbox, on dedicated AMD Ryzen 9 9950X hosts | A service that runs your build or Docker image as a container; sandboxes in early access |
| Docker, systemd and nested virtualization | Root, systemd, Docker and /dev/kvm on every machine | Runs a Docker image, but Docker inside the service, systemd and /dev/kvm are not documented |
| What survives a stop | The whole disk, saved every minute and on stop; a stopped sandbox costs nothing | Only files under the persistent disk's mount path; daily disk snapshots kept at least 7 days |
| Stopping when idle | You stop a sandbox by API and its compute stops billing | Paid services never spin down; you suspend or scale them yourself |
| Fork and snapshots | Fork a running sandbox with its disk; named snapshots to start new ones | Sandboxes can snapshot filesystem or memory and CPU state into new sandboxes, kept 3 days; services cannot fork |
| Reaching the machine | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 | One public HTTPS URL per web service with custom domains; SSH; private network between services |
| Coding agents | Claude Code, Codex and five more preinstalled, with a prompt, steer and events API | None inside; an MCP server and agent skills let outside agents manage Render deploys |
| Keeping keys out of the machine | AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out | Environment variables and secret files inside the service |
| Desktop and computer use | 60fps desktop and Chromium, computer use and browser control | Headless services only |
| Outbound rules | Open internet, no provider-side allowlist | Sandboxes can be set to allow-all or deny-all; services have dedicated outbound IP sets on Pro |
| Managed databases and jobs | None; run your own inside a sandbox | Postgres, Key Value, cron jobs and workflows with retries, on one private network |
| Biggest machine | 8 vCPU / 16 GB on the $20 plan, 16 vCPU / 32 GB from $100 | Services up to 12 CPU / 96 GB; sandboxes 2 CPU / 4 GB in early access |
| Regions | EU only: Germany, Finland, France | Oregon, Ohio, Virginia, Frankfurt and Singapore; sandboxes in Oregon only |
| 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 | Render |
|---|---|---|
| Full VM (own kernel) | Yes | No |
| Docker inside | Yes | No |
| Nested virtualization | Yes | No |
| Root | Yes | Not published |
| Systemd | Yes | No |
| Desktop GUI | Yes | No |
| Browser | Yes | No |
| Computer-use API | Yes | No |
| SSH | Yes | Yes |
| 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 | No |
| Wake on request | No | No |
| 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 | 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 | No |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Yes |
| 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. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's public hpc-sandbox-benchmarks, but Render 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. Render 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 | Render, 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 | $57 · Hobby · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $194 · Hobby · 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,374 · Hobby · 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 | $644 · Hobby · 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,205 · Hobby · 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.
Render: Each service has a fixed monthly plan by size, prorated by the second while it runs, plus $0.25 per GB-month for a persistent disk and bandwidth above the plan's allowance. Paid services never spin down, so the meter only stops when you suspend them, and Pro ($25) and Scale ($499) workspace fees are charged on top of compute, not as credit.
Limits in those scenarios
Render is an app platform, so every scenario here is a compromise: each agent becomes a service, a container where only the disk's mount path keeps files and Docker inside is not available. Our bills use the free Hobby workspace, which allows 25 services, so 50 agents, 300 user sandboxes or 1,000 jobs need the Pro workspace or more. Render Sandboxes would fit some of these better but are early access, Oregon only, with no published price. 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 | Render |
|---|---|---|
| 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 Render when
you are hosting a web app with its databases and background jobs, want queued tasks that retry and scale to zero, or need US or Asia regions.
- Your apps and databases in one place. Useful if your product already runs on Render: services, Postgres and Key Value share one private network.
- Durable jobs that scale to zero. Useful for queued background tasks: workflow runs start in seconds, retry on failure and scale to zero when done.
- Regions in the US and Asia. Useful if your users or data are in the US or Asia: Render runs in Oregon, Ohio, Virginia, Frankfurt and Singapore.
Use bochka when
each agent needs its own machine for hours or days: a full VM with Docker, root and a desktop, a disk that keeps everything, and coding agents you drive by API while their keys stay outside.
- A whole machine, not an app container. Agents run docker compose, start databases as services and boot Android emulators. In a Render container those steps have nowhere to run, so the agent stalls on the first build that needs them.
- A disk that keeps everything. An agent installs packages, tools and caches all over the filesystem. On Render those vanish on the next restart unless you move them under the mount path, and the service keeps billing while the agent waits.
- Agents, keys and a screen built in. On Render you build the agent harness yourself, put model keys in environment variables the agent can read, and have no screen for browser or desktop tasks.
Questions people ask
Is bochka cheaper than Render?
In four of the five scenarios on this page, yes: one agent on workdays is $20 on bochka against $57, one agent all month is $26 against $194, and 50 agents in parallel are $317 against $2,374. For 1,000 short jobs at once Render comes to $1,205 against $2,000 on bochka, though it does not fit cleanly either.
Can I run Docker inside a Render service?
Render deploys your service from a Dockerfile or image, but the service itself runs as a container, and Render's docs do not describe running Docker, systemd or /dev/kvm inside it. On bochka every sandbox is a full VM with all three.
What are Render Sandboxes?
An early access product for running untrusted code, enabled for select workspaces. Each sandbox has 2 CPU, 4 GB and 10 GB of disk, runs in Oregon only for up to 24 hours, and can save its filesystem or memory in snapshots that expire after 3 days. Render has not published a price.
Do files survive a restart on Render?
Only under a persistent disk's mount path; the rest of the filesystem is reset on every deploy or restart, and a disk stops the service from scaling past one instance. A bochka sandbox keeps its whole disk, saved every minute and on stop.
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. Render runs in Oregon, Ohio, Virginia, Frankfurt and Singapore.
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. Render's trust page lists SOC 2 Type 2 and ISO 27001.
Start a sandbox
Install the CLI, then run bochka new.
Product preview