# Cerebrium

> Cerebrium is serverless GPU infrastructure for real-time AI — voice agents, video models, LLMs, and custom ML apps. Sub-second cold starts, pay-per-second billing, no Kubernetes.

## What we do

- **Voice AI**: Real-time end-to-end pipelines for voice agents (STT + LLM + TTS).
- **Video & generative media**: Low-latency inference for video generation, image diffusion, and avatars.
- **LLMs**: Serverless deployment for OpenAI-compatible endpoints, open-source models (DeepSeek, Llama, Orpheus), and custom fine-tunes.
- **General ML**: Any Python workload, any GPU (L4, L40s, A100, H100, H200), pay only for compute-time used.

## Key Facts

- Product: serverless GPU infrastructure for real-time AI inference — voice, video, LLMs, and custom ML.
- Supported GPUs: L4, L40s, A100, H100, H200 — billed per-second of compute used, no idle charges or minimum reservations.
- Cold starts: sub-second on the largest models (H100/H200 inference).
- Voice pipelines: sub-500ms end-to-end latency (STT + LLM + TTS).
- Deployment: multi-region (US + EU) for data residency; bring-your-own-code (any Python script or container, no lock-in).
- Compliance: SOC 2, HIPAA, GDPR, ISO.
- Reference customers: Resemble AI, Camb AI, Telli, Amira Learning, Invofox, Creatium.
- Open source: github.com/CerebriumAI — 522-star examples repo (voice agents, LLMs, video, RAG).

## Key pages

- [Serverless GPU Infrastructure for Real-Time AI](https://cerebrium.ai/): Deploy voice agents, video models, and LLMs on serverless GPUs with sub-second cold starts. Pay-per-second pricing. No Kubernetes.
- [Pay-Per-Second Pricing for Serverless AI](https://cerebrium.ai/pricing): Pay for compute by the second, not the hour. Transparent serverless GPU pricing for voice, LLMs, and video. No commitment, no idle costs.
- [Our Mission — Real-Time AI Infrastructure](https://cerebrium.ai/about): Cerebrium is the team building global serverless GPU infrastructure for real-time AI model applications.
- [Book a Demo — Technical Architecture Review](https://cerebrium.ai/book-demo): See the technical architecture behind AI teams deploying real-time voice agents, LLMs, and video models on Cerebrium. 30-minute demo with our team.
- [Contact — Sales, Support, Partnerships](https://cerebrium.ai/contact): Get in touch with Cerebrium for sales, partnerships, support, or enterprise inquiries. Real-time replies during business hours.
- [Brand Assets — Logos & Guidelines](https://cerebrium.ai/brand-assets): Download Cerebrium logos, color palette, typography, and brand guidelines for press, partnerships, and media coverage.

## Use cases

- [Large Language Models](https://cerebrium.ai/use-cases/large-language-models): Run and deploy LLMs at scale
- [Voice](https://cerebrium.ai/use-cases/voice): Infrastructure built for low-latency voice at scale
- [Image & Video](https://cerebrium.ai/use-cases/image-and-video): Run image and video pipelines at scale

## Documentation

- [Documentation home](https://docs.cerebrium.ai/getting-started/introduction): Full developer docs (hosted on docs.cerebrium.ai).
- [Cerebrium examples](https://github.com/CerebriumAI/examples): 522-star reference repo covering voice agents, LLMs, video, RAG.
- [Documentation index](https://cerebrium.ai/docs/llms.txt): llms.txt index of every documentation page (151 entries), for agents that want to pick pages to fetch.
- [Documentation full text](https://cerebrium.ai/docs/llms-full.txt): the entire documentation as one plain-text corpus, for agents that want it in a single fetch.

## For AI agents

- [Agent Skill](https://cerebrium.ai/skill.md): Cerebrium packaged as an Agent Skill — deploying serverless GPU workloads, cold starts, scaling, and the CLI. Generated from the docs, so it tracks them rather than going stale.
- Install it: `npx skills add https://cerebrium.ai -y` — works with Claude Code, Cursor, and other tools that read the agent-skills discovery index.
- [Discovery index](https://cerebrium.ai/.well-known/agent-skills/index.json): agentskills.io discovery document, served with an [A2A agent card](https://cerebrium.ai/.well-known/agent-card.json) alongside it.
- [MCP server](https://cerebrium.ai/docs/mcp): Model Context Protocol endpoint for searching and querying the Cerebrium documentation.

## Blog (selected high-value posts)

- [How much does a H100 cost? Cost comparision](https://cerebrium.ai/blog/how-much-does-a-h100-cost-cost-comparision): GPU cost comparison.
- [How much does a H200 cost? 2025 Guide](https://cerebrium.ai/blog/how-much-does-a-h200-cost-2025-guide): H200 pricing breakdown.
- [Top 5 Serverless GPU providers](https://cerebrium.ai/blog/top-5-serverless-gpu-providers): Competitive landscape.
- [Creating a realtime RAG voice agent](https://cerebrium.ai/blog/creating-a-realtime-rag-voice-agent): Tutorial.
- [Deploying DeepSeek-R1: A Guide to a Serverless, High-Performaning OpenAI-Compatible Endpoint](https://cerebrium.ai/blog/deploying-deepseek-r1-a-guide-to-a-serverless-high-performaning-openai-compatible-endpoint): OpenAI-compatible endpoint guide.
- [Orpheus TTS: How to Deploy Orpheus at Scale for Production Inference](https://cerebrium.ai/blog/orpheus-tts-how-to-deploy-orpheus-at-scale-for-production-inference): Production TTS deployment.
- [Deploying Sesame CSM: The Most Realistic Voice Model as an API](https://cerebrium.ai/blog/deploying-sesame-csm-the-most-realistic-voice-model): Voice model guide.
- [Launch Week Day 3: Annoucing Multi-Region Deployments](https://cerebrium.ai/blog/launch-week-day-3-annoucing-multi-region-deployments): Product announcement.
- [Rethinking Container Image Distribution to eliminate cold starts](https://cerebrium.ai/blog/rethinking-container-image-distribution-to-eliminate-cold-starts): Engineering deep dive.
- [The Shortcomings of Celery + Redis for ML Workloads and How Cerebrium Solves It](https://cerebrium.ai/blog/celery-redis-vs-cerebrium): Migration comparison.
- [Faster Whisper Transcription: How to Maximize Performance for Real-Time Audio-to-Text](https://cerebrium.ai/blog/faster-whisper-transcription-how-to-maximize-performance-for-real-time-audio-to-text): Real-time STT.
- [Integrating PayPal’s Model Context Protocol (MCP) into a Real-time Voice Agent](https://cerebrium.ai/blog/integrating-paypal-s-model-context-protocol-mcp-into-a-real-time-voice-agent): MCP integration.
- [Introducing Cerebrium run: The Fastest Way to Execute Cloud Code](https://cerebrium.ai/blog/introducing-cerebrium-run-the-fastest-way-to-execute-cloud-code): Cloud-code execution.
- [Blog index](https://cerebrium.ai/blog): All posts.

## Resources

- [Batch vs Real-Time LLM Inference Cost Per Million Tokens](https://cerebrium.ai/resources/batch-vs-real-time-llm-inference-cost-per-million-tokens): Batch LLM inference runs 2-3x cheaper per million tokens than real-time - but only below a worker-utilization line. Here is exactly where that line sits.
- [Serverless vs Always-On GPU: LLM Break-Even](https://cerebrium.ai/resources/serverless-gpu-vs-always-on-gpu-break-even-llm-inference): At what utilization does an always-on GPU beat serverless for LLM inference? The break-even math, a worked RunPod A40 example, and a CTO decision checklist.
- [Mistral Large 4: GPU Memory & TTFT Deploy Guide](https://cerebrium.ai/resources/mistral-large-4-first-deployment-gpu-memory-ttft): First-deployment guide to Mistral Large 4 GPU memory and time to first token: MoE active params, FP8 vs NVFP4, PCP+DCP prefill, and vLLM day-0.
- [Reference-to-Video: Identity Consistency vs Time per Clip](https://cerebrium.ai/resources/reference-to-video-identity-consistency-time-per-clip): Comparing reference-to-video models on identity drift and generation time per clip - the trade-off ML teams resolve before putting a model behind an API.
- [vLLM on TPU vs H100: Cost & Throughput Guide](https://cerebrium.ai/resources/vllm-google-tpu-vs-h100-llm-inference-cost-throughput): vLLM now runs natively on Google TPU via TorchTPU, so TPU vs H100 is a buyer decision. A framework for LLM inference cost and throughput.
- [Hugging Face ZeroGPU Alternatives for Gradio Demos](https://cerebrium.ai/resources/hugging-face-zerogpu-alternatives-gradio-serverless-gpu): You didn't outgrow ZeroGPU's GPU - you outgrew its quota math. A numbers-backed guide to serverless GPU alternatives for Gradio: RunPod, Together AI, Cerebrium.
- [Few-Step Distilled Video: Time & Cost per Clip on H100](https://cerebrium.ai/resources/few-step-distilled-video-generation-cost-per-clip-h100): How few-step distillation (40 to 6-8 steps) changes the step-count term of the cost equation, and how to compute your own time and cost per clip on an H100.
- [Tool Call Schema Accuracy with Constrained Decoding in vLLM](https://cerebrium.ai/resources/tool-call-schema-accuracy-constrained-decoding-vllm): Why self-hosted vLLM agents fail tool-call schema validation, and how constrained decoding turns schema accuracy into a runtime guarantee.
- [Gradio Demo to Production GPU Inference API](https://cerebrium.ai/resources/gradio-demo-to-production-gpu-inference-api): An ML engineer's staged migration guide from a single-user Gradio demo to a batched, autoscaled, SLA-backed production GPU inference API.
- [MiniMax-M3.1-Flash: GPU Memory & TTFT Runbook](https://cerebrium.ai/resources/minimax-m3-1-flash-first-deployment-gpu-memory-ttft): A serving runbook for the first MiniMax-M3.1-Flash deployment: GPU memory, checkpoint size, TP4 configs, and what drives time to first token.
- [DeepSeek-V4.1-Flash: Self-Host Cost vs API Price](https://cerebrium.ai/resources/deepseek-v4-1-flash-self-hosted-cost-vs-api-price): Compare DeepSeek-V4.1-Flash self-hosted serving cost vs API price per million tokens, with the throughput and utilization inputs that decide break-even.
- [vLLM Replica Startup Time: Compile Cache & GPU Snapshots](https://cerebrium.ai/resources/vllm-replica-startup-compile-cache-gpu-memory-snapshots): Break a vLLM cold start into phases and quantify savings from compile cache (~18s on H100) and GPU memory snapshots (up to 88% on vLLM).
- [Real-Time Video Avatar Sessions Per GPU & Sticky Routing](https://cerebrium.ai/resources/real-time-video-avatar-sessions-per-gpu): How sticky routing and session affinity set your real-time video avatar sessions per GPU, protect TTFF, avoid cold starts, and cut costs.
- [DeepInfra Alternatives for Open-Source LLM Inference 2026](https://cerebrium.ai/resources/deepinfra-alternatives-open-source-llm-api-inference): A VP Engineering's guide to DeepInfra alternatives for open-source LLM API inference: compare price, latency, batch cost, and control-plane ownership.
- [SLM Inference Cost Per Request on a Single GPU](https://cerebrium.ai/resources/small-language-model-inference-cost-per-request-single-gpu): A measurement guide to small language model inference cost per request on a single GPU: KV-cache footprint, vocabulary tax, and throughput levers.
- [Whisper Batch Cost per Audio Hour: Serverless GPU Guide](https://cerebrium.ai/resources/whisper-batch-transcription-cost-per-audio-hour-serverless-gpu): Compare Whisper batch transcription cost per audio hour across serverless GPUs. The $/audio-hour formula, throughput drivers, and a platform-by-platform table.
- [BentoML Alternatives for Production LLM Serving](https://cerebrium.ai/resources/bentoml-alternatives-production-llm-serving): A VP's decision guide to 6 BentoML alternatives for production LLM serving: vLLM, Triton, KServe, Ray Serve, Seldon Core and TorchServe, scored on one rubric.
- [Self-Hosted LLM Cost-Per-Request & Token Tracking](https://cerebrium.ai/resources/token-usage-cost-per-request-tracking-self-hosted-llm-inference): Self-host open models and no provider sends an itemized bill. How to rebuild per-request token usage, cost attribution and an audit trail at the proxy.
- [Real-Time Speech Translation Latency for Voice Agents](https://cerebrium.ai/resources/real-time-speech-translation-latency-multilingual-voice-agents): An engineer's teardown of real-time speech translation latency for multilingual voice agents: per-stage budgets, round-trip targets, ATD, and benchmarks.
- [Northflank Alternatives for GPU Inference: 6 Compared](https://cerebrium.ai/resources/northflank-alternatives-gpu-inference-workloads): Six Northflank alternatives for GPU inference workloads compared on serving model, H100 price, bundled compute and scale-to-zero. A 2026 buyer's guide.
- [Ollama on a Laptop to a Production GPU Endpoint](https://cerebrium.ai/resources/ollama-laptop-to-production-gpu-inference-endpoint): A stage-by-stage migration path from ollama run on a laptop to an autoscaling production GPU inference endpoint, with the triggers that tell you when to move.
- [Koyeb Alternatives for Serverless GPU Deployment](https://cerebrium.ai/resources/koyeb-alternatives-serverless-gpu-model-deployment): Compare the top Koyeb alternatives for serverless GPU model deployment on cold starts, deployment model, GPU catalog and pricing - Modal, RunPod, Baseten.
- [Real-Time Video Generation Latency on Serverless GPU](https://cerebrium.ai/resources/real-time-video-generation-latency-per-frame-serverless-gpu): Can serverless GPU serve generated video inside a 33.3ms (30fps) or 16.7ms (60fps) per-frame budget at p99<100ms? A decision guide with real numbers.
- [8kHz Phone Call ASR: Latency and Accuracy Budget](https://cerebrium.ai/resources/speech-recognition-latency-accuracy-8khz-phone-audio): Engineer latency and accuracy together on 8kHz narrowband call audio: WER baselines, a component latency budget, deployment topology, and a measurement plan.
- [End-of-Turn Detection Latency in Voice Agent Pipelines](https://cerebrium.ai/resources/end-of-turn-detection-model-latency-voice-agent-pipelines): Endpointing is the latency you're not measuring. A measurement-first guide to end-of-turn detection latency in STT-LLM-TTS voice agent pipelines.
- [Groq Alternatives for Low-Latency LLM Inference](https://cerebrium.ai/resources/groq-alternatives-low-latency-llm-inference): Groq is fast, but 'fastest' depends on your workload. Compare Cerebras, SambaNova, Together AI, Fireworks AI and SiliconFlow on TTFT, throughput and cost.
- [Local FastAPI to Serverless GPU Endpoint: Migration Guide](https://cerebrium.ai/resources/local-fastapi-to-serverless-gpu-endpoint): A migration guide for ML engineers moving from a local FastAPI GPU server to a serverless GPU endpoint: cold starts, model loading, scaling and billing.
- [Voice Cloning Inference: Cost & Latency Per Request](https://cerebrium.ai/resources/voice-cloning-inference-cost-latency-per-request): Build vs. buy voice cloning inference, normalized to two per-request units: TTFB and cost per request. Provider numbers, self-hosted economics, break-even.
- [Anyscale Alternatives for Ray Serve Model Serving](https://cerebrium.ai/resources/anyscale-alternatives-ray-serve-model-serving): A VP-level guide to Anyscale alternatives for Ray Serve model serving: KServe, Together AI, managed serverless GPUs, and how to choose by workload.
- [Streaming STT Latency on Serverless GPU: A Budget](https://cerebrium.ai/resources/streaming-stt-latency-websocket-serverless-gpu): Treat streaming speech-to-text latency over WebSockets as a four-part budget: transport, RTF inference, partial/final emission, and the GPU cold-start tax.
- [9 fal.ai Alternatives for Image & Video Inference (2026)](https://cerebrium.ai/resources/fal-ai-alternatives-image-video-generation-inference): Compare fal.ai alternatives for image and video inference: Replicate, RunPod, Modal, Baseten, Together AI, Vertex AI and more on pricing, control and scale.
- [Together AI Alternatives for Fine-Tuned LLM Inference](https://cerebrium.ai/resources/together-ai-alternatives-fine-tuned-llm-inference): A VP of Engineering's 2026 guide to Together AI alternatives for fine-tuned LLM inference: serverless, multi-LoRA, pricing and deployment control compared.
- [S2S vs Cascaded Voice Agent Latency: A Buyer's Guide](https://cerebrium.ai/resources/speech-to-speech-vs-cascaded-voice-agent-latency): Speech-to-speech or cascaded STT-LLM-TTS? Compare voice agent latency honestly, then architect for the component you'll have to swap under deprecation.
- [Loading Model Weights from Object Storage at Deploy](https://cerebrium.ai/resources/loading-model-weights-object-storage-deploy-time): A DevOps guide to loading large model weights from object storage at deploy time: cold-start phases, streaming loaders, safetensors, and caching.
- [Fireworks AI Alternatives for Open-Source LLM Inference](https://cerebrium.ai/resources/fireworks-ai-alternatives-open-source-llm-inference): Compare Fireworks AI alternatives - Together AI, Groq, Modal and Anyscale - by pricing, control, catalog and latency for open-source LLM inference.
- [Sora API Alternatives: Text-to-Video Cost Per Clip](https://cerebrium.ai/resources/sora-api-alternatives-text-to-video-cost-per-clip): Sora's API sunsets Sept 24, 2026. Compare text-to-video alternatives by cost per clip, per GPU-second, and per usable clip for your pipeline.
- [OpenAI TTS Alternatives: Open-Source by TTFA](https://cerebrium.ai/resources/openai-tts-api-alternatives-time-to-first-audio): OpenAI's TTS API shuts down Jan 6, 2027. A commercial guide to evaluating open-source TTS alternatives by time-to-first-audio, with our own latency benchmarks.
- [Managing LLM Model Versions: Staging to Production](https://cerebrium.ai/resources/managing-model-versions-staging-production-llm-inference): A DevOps playbook for managing LLM model versions across staging and production: immutable artifacts, aliases, shadow and canary rollout, one-command rollback.
- [Replicate Alternatives for Production Image & LLM Serving](https://cerebrium.ai/resources/replicate-alternatives-production-image-llm-serving): A VP Engineering guide to Replicate alternatives for production image and LLM serving: cold starts, cost-at-scale, autoscaling, lock-in and a vendor map.
- [Multi-Node LLM Inference on Serverless Clusters](https://cerebrium.ai/resources/multi-node-llm-inference-serverless-clusters): A VP's build-vs-buy guide to multi-node LLM inference on serverless clusters: gang scheduling, RDMA, per-second billing, and when to consume vs. operate.
- [Llama 405B Serverless GPU Inference Cost: An Honest Model](https://cerebrium.ai/resources/llama-405b-serverless-gpu-inference-cost): What really drives the cost of serving Llama 405B on serverless GPUs: cost-per-token vs per-GPU-second, cold starts, idle billing, VRAM and quantization.
- [Autoscaling Llama 70B: Cutting Replica Startup Latency](https://cerebrium.ai/resources/autoscaling-llama-70b-inference-replica-startup): A vendor-neutral teardown of Llama 70B replica startup latency: where the 10+ minute cold start goes, how to cut it, and how to pick an autoscaling platform.
- [CoreWeave Alternatives for Production LLM Inference (2026)](https://cerebrium.ai/resources/coreweave-alternatives-production-llm-inference): Choosing a CoreWeave alternative for production LLM inference is a serving-architecture decision, not a GPU price. Compare routing, batch, raw GPU by workload.
- [LLM Serving Goodput Under Latency SLOs: A Guide](https://cerebrium.ai/resources/llm-serving-goodput-latency-slos): Goodput is the request rate you sustain while requests still meet their latency SLOs. Learn to define, measure, report, and raise it for production LLM serving.
- [Reserved GPU Capacity for Production LLM Inference](https://cerebrium.ai/resources/reserved-gpu-capacity-production-llm-inference): Should production LLM inference run on reserved GPU capacity? A VP's guide to predictability, committed terms, coverage, and the baseline-plus-burst pattern.
- [vLLM Server Parameters for Inference Throughput](https://cerebrium.ai/resources/vllm-server-parameters-inference-throughput): A production tuning workflow for vLLM server parameters: set GPU memory, KV cache and max-num-seqs in dependency order to maximize throughput without OOM.
- [4-Bit LLM Inference on H100: Throughput, VRAM & Cost](https://cerebrium.ai/resources/4-bit-llm-inference-on-h100): 4-bit and FP8 LLM inference on the H100: what fits in 80GB, tokens/sec vs FP16, and cost per billion tokens. A measured guide for ML engineers.
- [Modal vs RunPod: LLM Inference Cost & Cold Starts](https://cerebrium.ai/resources/modal-vs-runpod-llm-inference-cost-cold-starts): Modal vs RunPod for LLM inference: a neutral breakdown of billing, GPU rates, idle cost and cold-start tails, ending in a workload-keyed 'pick X when' verdict.
- [Multiple Models on One GPU: Pack or Dedicate?](https://cerebrium.ai/resources/multiple-models-on-one-gpu-inference): A DevOps decision guide to running multiple models on one GPU vs GPU-per-model. When to pack, when to dedicate, and how to reclaim wasted GPU capacity.
- [OpenAI-Compatible Endpoints for Open-Source LLMs](https://cerebrium.ai/resources/openai-compatible-endpoint-open-source-llms-serverless-gpu): How to serve open-source LLMs behind an OpenAI-compatible endpoint on serverless GPU: the drop-in base_url swap, vLLM, scale-to-zero, and cost math.
- [FLUX Image API Cost Per Image: 2026 Provider Guide](https://cerebrium.ai/resources/flux-image-api-cost-per-image): What one FLUX image really costs per 1024x1024 across Replicate, DeepInfra and more, plus latency, at-scale math and a provider decision framework.
- [MI300X vs H200 LLM Inference Throughput](https://cerebrium.ai/resources/mi300x-vs-h200-llm-inference-throughput): The MI300X-vs-H200 throughput gap is a software gap. See how a portable stack hits H200 parity on ShareGPT and deploys once across both vendors.
- [Baseten Alternatives for Production LLM Inference](https://cerebrium.ai/resources/baseten-alternatives-production-llm-inference): VP-Engineering guide to Baseten alternatives for production LLM inference - Modal, RunPod, Fireworks, Together, Anyscale, SageMaker on cost, cold starts, SLAs.
- [H100 vs H200 LLM Inference Throughput: A Buyer's Guide](https://cerebrium.ai/resources/h100-vs-h200-llm-inference-throughput): Same compute, more memory. Where the H200's bandwidth actually buys LLM inference throughput, and where the H100 is still the smarter spend.
- [Disaggregated Prefill/Decode LLM Serving: A Guide](https://cerebrium.ai/resources/disaggregated-prefill-decode-llm-serving): How disaggregated prefill/decode LLM serving works: why the two phases contend for a GPU, PD topologies, KV cache handoff, KV-aware routing, and when to skip it
- [Token-Load-Aware Routing for LLM Serving](https://cerebrium.ai/resources/token-load-aware-routing-llm-serving): KV cache overlap is a proxy for load, not the objective. How token-load-aware routers protect TTFT and p99 under bursty LLM traffic.
- [EU Data Residency for LLM Inference on Serverless GPU](https://cerebrium.ai/resources/eu-data-residency-llm-inference-serverless-gpu): Picking an EU region protects data at rest, not inference. A VP's guide to the four residency surfaces of serverless GPU LLM inference and how to pin each one.
- [Sandboxing Agent-Generated Code on Serverless GPU](https://cerebrium.ai/resources/sandboxed-agent-code-execution-serverless-gpu): A GPU-specific decision framework for sandboxing agent-generated code: gVisor vs Firecracker microVMs, cold-start cost, and the agent authority boundary.
- [Canary Rollout & Rollback on Serverless GPU Endpoints](https://cerebrium.ai/resources/canary-rollout-rollback-serverless-gpu-endpoint): How to run a percentage-based canary and safe rollback on a serverless GPU endpoint, where new revisions cold-start and warm fallbacks cost money.
- [The Active-Parameter Lie: What a Mixture-of-Experts Model Actually Costs on a Serverless GPU](https://cerebrium.ai/resources/mixture-of-experts-vram-footprint-serverless-gpu): MoE models quote active parameters, but your serverless GPU bill tracks total VRAM. What Mixtral and DeepSeek-V3 actually cost to serve.
- [Serverless Training for LLMs: What It Actually Means (and Where It Breaks Down)](https://cerebrium.ai/resources/serverless-training): Serverless training for LLMs, explained honestly: what the term actually covers, where it breaks down, and when fine-tuning on ephemeral GPUs makes sense.
- [Prefix Caching for Multi-Turn LLM Agents](https://cerebrium.ai/resources/prefix-caching-multi-turn-llm-agents): Prefix caching cuts agent prefill cost and TTFT, but scale-to-zero and multi-replica scale-out destroy the cache. Here's what you actually recover.
- [Speculative Decoding on Serverless GPUs](https://cerebrium.ai/resources/speculative-decoding-throughput-serverless-gpu): Speculative-decoding benchmarks assume a dedicated GPU. See what the draft model costs on pay-per-use serverless GPUs, and when the 2-3x speedup survives.
- [Serverless Providers for AI Inference: 2026 Buyer Guide](https://cerebrium.ai/resources/serverless-provider): A buyer's framework for choosing a serverless provider for AI inference in 2026 - compare pricing, cold starts, GPUs and migration paths off hyperscalers.
- [Serverless Cloud, Explained: Cost, Scaling & When to Use](https://cerebrium.ai/resources/serverless-cloud): What serverless cloud is, how event-driven scale-to-zero works, what it costs, its trade-offs like cold starts, and how it applies to GPU and AI inference.
- [What Is a Serverless Platform? A Complete Guide to Serverless Computing](https://cerebrium.ai/resources/serverless-platform): A vendor-neutral guide to serverless platforms: how they work, core traits, types, benefits, cold starts, and serverless GPU for AI and ML inference.
- [Serverless Computing: How It Works, Costs & Cold Starts](https://cerebrium.ai/resources/serverless-computing): What serverless computing is, how it works, its pay-as-you-go pricing, cold starts, major providers, and how it powers AI and GPU inference workloads.
- [GPU Inference for AI Agent Workloads](https://cerebrium.ai/resources/gpu-inference-ai-agent-workloads): Agent workloads pay every fixed overhead once per step. Measured per-step latency, burst behaviour and what both mean for sizing GPU inference.
- [Serving Fine-Tuned LLMs on Serverless GPUs](https://cerebrium.ai/resources/serving-fine-tuned-llms-serverless-gpu): Serve your own fine-tuned checkpoint on serverless GPUs: measured weight-load times, snapshot restore, right-sizing and per-model scaling.
- [Pipecat Voice Agents: Which Stage Belongs on a GPU](https://cerebrium.ai/resources/pipecat-voice-agent-gpu-deployment): Where the latency and cost sit in a Pipecat voice pipeline: measured per-stage figures for STT, LLM and TTS, plus what co-location saves.
- [LLM Inference Cost at Scale: The Tokens-Per-Minute Math](https://cerebrium.ai/resources/llm-inference-cost-at-scale): Convert tokens per minute into an actual LLM inference bill: measured instance counts, per-minute rates and why utilisation decides it.
- [Where Latency Goes in an AI Inference Pipeline](https://cerebrium.ai/resources/network-latency-ai-inference-pipeline): Where latency really goes in an AI inference pipeline: measured region, API-hop, broker and routing costs, ranked by size.
- [NVIDIA B200 Inference: Measured Throughput and TTFT](https://cerebrium.ai/resources/nvidia-b200-inference-throughput-ttft): Measured NVIDIA B200 inference throughput and TTFT from a production pipeline, plus why cross-GPU tokens/sec comparisons mislead.
- [Concurrent Voice Sessions Per GPU: The Real Numbers](https://cerebrium.ai/resources/concurrent-voice-sessions-per-gpu): How many concurrent voice sessions fit on one GPU: measured A10 concurrency, per-stage latency budgets and the cost arithmetic.
- [AWS Alternatives for AI Workloads: What Actually Changes](https://cerebrium.ai/resources/aws-alternatives-ai-workloads): AWS alternatives for AI workloads, compared on the number that decides cost: provisioning time. Measured cold starts, Inferentia benchmarks and when to stay.
- [What a Voice AI Agent Really Costs Per Minute](https://cerebrium.ai/resources/voice-ai-agent-cost-per-minute): A measured per-minute cost breakdown for a production voice AI agent: $0.02932 per call minute, and the concurrency maths that changes it.
- [Modal Alternatives for Serverless GPU Inference](https://cerebrium.ai/resources/modal-alternatives-serverless-gpu-inference): Compare Modal alternatives for serverless GPU inference on cold starts, tail latency, GPU breadth and pricing model, using measured restore-time benchmarks.
- [Serverless GPU Cold Starts: Killing Voice AI Latency](https://cerebrium.ai/resources/serverless-gpu-cold-starts-voice-ai): Serverless GPU cold starts stack container pulls, weight loads, and CUDA warmup into 30-90s of delay. Here's how to kill each phase for real-time Voice AI.
- [Resources index](https://cerebrium.ai/resources): All resources.

## Contact

- Website: https://cerebrium.ai/
- Book a demo: https://cerebrium.ai/book-demo
- General inquiries: https://cerebrium.ai/contact

## Optional

- [GitHub @CerebriumAI](https://github.com/CerebriumAI): Open-source examples and tools.
- [Privacy policy](https://cerebrium.ai/privacy)
- [Terms of service](https://cerebrium.ai/terms-of-service)