The Cerebras Wafer Chip: What a 900,000-Core Slice of Silicon Means for Token Costs

One Chip, One Model, Zero Networking

Most AI inference today runs on clusters of NVIDIA H100s or B200s stitched together with NVLink and InfiniBand. A 70B-parameter model needs 4–8 GPUs; a frontier model like Llama 3.1 405B needs 16+. Every token generated involves moving activations and KV-cache fragments between chips — and that networking is where most of the latency (and a surprising chunk of the cost) hides.

Cerebras took the opposite bet. The WSE-3 ("Wafer-Scale Engine 3") is a single chip the size of a dinner plate — 46,225 mm² of silicon, 900,000 AI cores, and 44 GB of on-die SRAM. It is, quite literally, an entire 12-inch wafer that was never cut into individual dies. Models up to ~70B parameters fit on a single WSE-3 with weights resident in on-chip memory. Models up to 405B fit across a small number of wafers connected by Cerebras' SwarmX fabric.

The architectural payoff: no off-chip memory traffic during inference. Weights live where the compute lives. KV-cache stays local. The result is throughput numbers that look implausible until you remember the underlying physics changed.

The Throughput Numbers (May 2026)

Independent benchmarks from Artificial Analysis and confirmed by Cerebras' own published figures:

These aren't theoretical peaks — they're the rates you get from the public Cerebras Inference API, single-stream, at full context.

Why Speed Changes the Cost Equation

Tokens per second isn't just a UX metric. It directly compresses the unit economics of inference, in three compounding ways:

1. Hardware amortization per token

A GPU costs the same per hour whether it generates 50 or 500 tokens/sec. If Cerebras runs the same model 20× faster, the per-token hardware cost falls roughly 20× — even if the wafer itself is more expensive than an H100. Cerebras' published API price for Llama 3.3 70B sits at $0.60 / M input, $0.60 / M output as of May 2026. Compare that with hosted Llama 3.3 70B on Together AI ($0.88 / M) or Fireworks ($0.90 / M) — both running on H100/B200 clusters.

2. No idle GPU tax during long generations

Long-form generation (agent traces, code synthesis, deep research summaries) keeps GPU clusters busy without adding new requests. On a Cerebras wafer, that same 30-second generation finishes in 1–2 seconds — freeing the chip for the next request. Higher tokens/sec = higher requests/sec at the same hardware footprint = lower amortized cost per call.

3. Agent loops collapse

This is where the cost story gets dramatic. Agentic workloads chain 5–20 LLM calls per user task. On a typical GPU host generating ~60 tok/s on Llama 3.3 70B, a 10-step agent loop with ~500 output tokens per step takes ~85 seconds end-to-end. On Cerebras at ~1,800 tok/s, the same loop runs in ~3 seconds. Same token count, same prompt structure — but the wall-clock cost of the orchestrator (the queue worker, the retry timer, the user-facing spinner) drops by ~28×.

If you're running agentic frameworks like OpenClaw, Hermes, or Paperclip, the per-step latency is what dominates your monthly bill once you hit non-trivial volume.

The Per-Token Price Comparison

Here's how Cerebras' published API rates stack up against the hosted alternatives for comparable open-weight models:

Cerebras isn't the cheapest per token — DeepInfra is consistently lower on the headline rate. What Cerebras sells is throughput per dollar. If your bottleneck is "how fast can I finish this agent run?" rather than "how cheaply can I run a batch overnight?", the wafer changes the math.

Where Cerebras Wins (and Where It Doesn't)

Wins:

• Real-time agents. Sub-second time-to-first-token plus 1,000+ tok/s sustained means you can run a 5-step agent loop inside a single user click.
• Coding copilots. Long-context code generation (8K–32K output tokens) finishes in 5–15 seconds instead of 1–3 minutes.
• Conversational voice. Voice-driven assistants need <500ms turn latency. Cerebras is one of the few inference paths that delivers it on 70B+ models without aggressive quantization.
• Live RAG. Document chat over large corpora, where retrieval + generation needs to feel instant.

Doesn't win:

• Pure batch. If you're processing 10M documents overnight, the Batch API discounts on hosted GPU clusters (50% off on OpenAI, Anthropic, and most open-weight hosts) usually beat Cerebras' rate.
• Frontier closed models. Cerebras only serves open-weight models — no GPT-5, no Claude, no Gemini.
• Tiny-context, low-latency-insensitive tasks. A classification call that fits in 200 tokens and runs in 50ms on any host doesn't benefit from wafer-scale physics.

The Cost-of-Speed Tradeoff in Practice

For most teams, the right framing isn't "cheapest per token" — it's "what's the cheapest way to hit my latency SLA?" A team that needs sub-2-second agent responses on Llama 3.3 70B has three realistic options:

1. Cerebras at ~$0.60/M with 1,800 tok/s and ~150ms TTFT.

2. Groq at ~$0.79/M with ~280 tok/s and ~250ms TTFT (LPU architecture, also no off-chip weight movement at inference time).

3. Quantized H100 hosting at ~$0.40/M but with 60–80 tok/s — too slow for the SLA, so it gets ruled out.

Cerebras and Groq are the only options that meet the latency constraint. Between them, Cerebras typically wins on long-output workloads (code, agents); Groq often wins on chat-style turns where TTFT matters more than sustained throughput.

You can model this exact tradeoff for your workload in the Token Cost Calculator — drop in your steps, output length, and target latency, and it shows you the per-month cost at each of these hosts.

What This Means for the Token-Pricing Floor in 2026

Wafer-scale and LPU architectures (Cerebras, Groq, and increasingly SambaNova) are pushing the floor on per-token open-weight pricing down by another 30–50% through 2026. They're doing it without the headline-grabbing model launches — just by extracting more tokens per second from the same dollar of silicon.

The downstream effect: agentic workloads that were marginal on cost six months ago are now profitable. Voice, real-time research, and code-generation copilots that require both speed and 70B+ class reasoning are moving from "experimental" to "default" line items in product budgets. The Cerebras wafer didn't lower the unit price of a token by itself — but it lowered the *opportunity cost* of using larger models in latency-bound workflows. That's the more important story.

If you're modeling what your agent-heavy workload would cost on Cerebras vs. a GPU host, our AI Agent Loop Cost Estimator lets you swap the model and host side-by-side and see the wall-clock + dollar impact in one view.

---

*Sources: Cerebras Inference API pricing page (cerebras.ai/inference, retrieved May 2026); Artificial Analysis Q1 2026 throughput benchmarks; Together AI, Fireworks, Groq, and DeepInfra public pricing pages (May 2026).*