Cerebras Trillion-Parameter Model Deployment: How Multi-Wafer WSE-3T Pipelines Reach 1,000+ Tokens per Second

Cerebras has described how it serves trillion-parameter language models on its own hardware. Instead of fitting a model on one chip, it spreads the weights across the on-chip memory of several WSE-3T wafers and runs them as a pipeline. The company reports speeds of roughly 1,000 to 2,000+ tokens per second per request. Kimi K3, a model of about 3 trillion parameters, serves as the headline example.

What Cerebras is actually doing

Cerebras keeps model weights in on-chip memory on the wafer rather than in external high-bandwidth memory. That is the core of its speed advantage, because token generation is usually limited by how fast weights can be read. The catch is capacity: a frontier-scale model will not fit on one wafer.

The answer is to shard the model across multiple WSE-3T wafers and chain them in a pipeline. Each wafer holds a slice of the network, and tokens flow from one wafer to the next. With many requests in flight at once, every wafer stays busy.

The Kimi K3 example

Kimi K3 has roughly 3 trillion parameters. Cerebras deploys it with 4-bit weight quantization and a workload averaging 256k tokens per request.

A back-of-envelope calculation shows why multiple wafers are needed. At 4 bits per weight, 3 trillion parameters take about 1.5 TB for weights alone. The publicly documented WSE-3 carries 44 GB of on-chip SRAM. WSE-3T specifications may differ, but if per-wafer capacity is in a similar range, the weights alone point to dozens of wafers. That is an estimate, not a figure Cerebras has confirmed here.

The long context matters too. At 256k tokens, the key-value cache that stores conversation state competes with the weights for memory. How Cerebras budgets for that is as important as the weight layout.

How this differs from earlier Cerebras offerings

Cerebras's public API previously added Qwen 3.8 27B, a dense model of 27 billion parameters running at about 1,500 tokens per second. This new deployment targets models more than 100 times larger at a comparable speed range. The earlier result showed fast serving of a small model, while this one addresses whether that speed survives at frontier scale.

Why it matters beyond Cerebras

Decode speed is becoming a product feature in its own right. Agentic workloads chain dozens of model calls, and per-call latency adds up. A model that answers at 1,000+ tokens per second changes what is practical, such as long reasoning traces or multi-step coding loops that would feel slow on a typical GPU deployment.

It also shifts the trade-off between model size and responsiveness. Teams have often picked smaller models because large ones were too slow to serve interactively. If trillion-parameter models can run at this pace, that compromise gets harder to justify for latency-sensitive products.

There are open questions. Pipelines across many wafers introduce hops between devices, and how well that latency is hidden under heavy concurrent load is not something the headline speed numbers alone can answer. Pricing, availability, and which other trillion-scale models will be offered have not been disclosed.

What to watch

Three things will determine whether this matters in practice: sustained speed at high concurrency, cost per million tokens compared with GPU-based serving, and how many large open-weight models Cerebras adds beyond Kimi K3. Cerebras's past pattern of adding models to its public API, as with Qwen 3.8 27B, suggests more large models could follow. That is an inference from its track record, not an announcement.

Reference: https://www.cerebras.ai/blog/how-we-deploy-trillion-parameter-frontier-models-on-cerebras