Wafer vs. Cerebras

Cerebras serves a curated set of models at very high published decode speeds, while Wafer builds a dedicated endpoint for the open model you choose and tunes it to your TTFT, throughput, and end-to-end latency targets.

Introduction and methodology note

Wafer is an inference platform for performance-sensitive production workloads: products where time to first token (TTFT), output tokens per second (TPS), or end-to-end (E2E) response time decides the user experience or the unit economics. It profiles your real request mix, builds a dedicated endpoint around your model and performance targets, and keeps testing batching, decoding, quantization, engine, kernel, and hardware configurations after launch. It also runs a pay-per-token serverless API, and reports 10T+ tokens of continual inference.

Cerebras runs its own inference service. Its shared API serves a short list of models, and its Dedicated Inference tier reserves capacity for enterprise customers. Both expose OpenAI-compatible chat completions and both sell to teams where speed decides the product. They diverge on which number gets optimized. Cerebras competes on single-stream decode for the models it hosts. Wafer tunes whichever of the three metrics your product depends on: TTFT for short turns, TPS for long outputs and throughput per node, and E2E (roughly TTFT plus output tokens divided by TPS, plus queueing) for the full response.

Methodology. Wafer figures come from Wafer's own published pages, linked inline, and were re-verified on October 29, 2026. Cerebras figures come from Cerebras's own published pricing and documentation pages, are stated as plain text, and were re-verified on October 29, 2026. Cerebras's pricing page did not render per-token rates, so the rates quoted here come from its per-model docs pages. TTFT, TPS, and E2E claims are self-reported by each vendor or by the customer who measured them, on different models. Test both on your own prompts, output lengths, and concurrency.

TL;DR

• Cerebras publishes far higher single-stream decode (about 3,000 tok/s for gpt-oss-120b, about 1,850 tok/s for qwen-3.8-27b) than Wafer (430 tok/s on Qwen3.6-35B-A3B), so long outputs finish much sooner on Cerebras.
• In YC's production voice test, average LLM latency per turn was 379 ms on Wafer and 674 ms on Cerebras (YC case study), on different models; on short turns, TTFT and load behavior decided E2E, not decode speed.
• Choose Cerebras for maximum TPS on its supported models; choose Wafer when you need a specific open model held to TTFT, throughput, or E2E targets on your traffic.

Quick comparison

Where the vendors differ: decode speed vs the whole response

Cerebras's differentiator is decode speed. Decode time is output tokens divided by published TPS (derived). TTFT is excluded because Cerebras does not publish it, and the models differ.

On long outputs, Cerebras finishes decoding about 3 s sooner, and that gap is real. On a 100-token turn, the decode gap is about 200 ms, which TTFT and queueing can erase. That is what the YC test shows: a slower-decoding stack produced lower average turn latency on short spoken answers.

Cerebras is ahead on single-stream decode, a management API for deployments, and custom-weight hosting. It is also cheaper per request on list price: gpt-oss-120b costs 10,000 x $0.35 / 1M + 1,500 x $0.75 / 1M = $0.004625 for a 10,000-in, 1,500-out request, against 10,000 x $0.22 / 1M + 1,500 x $3.39 / 1M = $0.007285 for Wafer's GLM-5.3 (derived; different and larger model).

Why teams choose Wafer over Cerebras

E2E latency measured on short turns

YC ran GLM-5.2 on Wafer, GPT-4.1 mini on OpenAI, and Gemma 4 31B on Cerebras across 4,168 LLM turns in its voice office-hours simulator.

The derived gap is (674 - 379) / 674 = 43.8%, matching the 44% on the case page. The models differ and these are YC's own measurements, so this does not show Wafer is faster on the same model. It shows how one team's deployed stacks compared on short spoken answers.

TTFT and throughput published at each load step

Wafer's Qwen3.6-35B-A3B benchmark publishes the full curve on one 8x MI355X node:

Success stayed at 100% through 50 RPS. Cerebras publishes decode speed but no TTFT or aggregate throughput on the pages reviewed.

Targets written for regulated, real-time workloads

Neon Health moved GLM-5.1 to a Wafer dedicated endpoint and cut p50 client-observed TTFT from 800 ms to 550 ms at about 25% higher peak load, against a 600 ms contract target, with a signed BAA and US-only data residency. Brilliant reports about 250 ms TTFT and 300+ output tokens per second after Wafer tuned prefix caching and speculative decoding. Both are customer-reported.

If a TTFT, TPS, or E2E number is your acceptance test, start a dedicated endpoint benchmark with Wafer and compare it against your current Cerebras numbers.

Best use cases for Wafer

Voice agents and avatars

Short spoken turns are TTFT-bound. Wafer tunes the endpoint for your p50 TTFT target and holds it as call volume rises, as in Neon's deployment.

How Cerebras compares: its decode speed is higher on the models it lists, which helps long responses more than short voice turns.

Throughput per node at a TTFT ceiling

When the metric is aggregate TPS within a TTFT budget, Wafer tunes for tokens per node. Its GLM-5.2 post reports 2,626 tok/s per node at 2.4 RPS on a 20K-in, 1K-out workload with a 60% cache hit rate, at 0.81 s p50 and 2.22 s p95 TTFT.

How Cerebras compares: it does not publish aggregate throughput or TTFT under load on the pages reviewed.

Teams that want the model choice to stay open

Wafer has published results on GLM, Qwen, Kimi, and DeepSeek models. On Kimi K3, a 2.8T-parameter model, Wafer reports 952 tok/s per 8x MI355X node and 118 tok/s single stream on a 1,024-in, 400-out workload.

How Cerebras compares: Dedicated supports many families (Qwen, GPT-OSS, Llama, Mistral, GLM, Kimi, DeepSeek, Gemma 4), but it is enterprise-only.

Best use cases for Cerebras

Maximum single-stream decode on supported models

If your bottleneck is long output at high TPS on gpt-oss-120b or qwen-3.8-27b, Cerebras publishes about 3,000 and 1,850 tok/s. Wafer does not publish single-stream numbers in that range, and on 1,500-token outputs the derived decode gap is about 3 s.

Reserved capacity with custom weights

Cerebras Dedicated Inference deploys fine-tuned weights behind a stable endpoint ID, with immutable model versions, replica counts, and a Management API.

Platform overview of Wafer

Dedicated endpoints with performance targets

You supply model, traffic shape, and SLO (a TTFT, TPS, or E2E target); Wafer builds the endpoint and keeps optimizing it. Dedicated Inference carries a 99.9% monthly availability SLA with credits of 10%, 15%, or 30%, capped at 40%, per the SLA page. The public SLA lists no latency target.

Continual inference loop

Wafer profiles whether latency or throughput is limited by scheduling, decoding, kernels, memory pressure, or hardware fit, tests candidates, deploys the measured winner, and repeats as traffic changes. In one DigitalOcean engagement, the loop raised DeepSeek V3.2 aggregate throughput at concurrency 64 from 548 to 2,165 tok/s (internal testing).

Serverless OpenAI-compatible API

The serverless docs list POST /v1/chat/completions, /v1/responses, /v1/messages, and GET /v1/models. Busy models return 429 server_overloaded with Retry-After, and errors can arrive mid-stream, per the errors page.

from openai import OpenAI
client = OpenAI(base_url="https://pass.wafer.ai/v1", api_key="YOUR_WAFER_API_KEY")
r = client.chat.completions.create(model="GLM-5.3",
    messages=[{"role": "user", "content": "Hello!"}], max_tokens=128)

Models and capabilities

The models page documents GLM-5.3: 1,048,576-token context, tools, JSON schema output, n greater than 1, no vision, and reasoning efforts none, low, high, max. Reasoning tokens bill as output and add to TTFT and E2E, so set the effort per route.

Zero data retention

Send Wafer-ZDR: required. Unsupported models return HTTP 422 model_zdr_not_supported. See the ZDR docs.

curl https://pass.wafer.ai/v1/chat/completions \
  -H "Authorization: Bearer $WAFER_API_KEY" -H "Wafer-ZDR: required" \
  -d '{"model":"GLM-5.3","messages":[{"role":"user","content":"Hi"}]}'

Measuring TTFT, TPS, and E2E on your own prompts

Run the same script against both base URLs. TTFT is time to the first content token; TPS is output tokens over decode time.

import time
t0 = time.perf_counter(); first = None; n = 0
for c in client.chat.completions.create(model="GLM-5.3", messages=msgs,
        stream=True, stream_options={"include_usage": True}):
    if c.choices and c.choices[0].delta.content and first is None: first = time.perf_counter()
    if c.usage: n = c.usage.completion_tokens
end = time.perf_counter()
print(f"TTFT {first-t0:.3f}s  TPS {n/(end-first):.0f}  E2E {end-t0:.3f}s")

If a model returns no usage chunk, count output tokens with its tokenizer instead.

How to choose

Switching from Cerebras to Wafer

1. Create a Wafer key in the app and add credits.
2. Change base_url and model.
3. Re-run quality and performance tests with the measurement script above; you are likely changing models, so compare TTFT, TPS, and E2E at your real output lengths.
4. Add 429 retry handling. Wafer returns server_overloaded under capacity pressure.

Before:

client = openai.OpenAI(base_url="https://api.cerebras.ai/v1", api_key=CEREBRAS_KEY)
r = client.chat.completions.create(model="qwen-3.8-27b", messages=msgs)

After:

client = openai.OpenAI(base_url="https://pass.wafer.ai/v1", api_key=WAFER_KEY)
r = client.chat.completions.create(model="GLM-5.3", messages=msgs)

What to watch:

• Cerebras-specific parameters passed via extra_body (reasoning_format, clear_thinking) need review on Wafer.
• Dedicated custom weights: no Wafer equivalent on the pages reviewed.
• Decode speed: Wafer's published single-stream TPS is lower. Long-output routes can get slower E2E; short-output routes are decided by TTFT.
• Partial migration: often best. Keep Cerebras for long-output generation on its fast models; move TTFT-critical and throughput-at-load paths to Wafer.

Neon's case states a dedicated endpoint can reach production in under two weeks. That is a stated capability, not a guarantee.

FAQ

Is Wafer faster than Cerebras? On single-stream decode, no: Cerebras publishes about 3,000 tok/s on gpt-oss-120b against Wafer's 430 tok/s on Qwen3.6-35B-A3B. On average turn latency in YC's production test, Wafer measured 379 ms and Cerebras 674 ms, on different models. Long outputs favor Cerebras; short turns depend on TTFT. Benchmark your own prompts.

What throughput can a Wafer endpoint sustain? Wafer reports about 15,000 tok/s of aggregate output from one 8x MI355X node on Qwen3.6-35B-A3B at TTFT p95 under 4 s, and 952 tok/s per node on Kimi K3. Both are Wafer's own measurements.

Does Cerebras offer a dedicated option? Yes. Dedicated Inference reserves capacity for enterprise customers and supports custom weights of the same architecture. SLA terms are not published on the pages reviewed.

What does Cerebras cost? Its model docs list gpt-oss-120b at $0.35 input and $0.75 output per 1M tokens, and qwen-3.8-27b at $0.99 and $1.49. Against Wafer's GLM-5.3 ($0.22 input, $3.39 output), Cerebras is cheaper on output and pricier on input, on different models. Adding a payment method gives a one-time $5 credit that expires 30 days after activation; a pricing-page footnote says the free tier is not intended for production use.

Which hardware does Wafer use? Per its AI info page, NVIDIA and AMD GPUs. Its published benchmarks run on AMD MI355X. Validate availability per model.

Does Wafer's SLA cover latency? The public SLA covers 99.9% monthly availability on Dedicated Inference and lists no latency target. Neon reports a TTFT target written into its own contract.

Want TTFT, TPS, and E2E numbers on your own traffic? Get started on Wafer and benchmark a dedicated endpoint against your current Cerebras results.

Related Articles

• Oct 2026: Wafer vs. Together AI
• Oct 2026: Wafer vs. Groq