bochka vs Red Hat OpenShift
OpenShift is Red Hat's Kubernetes platform for running apps on a cluster you own or rent, and tools like Harbor run agent tasks on it as pods. bochka gives each agent a whole Linux machine with Docker, a disk that keeps everything and coding agents ready to drive.
Where bochka stands out
A whole machine, not a locked-down pod
A bochka sandbox is a full VM with root, Docker, systemd, SSH and /dev/kvm. In Harbor's OpenShift setup each task is a pod under a custom SCC that forbids privileged containers and drops every Linux capability before adding a few back, so there is no Docker daemon and no /dev/kvm inside.
The disk stays, with snapshots and fork
bochka saves the whole disk every minute and when a sandbox stops, a stopped sandbox costs nothing, and you can fork a running sandbox with its disk. On OpenShift only data on a mounted PVC outlives the pod, and Harbor's pod mounts none by default.
Built for agents, not apps
Claude Code, Codex and other agents come preinstalled, and you prompt, steer and follow them from outside through one API. Real API keys stay outside the sandbox in a credentials proxy, and each sandbox streams a 60fps desktop with Chromium and gets HTTPS URLs on up to 50 ports.
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
Red Hat OpenShift
Red Hat OpenShift is a Kubernetes application platform from Red Hat, a company founded in 1993 and part of IBM since 2019.
OpenShift is not a sandbox product. It is a platform for building and running containers on a cluster, either self-managed on your own machines or managed by Red Hat and its partners on AWS, Azure, Google Cloud and IBM Cloud. The Harbor eval framework runs each agent task on it as a single non-privileged pod driven with oc exec, and that is where it overlaps with bochka.
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 | Red Hat OpenShift: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent that runs docker compose or builds images cannot do it in a Harbor pod under a non-privileged SCC; bochka runs Docker inside every sandbox. | 3rd cheapest of 367 $634 a month | 234th of 367, with limits $3,010 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month needs packages and files to survive restarts; on OpenShift only mounted volumes (PVCs) survive, while bochka keeps the whole disk. | 5th cheapest of 366 $657 a month | 239th of 366, with limits $3,121 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code runs suit OpenShift if you already pay for a cluster with spare worker nodes, since a pod starts on capacity you already have. | 186th of 345, with limits $2,000 a month | 94th of 345, with limits $143 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month On OpenShift the number of user sandboxes at once is set by the size of your own cluster; bochka gives every sandbox HTTPS URLs on up to 50 ports with no Routes to set up. | Cheapest of 361 $209 a month | 107th of 361, with limits $994 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 | 74th of 360, with limits $4,275 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 | 142nd of 364, with limits $855 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month CI jobs that build container images or Android apps need Docker or /dev/kvm; ordinary OpenShift pods have neither, while OpenShift Pipelines builds images its own way. | 4th cheapest of 377 $86 a month | 158th of 377, with limits $410 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box wants SSH and a disk that keeps installed packages; OpenShift gives oc rsh into a pod and keeps only what sits on a PVC. | 18th cheapest of 368 $26 a month | 270th of 368, with limits $125 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month OpenShift pods are headless; bochka streams a full Linux desktop at 60fps with Chromium for computer-use agents. | 6th cheapest of 369 $200 a month | 225th of 369, with limits $855 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 | 248th of 367, with limits $428 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 | 233rd of 346, with limits $214 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 | 146th of 338, with limits $4,275 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 | 205th of 360, with limits $214 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Neither is ranked here, but OpenShift does run GPU nodes through the NVIDIA and AMD GPU Operators, 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 | Red Hat OpenShift |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | CRI-O containers sharing the worker node's kernel; sandboxed containers as an optional add-on |
| Docker, systemd and root | Root, Docker and systemd inside every sandbox | Root is possible under a custom SCC, but no privileged containers, so no Docker daemon inside the pod |
| Nested virtualization | Yes, /dev/kvm for Android emulators and VMs | Not in ordinary pods; /dev/kvm goes to OpenShift Virtualization's own VM launcher pods |
| Shell access | SSH into any sandbox | oc exec and oc rsh through the Kubernetes API; no SSH daemon in the pod |
| What survives a stop | The whole disk, saved every minute and on stop; a stopped sandbox costs nothing | Only mounted volumes (PVCs); the container filesystem goes away with the pod |
| Snapshots and fork | Automatic snapshots every minute; fork a running sandbox with its disk | On-demand CSI snapshots of PVCs only; no fork of a running pod |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv6 or IPv4 | Routes through the cluster's HAProxy router for HTTP and HTTPS, with IP allowlists; pods get no public IP of their own |
| Network controls | Open internet, no provider-side allowlist | Egress firewall by IP range, DNS name or port, plus NetworkPolicy rules per pod, set by the cluster admin |
| Keeping API keys out of the sandbox | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out | Secrets mounted into the pod as files or environment variables |
| Coding agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | None from Red Hat; Harbor brings its own harness and runs it with oc exec |
| Desktop and browser | Full Linux desktop streamed at 60fps, with Chromium and computer use | Headless pods only |
| GPUs | None | GPU worker nodes through the NVIDIA GPU Operator and AMD GPU Operator |
| Operating systems | Linux on x86_64 | Linux on x86_64, ARM64 and more, and Windows Server containers on Windows nodes |
| Where it runs | EU only (Germany, Finland, France), managed by bochka | Your own data centers, or managed on AWS, Azure, Google Cloud and IBM Cloud in regions worldwide |
| 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 | Red Hat OpenShift |
|---|---|---|
| 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 | 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 | 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 | Yes |
| 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 | Yes |
| Arm64 | No | Yes |
| Self-hosting | No | Yes |
| BYOC | No | Yes |
| Open source | No | Yes |
| Scoped API keys | Yes | Not published |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Not published |
| 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: OpenShift was not part of the hpc-sandbox-benchmarks run. bochka did 26.69 runs per second on its Node.js build-and-test loop at 4 vCPU / 8 GB. On OpenShift the speed depends on the worker nodes you pick and how busy they are, so a fair comparison would need a run on your own cluster.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Red Hat OpenShift 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 | Red Hat OpenShift, 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 | $30 · OpenShift Dedicated · with limits |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $125 · OpenShift Dedicated · 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,505 · OpenShift Dedicated · 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 | $428 · OpenShift Dedicated · 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 | $855 · OpenShift Dedicated · 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.
Red Hat OpenShift: The table uses Red Hat's OpenShift Dedicated rate of $0.171 per 4 vCPU-hour, which Red Hat says is for illustration because customers are billed annually for at least a minimum worker node setup; 1- and 3-year terms cut it to $0.114 and $0.076. The cloud machines, disks and network underneath are billed on top by the cloud provider, and the free Developer Sandbox is a 30-day trial, not a way to run agents.
Limits in those scenarios
None of the scenarios fit OpenShift cleanly because it is a platform you size yourself, not a sandbox service: how many pods run at once depends on the worker nodes you pay for, and disk and egress prices come from your cloud. The agent fleet also needs Docker inside each machine, which a non-privileged pod does not have. On the OpenShift Dedicated rate the table uses, pods run until you delete them, so the always-on agent has no session cap; only the free Developer Sandbox deletes pods after 12 hours. bochka's start limits bite at 1,000 short jobs at once: the $2000 plan queues starts above 90 per minute and runs out of daily starts.
| Scenario | bochka | Red Hat OpenShift |
|---|---|---|
| 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 Red Hat OpenShift when
you already run it, or must keep workloads in your own data center or a non-EU cloud, and your agent tasks fit in headless pods without Docker, or need GPUs or Windows containers next to them.
- It runs where you choose. Teams that must keep workloads in their own data center, or in a cloud region outside the EU, can run OpenShift there.
- GPUs, Windows and more CPU types. Workloads that need GPU nodes, Windows Server containers or ARM64 machines can share one OpenShift cluster.
- Network rules and a growing agent sandbox. Cluster admins can limit each project's outbound traffic by DNS name, IP range or port, and Red Hat is previewing an agent sandbox.
Use bochka when
your agents do real work on a machine for hours: Docker, builds, tests, emulators and a browser, with a disk that keeps everything, URLs you can open and agents you drive from outside, with no cluster to run.
- A whole machine, not a locked-down pod. Coding agents reach for docker build, docker compose and Android emulators all the time, and those fail in the pod. The workaround is a privileged SCC from a cluster admin, which gives code an agent wrote more power over a node shared with other pods.
- The disk stays, with snapshots and fork. Without it, every new pod repeats the clone, the installs and the build. On OpenShift you can put work on a PVC and snapshot it, but packages installed elsewhere still reset, and there is no fork of a running pod.
- Built for agents, not apps. On OpenShift you build the harness, the Routes and the key handling yourself, and Secrets arrive as files or environment variables inside the pod the agent controls, where one prompt injection can read them.
Questions people ask
Is bochka cheaper than Red Hat OpenShift?
In four of the five scenarios on this page, yes, even before you add the cloud machines OpenShift runs on: one agent all month is $26 on bochka against $125 for the OpenShift subscription alone. For 1,000 short jobs at once OpenShift comes out lower, at $855 against $2,000, if your cluster has room for them.
Can I run Docker inside an OpenShift pod?
Not under the default restricted SCC or Harbor's own SCC, which forbid privileged containers. A cluster admin can grant a privileged SCC, or you can build images with OpenShift's own build strategies instead. bochka runs Docker inside every sandbox, along with systemd and /dev/kvm.
Does OpenShift have a sandbox for AI agents?
Red Hat lists a Red Hat build of Agent Sandbox as a Technology Preview in OpenShift sandboxed containers 1.13, with sandbox templates, claims and warm pools you install as an Operator on your cluster. Tools like Harbor instead run agent tasks as plain pods. bochka is a managed service where each agent gets a full VM with coding agents included.
Can I use the free Developer Sandbox for agents?
It is meant for trying Red Hat products: it lasts 30 days, runs on a shared cluster, deletes pods after 12 consecutive hours and shuts Linux VMs down after one hour. That works for a quick test, not for agents that run every day.
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. OpenShift runs wherever you put the cluster: your own data center, or a managed service on AWS, Azure, Google Cloud or IBM Cloud.
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