Cerebrium vs Baseten
Both are GPU clouds that run your model or app as containers that scale up with traffic and down to zero. Cerebrium bills per second and keeps one shared storage folder, while Baseten bills per minute, adds hosted open models, training and a private preview of agent sandboxes, and can run in your own cloud.
The companies and products
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.
Baseten
Baseten is an inference cloud: it runs AI models on GPUs for production apps, and sells hosted open models and training.
You package a model with Truss, its open-source format, or bring a Docker image, and Baseten runs it as replicas on Kubernetes that scale up with traffic and down to zero. It also sells Model APIs (open models priced per token) and training jobs on the same GPUs. Sandboxes, isolated environments where an agent runs commands and works with files, are in private preview; this page compares bochka with both the CPU instances and the sandbox preview.
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 364” means 31 of the other 363 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 | Cerebrium: price rank | Baseten: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 182nd of 367, with limits $2,008 a month | 216th of 367, with limits $2,619 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on one machine all month loses its installs on both: Cerebrium keeps only one folder, Baseten's CPU instances keep no disk. | 221st of 366, with limits $2,534 a month | 242nd of 366, with limits $3,258 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 Cerebrium's per-second billing better than Baseten's per-minute billing, which also counts cold starts and, by default, 15 idle minutes before a replica scales down. | 225th of 345, with limits $131 a month | 319th of 345, with limits $1,856 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 can run 300 short user sessions at once on Hobby, while Baseten's sandbox preview allows 10 at once per organization by default. | 230th of 361, with limits $821 a month | 277th of 361, with limits $1,868 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 | 72nd of 360, with limits $4,068 a month | 322nd of 360, with limits $31,140 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 fits agent evals as short per-second containers, while Baseten's CPU instances lose their files when a replica stops; bochka gives each eval a full VM. | 32nd cheapest of 364 $639 a month | 297th of 364, with limits $1,609 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 Neither documents Docker inside its containers, which most CI builds need; every bochka sandbox has root, Docker and /dev/kvm. | 81st cheapest of 377 $766 a month | 320th of 377, with limits $1,119 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Cerebrium has no SSH and keeps only /persistent-storage, and Baseten's CPU instances keep no disk at all, so a dev box that keeps its installs fits bochka better. | 259th of 368, with limits $102 a month | 170th of 368, with limits $130 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 computer-use product; bochka streams a 60fps Linux desktop with Chromium from every sandbox. | 179th of 369, with limits $575 a month | 294th of 369, with limits $1,799 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 | 221st of 367, with limits $287 a month | 318th of 367, with limits $1,194 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 | 223rd of 346, with limits $195 a month | 220th of 346, with limits $183 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 | 135th of 338, with limits $3,991 a month | 126th of 338, with limits $3,654 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 | 197th of 360, with limits $191 a month | 254th of 360, with limits $381 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 This is where both fit: Baseten comes out a little ahead at $1,625 a month against $1,975 for Cerebrium, and bochka has no GPUs. | 28th cheapest of 98 $1,975 a month | 24th cheapest of 98 $1,625 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 | Cerebrium | Baseten | bochka |
|---|---|---|---|
| Kind of product | Serverless GPU cloud: apps run as autoscaling containers behind HTTP or WebSocket endpoints | Inference cloud: model deployments, hosted open models per token and training; agent sandboxes in private preview | Sandboxes for AI agents: full VMs with agents, desktop and hosting ready |
| GPUs | T4 to B200 and RTX PRO 6000, up to 8 per container, plus AWS Inferentia2 and Trainium | Nvidia T4 to B200 and RTX PRO 6000, up to 8 per instance, plus multi-node over InfiniBand | None, CPU only |
| Billing unit | Per second while a container runs; the platform's cold-start time is not billed | Per minute, partial minutes rounded up, including image builds and cold starts | Per second while a sandbox runs; a stopped sandbox costs nothing |
| Plan fee | Hobby is free plus compute; Standard is $100 a month plus compute, needed for A100, H100, H200 and B200 | No plan fee on Basic; Pro and Enterprise are quoted | Plans from $20 a month, and the whole fee is usage credit |
| Files after a stop | Only the shared /persistent-storage volume survives; packages and files elsewhere reset | Model replicas start fresh from the image; preview sandboxes keep files on standby but are deleted after 7 days by default | The whole disk is saved every minute and on stop, and a stopped sandbox keeps it for free |
| Shell access | No SSH; you reach the app through its endpoints | SSH once enabled for your organization; containers run as the non-root app user | SSH, root and systemd, like a normal Ubuntu server |
| Docker and nested virtualization | The app is the container; Docker inside and /dev/kvm are not documented | Docker inside and /dev/kvm are not documented | Docker inside, and /dev/kvm for Android emulators and VMs |
| Agent sandboxes | No sandbox product; apps are endpoints | Private preview, access on request, 10 per organization at once by default, price not published | On every plan, self-serve, 100 to 2,000 at once by plan |
| Fork and snapshots | No fork; an early-beta memory checkpoint speeds up new containers of the same build | No fork or clone; new replicas cold-start from the image | Fork a running sandbox with its disk |
| Scale to zero and wake | Apps scale to zero and start again on the next request | Deployments scale to zero and start on the next request; standby sandboxes resume on the next request | No wake on request; a stopped sandbox is started by API |
| Desktop and coding agents | No desktop or browser product, no agent to run inside | No desktop or computer-use API; Baseten Switch points Claude Code or Codex on your laptop at its Model APIs | 60fps Linux desktop with Chromium and computer use, and seven coding agents preinstalled with a prompt, steer and events API |
| Keeping API keys out of the machine | Secrets are exposed to the app as environment variables | Secrets are passed into the model as arguments or files under /secrets | Credentials proxy for model providers and any HTTPS API you register |
| Outbound network | No provider-side egress allowlist | TCP 443 and 80 by default; per-deployment IP and domain allowlists once enabled | Open internet on every plan; no provider-side allowlist |
| Regions and hosting | US East, US Central, Stockholm and Finland; Asia, South America, Canada and the Middle East on request | US and EU for GPU deployments; self-hosted in your own AWS, GCP or OCI account on Enterprise | EU only (Germany, Finland, France) |
Every feature Battleships tracks (43)
| Feature | Cerebrium | Baseten | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | No | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Not published | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | No | Yes | Yes |
| Persistent disk | Yes | No | Yes |
| Pause/resume | No | 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 | Yes | Yes | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Not published | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | 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 | No | Yes | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | No | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | No | Yes | 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 either: neither Cerebrium nor Baseten has a result on the StarSling hpc-sandbox-benchmarks CPU test, so we cannot say which is faster at CPU work. bochka did 26.69 runs per second on that test at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. Both providers' own speed claims are about GPU inference and cold starts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Cerebrium and Baseten 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 | Cerebrium, a month | Baseten, 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 | $53 · Hobby · with limits | $34 · Basic · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $210 · Hobby · with limits | $136 · Basic · 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 | $2,557 · Hobby · with limits | $1,701 · Basic · 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 | $715 · Hobby | $1,246 · Basic · with limits | $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 | $1,681 · Standard | $6,228 · Basic · with limits | $2,000 · $2000/mo · with limits |
Cerebrium: Cerebrium bills per second for each vCPU, GB of memory and GPU while a container runs, and the default tier can be interrupted; the protected tier costs 2x on all compute. Standard is $100 a month on top of compute, and storage past the first 100 GB costs $0.05 per GB a month.
Baseten: Baseten bills per minute, rounding partial minutes up, from image build and cold start until the replica stops, and by default a replica waits 15 idle minutes before it scales down. There is no plan fee on Basic, and a monthly budget only stops Model APIs, not dedicated deployments.
Baseten: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Neither fits the coding agent, always-on or 50-agent scenarios: Cerebrium keeps only /persistent-storage, so installed packages reset, and Baseten's CPU instances keep no disk at all; neither documents Docker inside for the fleet. For short, many sessions Cerebrium fits: 300 user sandboxes at once on Hobby and the 1,000-job burst on Standard, while Baseten is marked as not fitting because its CPU instances are an app platform and its sandbox preview runs 10 at once by default. bochka fits every scenario but the burst, where its start limits queue the jobs.
| Scenario | Cerebrium | Baseten | 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 Cerebrium when
you serve a model, voice or video app on GPUs with short, spiky traffic and want per-second billing, a shared storage folder, or regions outside the US and EU.
- Per-second billing for short work. For bursty or short jobs, Cerebrium bills per second and does not bill its own cold-start time.
- A folder that survives restarts. For apps that cache model weights or data, the shared /persistent-storage volume keeps files across containers.
- More regions on request. For teams serving users in Asia or South America, support can open Tokyo, Mumbai, Sao Paulo and more.
Use Baseten when
you want big GPUs with no plan fee, hosted open models and training in one place, egress allowlists, or to run inside your own cloud account.
- No plan fee for the big GPUs. For teams that want H100s or B200s without a monthly fee, Baseten's Basic plan is pay as you go.
- More than serving. For teams that also want hosted open models per token, training jobs or a sandbox preview, Baseten has all three.
- Your own cloud and egress rules. For teams that must run in their own AWS, GCP or OCI account, or limit outbound traffic per deployment.
Where bochka fits
Cerebrium and Baseten are built to serve models on GPUs, and bochka has no GPUs, so for inference pick one of them. If what you are really running is agents that write code, install tools and use a browser, neither gives them a machine of their own, and bochka does. Many teams serve the model on a GPU cloud and let the agents work on bochka.
A full VM with root and Docker
Agents run docker build, start databases and launch emulators. Cerebrium's app is the container with no shell, and Baseten's containers run as a non-root user; neither documents Docker or /dev/kvm inside. A bochka sandbox has its own kernel, root, systemd and Docker.
A disk that stays, and forks
On Cerebrium only /persistent-storage survives, so installs elsewhere reset; Baseten's CPU instances keep no disk and its preview sandboxes are deleted after 7 days. bochka saves the whole disk every minute, keeps it free while stopped, and forks a running sandbox.
Agents, desktop and keys built in
Neither runs a coding agent or a desktop for you, so you build the loop and the browser yourself, and both hand secrets to the container. bochka ships seven agents you drive from outside, a 60fps desktop, and a credentials proxy that keeps real keys off the machine.
Use bochka when the real workload is agents that need a machine of their own: root, Docker, a desktop and coding agents built in, and a whole disk that stays and can be forked. Compare it one to one: bochka vs Cerebrium and bochka vs Baseten.
Questions people ask
Is Cerebrium cheaper than Baseten?
It depends on the shape of the work. For steady CPU work Baseten came out cheaper, such as $136 against $210 a month for one agent running all month, and for GPU eval jobs it was $1,625 against $1,975. For many short sessions Cerebrium's per-second billing won: $715 against $1,246 a month for 300 user sandboxes.
Which is faster, Cerebrium or Baseten?
Neither has a result on the StarSling CPU benchmark, so there is no fair CPU comparison. Both make their speed claims about GPU inference and cold starts. bochka did 26.69 runs per second on that test at 4 vCPU / 8 GB.
Can Cerebrium or Baseten run Docker inside?
Both build or run your app from a Docker image, but neither documents running Docker inside the container, and Baseten's model containers run as a non-root user. Every bochka sandbox has root, Docker, systemd and /dev/kvm.
Does Cerebrium or Baseten have sandboxes for AI agents?
Baseten has agent sandboxes in private preview: access on request, 10 at once per organization by default, and deleted with their files after 7 days by default. Cerebrium has no sandbox product; it runs apps as endpoints. bochka sandboxes are self-serve on every plan.
Which keeps my files after a stop?
Cerebrium keeps files only in its shared /persistent-storage volume, and Baseten's model replicas start fresh from the image each time. bochka saves the whole disk every minute and on stop, and keeps it for free while the sandbox is stopped.
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.
Try bochka
Install the CLI, then run bochka new.
Product preview