Cerebrium vs Replicate
Both are serverless GPU clouds that scale to zero, but they start from different places. Cerebrium deploys your own app or Dockerfile as HTTP or WebSocket endpoints, while Replicate gives you thousands of ready models behind one API, plus your own models packaged with Cog.
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.
Replicate
Replicate runs AI models with an API: thousands of community and official models, plus your own models packaged with Cog.
You call a public model with one API request, fine-tune one on your data, or package your own model with Cog, Replicate's open-source tool that builds a Docker image with an HTTP prediction server. Replicate runs it on CPU or NVIDIA GPU hardware as deployments that scale up with traffic and down to zero. It is built for teams that serve models, 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 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 | Replicate: price rank | boat: 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 | 268th of 367, with limits $4,340 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 221st of 366, with limits $2,534 a month | 335th of 366, with limits $11,300 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, where work starts on a request and scales back to zero. | 225th of 345, with limits $131 a month | 258th of 345, with limits $295 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 Both can serve your users as endpoints that scale; boat gives each user a full VM with a lasting disk and ranks first here. | 230th of 361, with limits $821 a month | 317th of 361, with limits $3,705 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 For RL rollouts Cerebrium ranks 72nd and Replicate 174th, and boat ranks 34th, though none of the three is a full match. | 72nd of 360, with limits $4,068 a month | 174th of 360, with limits $17,900 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 Agent evals fit both, with Cerebrium ranking 32nd and Replicate 67th; boat ranks 10th with a full VM per run. | 32nd cheapest of 364 $639 a month | 67th cheapest of 364 $1,440 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 CI fits Cerebrium at rank 81, but Replicate is a compromise at 311; boat ranks 4th because it has Docker and /dev/kvm inside. | 81st cheapest of 377 $766 a month | 311th of 377, with limits $864 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs SSH and a disk that keeps your installs; Cerebrium keeps only /persistent-storage, Replicate keeps nothing, and neither has SSH. | 259th of 368, with limits $102 a month | 306th of 368, with limits $226 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 Cerebrium nor Replicate has a desktop or browser product; boat streams a Linux desktop at 60fps with Chromium. | 179th of 369, with limits $575 a month | 263rd of 369, with limits $1,296 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 | 322nd of 367, with limits $1,296 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 | 272nd of 346, with limits $439 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 | 221st of 338, with limits $8,775 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 | 306th of 360, with limits $855 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; Replicate ranks 22nd at $1,338 a month and Cerebrium 28th at $1,975, while boat is CPU only and has no rank here. | 28th cheapest of 98 $1,975 a month | 22nd cheapest of 98 $1,338 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 | Replicate | boat |
|---|---|---|---|
| What you get | Your own app, built from your code or a Dockerfile, served as HTTP or WebSocket endpoints | Thousands of public models behind one API, plus your own models packaged with Cog | A full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts, which you or an agent work inside |
| Ready-made models | None; you deploy your own model or app | Thousands of community and official models for images, video, speech and text, plus fine-tuning | None; you bring the model API you call |
| GPUs | T4, A10, L4, L40S, A100, H100, H200, B200 and RTX PRO 6000, up to 8 per container, plus Inferentia2 and Trainium | T4, L40S, A100 80GB, H100 and H200, up to 8 per instance; most multi-GPU and all H200 need a committed spend contract | No, CPU only |
| CPU sizes | CPU containers sized by vCPU and memory, billed per second | CPU tiers of 1 or 4 vCPU | Default 4 vCPU / 8 GB and a small 2 vCPU / 4 GB size |
| Shell access | No SSH; you reach the app through its endpoints | No SSH; you call the model through the HTTP API or client libraries | 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 | The model is the container; Docker inside and /dev/kvm are not documented | Docker inside, and /dev/kvm for Android emulators and VMs |
| Files after a stop | Only the shared /persistent-storage volume survives; the first 100 GB of storage are free | No persistent disk; instances start fresh from the image, and API inputs and outputs are deleted after an hour by default | The whole disk is saved every minute and on stop, and a stopped sandbox keeps it for free |
| Fork and snapshots | No fork; an early-beta memory checkpoint speeds up new containers of the same build | No snapshots or fork; you add replicas of the same image | Fork a running sandbox with its disk |
| Run time per job | A request times out at response_grace_period, 15 minutes by default; async runs go up to 12 hours | Each prediction times out after 30 minutes unless support raises it | No session cap on paid plans; you set the time to live |
| Scale to zero and wake | Yes; apps scale to zero and start on the next request, up to your replica limit | Yes; deployments scale to zero and start on the next prediction, between min and max instances you set | No; a stopped sandbox is started by API |
| Inbound access | One endpoint per app on one port; custom domains on Standard | One prediction API per model behind API token auth; no own IP or ports | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| Keeping API keys out of the machine | Secrets are exposed to the app as environment variables | Secrets are sent to the model as inputs and redacted from logs afterwards | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Regions | US East, US Central, Stockholm and Finland, with 8 more on request | No region choice documented; infrastructure subprocessors listed in the United States | EU only (Germany, Finland, France) |
| Self-hosting | No | Cog is open source and its images run anywhere Docker runs | No |
Every feature Battleships tracks (43)
| Feature | Cerebrium | Replicate | boat |
|---|---|---|---|
| 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 | No | 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 | 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 | No | Yes | No |
| GPU | Yes | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | No | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | Yes | No |
| SSO | No | No | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | Yes | Not published | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either: neither Cerebrium nor Replicate has a result on the StarSling hpc-sandbox-benchmarks CPU test, so we cannot say which is faster at CPU work. boat did 26.69 runs per second on that test at 4 vCPU / 8 GB. Both Cerebrium and Replicate are built for GPU inference, 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. Cerebrium and Replicate 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 | Replicate, a month | boat, 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 | $57 · Usage · 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 | $237 · Usage · 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 | $2,851 · Usage · 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,620 · Usage | $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 | $3,580 · Usage | $2,000 · $2000/mo · with limits |
Cerebrium: Cerebrium bills per second for each vCPU, GB of memory and GPU while a container runs, and does not bill cold-start time. Hobby is free plus compute; Standard is $100 a month plus compute, and the protected tier costs 2x on all compute.
Replicate: Replicate bills per second by hardware tier from prepaid credit that expires after a year. Public models bill only while they run; private models and deployments also bill setup and idle time.
Replicate: 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.
Limits in those scenarios
Neither fits the workday agent, the always-on agent or the 50-agent fleet: Cerebrium keeps only /persistent-storage, so installed packages reset, and Replicate has no persistent disk at all. The fleet also needs Docker inside, which neither documents. Replicate's CPU tier comes in 1 or 4 vCPU, so the 2 vCPU scenarios are priced at 4 vCPU. Neither publishes an egress price, so the scenarios count none; for 1,000 short jobs at once both fit, while boat's $2,000 plan queues starts.
| Scenario | Cerebrium | Replicate | boat |
|---|---|---|---|
| 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 deploy your own model, voice or video app as an endpoint, need GPUs up to B200, or must run in the EU or Asia.
- Your own app, any shape. Teams with their own model or voice app can ship any Python code or Dockerfile as HTTP or WebSocket endpoints.
- Newer GPUs and more regions. Cerebrium adds B200, RTX PRO 6000 and Inferentia2, and runs in the US and the EU, with Asia on request.
- Longer async runs. Async jobs can run up to 12 hours, while a Replicate prediction stops at 30 minutes unless support raises it.
Use Replicate when
you want to call a ready model from a large catalog, fine-tune one, or package your own with Cog and keep the option to self-host.
- Thousands of ready models. Teams that want an image, video, speech or text model without hosting it can call one with a single request.
- Pay only for runs on public models. Public models bill only while they run, so occasional calls cost nothing between them.
- Cog runs anywhere. Cog is open source and builds standard Docker images, so the same model can run on your own servers.
Where boat fits
Cerebrium and Replicate serve models; neither is a machine an agent works inside. If what you are really running is agents that install tools, run Docker and keep their files, boat gives each one a full VM. Your agent in boat can still call Cerebrium or Replicate for GPU work.
A whole machine with Docker and /dev/kvm
On Cerebrium and Replicate the app or model is the container, with no SSH and no documented Docker inside, so an agent cannot run docker build or an Android emulator. boat gives root, systemd, Docker and /dev/kvm in every sandbox.
The whole disk stays, and you can fork it
Cerebrium keeps only /persistent-storage and Replicate keeps nothing, so packages and repos are set up again after every scale down. boat saves the whole disk every minute, keeps it free while stopped, and forks a running sandbox.
No time limit on the work
A Cerebrium request stops at 15 minutes by default and 12 hours at most for async runs, and a Replicate prediction stops at 30 minutes, so long agent tasks must be split. boat has no session cap on paid plans.
Use boat when your agents need a machine of their own: a shell, root, Docker, emulators and a browser, on a full VM whose whole disk is still there the next time it starts. Compare it one to one: boat vs Cerebrium and boat vs Replicate.
Questions people ask
Is Cerebrium cheaper than Replicate?
For the CPU scenarios on this page, yes, such as $715 against $1,620 a month for sandboxes for your users. For GPU eval jobs, Replicate comes out lower at $1,338 against $1,975 a month.
Which is faster, Cerebrium or Replicate?
Neither has a result on the StarSling CPU benchmark, so there is no fair CPU comparison. Both are built for GPU inference, and the GPU you pick matters more than the platform.
Can Cerebrium or Replicate run Docker inside?
Both build your code into a container image, Cerebrium from your Dockerfile and Replicate with Cog, but neither documents running Docker inside it. A boat sandbox runs Docker, systemd and /dev/kvm like a normal Ubuntu server.
How long can a job run on Cerebrium and Replicate?
A Cerebrium request times out at 15 minutes by default, and async runs can go up to 12 hours. A Replicate prediction stops at 30 minutes unless support raises it. boat has no session cap on paid plans.
Do Cerebrium and Replicate keep files between runs?
Cerebrium keeps files only in its /persistent-storage volume, and the rest of the container resets. Replicate has no persistent disk, and API inputs and outputs are deleted after an hour by default. boat saves the whole disk every minute and keeps it while the sandbox is stopped.
Can I use Cerebrium or Replicate as a sandbox for AI agents?
Not in the usual sense: both run models or apps behind endpoints, with no SSH, desktop or agent harness. An agent can work inside a boat sandbox and call either one for GPU work.
Try boat
Install the CLI, then run boat new.
7-day free trial