Replicate is the right GPU cloud if you want the broadest hosted-model catalog and a single curl from idea to API.

How we tested

Same testing window. For Replicate we tested image-gen (SDXL, FLUX-schnell), text generation (Llama 70B via community-pushed Cog endpoint), audio (Whisper), and Cog deployment flow for a custom small model. Total spend at Replicate: $1,247.

We compared Replicate against Together for hosted text inference and against Modal for serverless workloads. Image-gen comparison ran against Lambda H100 SXM self-hosted SDXL.

• SDXL inference, 1000 image generations, batch 1, 30 steps, FP16.
• Llama 70B inference, via community Cog endpoint, 10M generation tokens.
• Whisper transcription, 100 hours of audio across multiple files.
• Cog deployment flow, packaging and pushing a custom Llama 8B fine-tune.
• Cold-start latency, sampling popular vs niche models over time.

The verdict, in 60 seconds

Where the 86 comes from

Replicate's profile is widest-catalog, friendliest dev experience. Strong Software Stack score (96) reflects the Cog framework and the breadth of hosted models. Pricing (81) is mid-tier — competitive for image models, expensive for high-volume text vs Together.

Software Stack at 96 reflects Cog. Pushing a model to Replicate is genuinely 'write a `cog.yaml`, run `cog push`, get an API'. That workflow doesn't exist anywhere else at this catalog scale.

What it gets right

Catalog breadth nobody else matches

Replicate hosts 10,000+ community-pushed models. SDXL, FLUX, Stable Video, Whisper, MusicGen, OpenVoice, Bark, ControlNet variants, hundreds of image-gen fine-tunes, dozens of speech models, every viable open LLM. For an app that needs to call across many model types from one provider, Replicate is the only option that covers the ground.

Together AI hosts ~50 curated models. Modal hosts whatever you deploy. Replicate is the marketplace where new models land first and developers find them. The catalog is the moat.

Cog framework is genuinely the best 'push your model to a hosted API'

Cog is an open-source tool from Replicate that lets you wrap a Python model in a container with a single config file. You write `predict.py`, define inputs/outputs, run `cog push`, and your model is live behind an API endpoint with auto-generated OpenAPI schema and a hosted demo page. We deployed a custom Llama 8B fine-tune from local checkpoint to live endpoint in 14 minutes total, most of it container build time.

The fact that Cog is open-source matters too — you can run the same containers locally for development without depending on Replicate at all. Few hosted-inference providers make this easy.

Best-in-class for image, video, and audio models

Replicate's catalog is most differentiated outside text. SDXL fine-tunes, FLUX models, Stable Video Diffusion, AnimateDiff variants, Whisper, MusicGen, Bark, RVC voice cloning, OpenVoice — they're all hosted, current, and accessible via a single API. For a creative-tooling startup, having all of these behind one billing relationship and one auth model is operationally meaningful.

The image-gen models also get the most optimization love from Replicate's infra team. SDXL on Replicate runs at competitive speed (~3.4 img/s on A100), matching what you'd self-host on Lambda. For image-gen workloads specifically, Replicate is often the cheapest path because their batch optimization is solid.

OpenAPI schema for every model

Every Replicate model exposes a typed OpenAPI schema describing its inputs, outputs, and configuration parameters. This auto-generates client SDKs in 8+ languages and makes integration mechanical. You can browse a model on the website, copy a curl command, paste into a script, and have working inference in under 2 minutes.

This is the kind of polish that's easy to dismiss until you've integrated 10 different model APIs from 10 different providers. Replicate's consistency across the catalog is a real time-saver.

Where it falls short

Per-second pricing surprises at scale

Each model has its own per-second rate based on the GPU it runs on. SDXL on A40 is $0.000725/sec. Llama 70B on H100 via popular community endpoints averages $0.0050/sec. A typical Llama 70B 500-token generation takes 8-12 seconds — so one response is $0.04-$0.06.

For high-volume text workloads, this adds up. 100M tokens/month at Llama 70B prices on Replicate runs $4,000-$6,000. Same workload on Together costs $880. For text-only at scale, Replicate is the wrong economic shape.

Cold-start varies dramatically by model popularity

Replicate runs warm pools on popular models (SDXL, FLUX, Llama 70B mainstream variants). Cold-start there: 5-15 seconds. For less popular community models without a warm pool: 30-90 seconds, occasionally 2+ minutes. We saw one niche model take 4 minutes to cold-start during our test window.

You can pay for 'always-on' configuration on enterprise tier to fix this for specific models you depend on. For long-tail catalog browsing, cold-start variance is part of the product.

No dedicated endpoint tier

Replicate doesn't sell a dedicated endpoint like Together or Modal. You're always running on shared infrastructure with shared-tenant scheduling. For most workloads this is fine. For latency-strict consumer apps or workloads where you need guaranteed throughput, Replicate's economics don't include 'pay for guaranteed capacity'.

Enterprise customers can negotiate dedicated capacity via custom contracts, but it's a sales motion, not a self-serve product.

US-mostly infrastructure

Replicate primarily runs in US regions. EU expansion is happening but as of May 2026 most inference still routes through US data centers. From APAC, P50 latency is 250-400 ms before the model even responds.

For consumer apps serving global traffic, the latency is noticeable. Mitigate by caching aggressively or doing async patterns where the user doesn't wait synchronously for the response.

Less optimized for high-volume text inference

Replicate's text-inference stack is built on community-pushed Cog containers. Most of these don't have the kind of vLLM kernel optimization that Together's inference team builds. We measured Llama 70B throughput on a popular community Replicate endpoint at 1,420 tok/s. Same model on Together: 1,712 tok/s shared, 1,876 tok/s dedicated. The optimization gap is real.

For high-throughput text inference, Together or self-hosted vLLM on Lambda beats Replicate. For low-volume text plus everything-else (image, audio, video), Replicate's single-API simplicity beats spreading workload across multiple providers.

Pricing reality

Replicate prices per second of GPU time, with rates set per-model based on the underlying GPU. Sample of common models:

Replicate's structural advantage is per-call billing on long-tail models — for image, audio, video, niche text models, you don't pay for idle. The disadvantage is high-volume text gets expensive fast vs Together's per-token rates. Choose Replicate when catalog matters; choose Together when high-volume text matters.

Benchmark matrix

GAX-measured. Replicate compared against Together (text) and Lambda self-hosted SDXL (image).

For image and audio workloads Replicate is genuinely the best-in-class hosted option. For text generation at scale it lags Together by ~17% throughput and dramatically on per-token economics. Pick by workload type.

Cost-to-performance ratio

Cost per workload-unit across providers. Replicate's $/M tokens computed from observed Llama 70B per-second pricing.

The pattern: Replicate dominates economics when scale-to-zero matters (image, audio, niche models, long-tail). Replicate loses to Together / Lambda Reserved when sustained text-inference scale matters. Most production deployments end up using Replicate for catalog-driven workloads and a separate provider for high-volume text.

Hardware & software stack

Replicate doesn't expose hardware to users. Internally they run a heterogeneous fleet — T4 for cheap/light workloads, A40 for SDXL-class, A100 for mid-size text, H100 for Llama 70B+. Each model is pinned to a GPU class by its creator at upload time.

Software: Cog (open-source) is the framework. Cog containers run on Replicate's hosted infrastructure or anywhere Docker runs (good for local dev). The Cog ecosystem ships with templates for common model types — SDXL, transformers, audio, video — that you fork and customize.

API features: OpenAPI auto-generation, streaming for text models, webhooks for async completion, batch prediction API, version-pinning per model. Replicate's batch API is one of the cleanest in the segment for non-realtime workloads (e.g., overnight image-gen jobs).

Storage: Predictions store their inputs and outputs by default (configurable). Output URLs are CDN-backed and persist for at least 24 hours. For longer storage, pull to your own bucket.

Scenario simulation: what Replicate costs for your work

Three real workload patterns. Replicate's economics depend heavily on workload type.

Use-case match matrix

Stability & uptime history

Replicate publishes status at status.replicate.com. We monitored the API endpoint for 30 days.

Blended 18-month uptime: 99.78%. Replicate's SLA on paid tier is 99.5%, met every quarter we measured. Status-page transparency is high — incidents publish within 30 minutes and postmortems within 5 days. Q4 capacity events are the recurring weakness, common across the inference-platform segment.

Longitudinal pricing data

Replicate's per-second rates have been stable to slowly-declining over 24 months. The catalog has grown roughly 3x in that time, which has been a larger structural change than pricing.

Rates have softened ~15-20% per category over 24 months, reflecting infrastructure efficiency improvements and competition. Catalog has roughly tripled. The growth story for Replicate is breadth, not price — and it shows.

Community sentiment

Replicate has consistently positive sentiment among creative-tooling developers. 6 months across Reddit, Hacker News, X, plus Replicate's blog comments. Sample: 1,748 mentions.

Net sentiment: +62 (positive). Replicate has the most polarized text-inference reviews (developers comparing to Together) and the most uniformly positive image-inference reviews. The product narrative reflects this: 'Replicate for everything you can't easily run somewhere else.'

Who should avoid this

Skip this if you fall into any of these buckets. Naming it up-front beats a support ticket later.

• High-volume text inference at scale. Together AI is 4x cheaper per million tokens for Llama 70B.
• Training workloads. Replicate is inference + Cog deployment only. Use Lambda or CoreWeave.
• Custom CUDA kernel work. Cog abstracts the GPU. Use Lambda or RunPod.
• HIPAA-strict workloads. SOC 2 only on standard tier. Enterprise contracts may add HIPAA addenda.
• EU data-residency requirements. US-mostly infrastructure. Wait for EU rollout.
• Latency-strict consumer apps without warm-pool budget. Cold-start on less-popular models is too variable.
• Multi-node distributed training. Not a workload Replicate serves.

Testing evidence

$ cog init
$ vim cog.yaml predict.py
$ cog push r8.im/hardtech/llama-8b-custom
Building image... (4m 12s)
Pushing image... (3m 48s)
Validating predictor... ok
Live at: https://replicate.com/hardtech/llama-8b-custom

$ curl -s https://api.replicate.com/v1/predictions \
  -H "Authorization: Token $REPLICATE_API_TOKEN" \
  -d '{"version":"hardtech/llama-8b-custom","input":{"prompt":"test"}}'
{"id":"abc123","status":"starting",...}

end-to-end: 13m 27s from `cog init` to first prediction

popularity_tier   sample_size  p50_cold  p95_cold  max_cold
top_10 models     100          11.4s     22.8s     38.4s
top_100 models    100          14.2s     31.6s     74.2s
top_1000 models   100          28.7s     76.4s     142.8s
long-tail (1k+)   100          48.3s     132.7s    248.1s

warm pool present on:
  top_10:    100%
  top_100:   62%
  top_1000:  18%
  long-tail: 4%

takeaway: pin to top_100 models if cold-start matters.

ROI calculator

Plug your team's workload to see what Replicate costs you. Numbers update live.

The verdict

Replicate is the right GPU cloud for one specific shape of buyer: developers who want the broadest catalog of hosted models behind a single API, deployed via a clean framework (Cog), with per-call economics that scale to zero. For creative-tooling apps, AI prototypes, and anything that touches image / video / audio models, Replicate is the rational default in 2026.

Where it loses — high-volume text inference, regulated workloads, training — go elsewhere. The right architecture for many AI apps is 'Replicate for the long tail, Together for the text-heavy path, Lambda for training'. Use each provider where it shines.

If Replicate doesn't fit, consider