Runpod vs Cerebrium
Both are GPU clouds, but they hand you different things. Runpod rents you a pod, a container you log into by SSH and keep running, while Cerebrium turns your code into an endpoint that starts on a request and scales back to zero.
The companies and products
Runpod
Runpod is a GPU cloud for AI work: you rent GPU or CPU pods by the second, run serverless endpoints, or book multi-node GPU clusters.
A Runpod Pod is a container started from a Docker image, with a GPU or CPU-only, SSH, a web terminal and Jupyter. Serverless endpoints run your handler in workers that scale to zero and start on a request, and Instant Clusters join 2 to 8 nodes of 8 GPUs each. It is built for teams that train, fine-tune and serve models, not as a sandbox API for agents, so this page compares the parts that overlap: CPU pods as machines for agent work.
- Founded
- 2022
Cerebrium
Cerebrium is a serverless GPU cloud for real-time AI: voice agents, video models, LLMs and other ML apps.
You describe an app in a cerebrium.toml file, with your Python code or your own Dockerfile, and Cerebrium builds it and serves it as HTTP or WebSocket endpoints. It starts containers when requests arrive, scales them across GPUs and regions, and scales them back to zero when traffic stops. It is built for teams that serve models in production, not for agents that need a machine of their own, so this page compares the places where the two 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. “32nd cheapest of 377” means 31 of the other 376 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 | Runpod: price rank | Cerebrium: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither runs Docker inside, and each keeps only one folder after a stop (/workspace on Runpod, /persistent-storage on Cerebrium), so a coding agent that builds full apps is a compromise on both; bochka fits fully. | 203rd of 367, with limits $2,362 a month | 182nd of 367, with limits $2,008 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 211th of 366, with limits $2,290 a month | 221st of 366, with limits $2,534 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Short code runs suit both serverless models, which start on a request and bill per second, while bochka's start limits make big bursts a compromise. | 227th of 345, with limits $135 a month | 225th of 345, with limits $131 a month | 186th of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Cerebrium is confirmed to run 300 sandboxes at once on Hobby, while Runpod does not publish how many pods can run at once; bochka gives each user a full VM. | 83rd of 361, with limits $733 a month | 230th of 361, with limits $821 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 53rd of 360, with limits $3,068 a month | 72nd of 360, with limits $4,068 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month Cerebrium is a full fit for agent evals and Runpod a compromise; bochka also fits fully and ranks higher. | 127th of 364, with limits $614 a month | 32nd cheapest of 364 $639 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Both fit plain build and test jobs, with Runpod ranking higher; jobs that start Docker containers need bochka, since neither runs Docker inside. | 32nd cheapest of 377 $301 a month | 81st cheapest of 377 $766 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Runpod gives you SSH into a pod, which Cerebrium does not, but on both only one folder survives a stop; bochka keeps the whole disk and snapshots it every minute. | 161st of 368, with limits $93 a month | 259th of 368, with limits $102 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Neither has a desktop or browser product; bochka streams a 60fps desktop with Chromium and computer use. | 189th of 369, with limits $614 a month | 179th of 369, with limits $575 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 224th of 367, with limits $307 a month | 221st of 367, with limits $287 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 225th of 346, with limits $202 a month | 223rd of 346, with limits $195 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 138th of 338, with limits $4,035 a month | 135th of 338, with limits $3,991 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 180th of 360, with limits $161 a month | 197th of 360, with limits $191 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Both fit GPU eval jobs; Runpod ranks 13th and Cerebrium 28th, and bochka has no GPUs, so this part of the work belongs on one of them. | 13th cheapest of 98 $1,001 a month | 28th cheapest of 98 $1,975 a month | 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 | Can't run it |
Key features
| Feature | Runpod | Cerebrium | bochka |
|---|---|---|---|
| What you get | A pod: a container from a Docker image with a GPU or CPU only, plus Serverless endpoints and multi-node clusters | An app built from your code or Dockerfile, served as HTTP or WebSocket endpoints | A full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Shell access | SSH, a web terminal, JupyterLab and remote VS Code or Cursor | No SSH; you reach the app through its endpoints | SSH, root and systemd, like a normal Ubuntu server |
| Docker inside | No Docker or Docker Compose inside a pod | Not documented; the app is the container | Docker, Docker Compose and /dev/kvm on every machine |
| Files after a stop | Only /workspace is kept, and billed while stopped | Only the shared /persistent-storage volume survives | The whole disk is kept, saved every minute and on stop, free while stopped |
| Fork and snapshots | No pod fork or snapshot; templates save the image and settings | No fork; an early-beta memory checkpoint speeds up cold starts | Fork a running sandbox into a new one with the same disk |
| Scale to zero | Serverless workers scale to zero and start on a request; pods run until you stop them | Apps scale to zero and start on the next request, up to your replica limit | Sandboxes stop and resume by API; no start on an incoming request |
| Run time | No documented cap on a pod; Serverless jobs time out after 24 hours by default, up to 7 days | No container cap, but a request times out after 15 minutes by default, 12 hours at most for async runs | No session cap on paid plans; you set the time to live |
| GPUs | Dozens of Nvidia and AMD types, from RTX A4000 to B300 and MI300X, plus multi-node clusters | T4 to B200 and RTX PRO 6000, up to 8 per container, plus Inferentia2 and Trainium | None, CPU only |
| Machines at once | Not published; spend is capped at $80 an hour by default | 500 CPU containers and 5 GPUs on Hobby; 1,000 containers and 30 GPUs on Standard | 100 to 2,000 sandboxes by plan, with limits on starts per minute |
| Reaching the machine | Up to 10 HTTP ports on a proxy URL with no built-in auth; TCP ports on a public IP | One endpoint per app on one port; custom domains on Standard | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Desktop and computer use | No desktop | No desktop or browser product | 60fps desktop with Chromium, computer use and browser control |
| Coding agents | An MCP server and skills let your own agent manage Runpod; none run inside a pod | An Agent Skill and a docs MCP server help your own agent deploy; none run inside | Claude Code, Codex, OpenCode and more preinstalled, driven from outside with a prompt, steer and events API |
| Keeping API keys out | Secrets passed into the pod as environment variables | Secrets exposed to the app as environment variables | Credentials proxy for model providers and any HTTPS API you register |
| Regions | 24 documented data centers in the US, Canada, Europe and Australia | US East, US Central, Stockholm and Finland, with 8 more on request | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Runpod | Cerebrium | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | No | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | No | Yes | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | Not published | Yes |
| Public IPv4 | Yes | No | No |
| Egress allowlist | No | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | No | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Runpod or Cerebrium: neither is in the public sandbox benchmark runs we use, so we cannot say which is faster at CPU work. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's run of 2026-09-29. Both Runpod and Cerebrium are mainly about GPU speed, which this test does not cover.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Runpod and Cerebrium have 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 | Runpod, a month | Cerebrium, a month | bochka, 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 | $26 · Pay-as-you-go (prepaid credits) · with limits | $53 · Hobby · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $93 · Pay-as-you-go (prepaid credits) · with limits | $210 · Hobby · with limits | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $1,156 · Pay-as-you-go (prepaid credits) · with limits | $2,557 · Hobby · with limits | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $307 · Pay-as-you-go (prepaid credits) · with limits | $715 · Hobby | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $614 · Pay-as-you-go (prepaid credits) · with limits | $1,681 · Standard | $2,000 · $2000/mo · with limits |
Runpod: Runpod bills a running pod per second from a prepaid balance, with disk on top, and a stopped pod keeps billing its /workspace volume at double the running rate. There are no ingress or egress fees, and spend is capped at $80 an hour by default.
Cerebrium: Cerebrium bills per second for each vCPU, GB of memory and GPU while a container runs. Hobby has no plan fee and Standard is $100 a month on top of compute; the protected tier that cannot be interrupted costs 2x, and egress has no published price.
Cerebrium: 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 whole disk.
Limits in those scenarios
Neither fits the coding agent, always-on and 50-agent scenarios, because only one folder survives a stop (/workspace on Runpod, /persistent-storage on Cerebrium) and neither runs Docker inside. Runpod does not publish how many pods can run at once, so 300 user sandboxes and 1,000 short jobs at once are not confirmed there, while Cerebrium's published container limits fit both. bochka's start limits queue the 1,000-job burst, which needs more starts per day than its $2,000 plan allows.
| Scenario | Runpod | Cerebrium | bochka |
|---|---|---|---|
| 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 Runpod when
you want GPU machines you log into and keep running, the widest choice of GPUs and clusters, or lower CPU rates.
- A pod you can log into. Useful if you want a GPU machine to work on: Runpod pods have SSH, a web terminal, JupyterLab and TCP ports.
- More GPU types and clusters. Useful for training and big jobs: Runpod rents dozens of Nvidia and AMD GPUs, up to clusters of 2 to 8 nodes.
- Lower CPU rates. Useful for CPU work in our scenarios: a 4 vCPU pod costs less than half what the same Cerebrium container does per hour.
Use Cerebrium when
you serve a model, voice or video app as an endpoint that scales to zero and grows with traffic across regions.
- Endpoints that scale with traffic. Useful for serving models: a Cerebrium app starts on a request, grows to many replicas and scales back to zero.
- Published limits for many at once. Useful when you need hundreds of containers at once: Cerebrium allows 500 on Hobby and 1,000 on Standard.
- One endpoint across regions. Useful for real-time apps: one endpoint routes each request to a region with a warm instance.
Where bochka fits
Runpod and Cerebrium are GPU clouds for training and serving models, not sandboxes for agents. If what you are really running is agents that write and run code for hours, bochka gives each one a full VM with Docker and a whole disk that survives. You can keep the GPU part on Runpod or Cerebrium and run the agents on bochka.
Docker and a real machine inside
A coding agent runs docker compose up and test containers. Neither a Runpod pod nor a Cerebrium app can run Docker inside, so those steps fail; bochka gives every sandbox Docker, systemd and /dev/kvm.
The whole disk survives a stop
Runpod keeps only /workspace and Cerebrium only /persistent-storage, so packages an agent installed elsewhere are gone. The workaround is baking everything into an image, which means a rebuild for every change; bochka saves the whole disk every minute.
Agents, desktop and a keys proxy built in
Both pass secrets in as environment variables an agent can read and leak, and neither runs agents or a desktop for you. bochka ships coding agents you drive from outside, a 60fps desktop and a credentials proxy.
Use bochka when your agents need a machine of their own: a shell, root, Docker, emulators and a desktop, on a full VM whose whole disk is still there next time. Compare it one to one: bochka vs Runpod and bochka vs Cerebrium.
Questions people ask
Is Runpod cheaper than Cerebrium?
For CPU work in our scenarios, yes: one agent running all month comes to $93 on Runpod and $210 on Cerebrium, and 50 agents in parallel to $1,156 against $2,557. For GPU eval jobs Runpod comes to about $1,001 a month against $1,975. On bochka the same always-on agent is $26 a month.
Which is faster, Runpod or Cerebrium?
We have no comparable CPU measurement for either one, so we cannot say. Both are built around GPU work, and their speed depends on the GPU you pick. bochka did 26.69 runs per second on the StarSling CPU test at 4 vCPU / 8 GB.
Can I SSH into Cerebrium like a Runpod pod?
No. Cerebrium has no SSH; you reach your app through its HTTP or WebSocket endpoints. Runpod pods have SSH, a web terminal and JupyterLab, and a bochka sandbox has SSH, root and systemd.
Can Runpod or Cerebrium run Docker inside?
Runpod's docs say you cannot start your own Docker or use Docker Compose on a pod, and Cerebrium does not document Docker inside an app. Every bochka sandbox is a VM with Docker, Docker Compose and /dev/kvm ready.
What happens to my files when they stop?
On Runpod only /workspace is kept, and you keep paying for it while stopped. On Cerebrium only /persistent-storage survives. bochka keeps the whole disk, snapshots it every minute, and a stopped sandbox costs nothing.
Does bochka have GPUs like Runpod and Cerebrium?
No. bochka runs Linux VMs on dedicated AMD Ryzen 9 9950X hosts and has no GPUs. Keep training and model serving on Runpod or Cerebrium, and run the agents that write and test code on bochka.
Try bochka
Install the CLI, then run bochka new.
Product preview