Cerebras says Kimi K3 runs across 59 of its wafer-scale chips

What Cerebras published

Cerebras has explained how it runs AI models that are far too large for any one of its chips, using Moonshot AI's Kimi K3 as the example. A post on the Cerebras blog dated 22 October 2026 says the open-weight model, which Cerebras puts at about 3 trillion parameters, can be split across 59 of the company's WSE-3T wafer-scale processors. It says deployments built this way run multi-trillion parameter models at 1,000 to more than 2,000 tokens per second.

The post opens with the problem. One WSE-3T wafer has 44 GB of memory on the chip itself, in the form of SRAM, which is much faster than the HBM stacks that sit beside a GPU. But a frontier model needs terabytes for its weights alone. Cerebras says how it bridges that gap is one of the questions it is asked most often.

Kimi K3 is a natural test case. It is one of the largest open models available, and our earlier coverage put it at 2.8 trillion parameters when vLLM sped it up by as much as 1.9 times on NVIDIA GB300 systems. Cerebras rounds it to about 3 trillion. It also repeats Moonshot's benchmark claims, 88.3 percent on Terminal-Bench 2.1 and 91.2 percent on BrowseComp, which Cerebras did not measure itself.

How the 59 wafers are counted

Cerebras calls the K3 layout an illustrative example and lists its assumptions: weights stored at 4 bits, as in the Hugging Face release, a key-value cache stored at 8 bits, and an average request of 256,000 tokens. The model has 93 layers, 69 using linear attention and 24 using full, or dense, attention.

At 4 bits, 3 trillion parameters come to about 1.5 terabytes. Divided across 93 layers, that is about 16 GB per layer. The two kinds of layer then get different treatment. A dense layer stores keys and values for every token of every request it is handling, so its memory needs grow with context length and the number of users. Cerebras gives each dense layer a wafer of its own and uses the rest of that wafer's memory for its cache, about 28 GB once the 16 GB of weights are subtracted.

A linear-attention layer keeps only a small, fixed-size state for each request, whatever the length of the context. That means two of them, 32 GB in total, can share a wafer. The 69 linear layers therefore fill 35 wafers, the last holding a single layer, and the 24 dense layers take 24 more, for 59 in all. By simple multiplication, those wafers hold about 2.6 terabytes of on-chip memory.

Using Moonshot's lower 2.8 trillion count would give about 1.4 terabytes of weights and 15 GB per layer, which would not change the wafer count. The real layers of a mixture-of-experts model also differ in size, so the 16 GB figure is an average rather than a measurement of each layer.

Why weights stay on the chip

Because each layer fits on one wafer, Cerebras says, the model weights almost never have to move and layers rarely need to be split between chips. Only activations, the intermediate results passed from one layer to the next, travel between wafers. The company says it sends them over RDMA over Ethernet, a way of writing directly into another machine's memory, at roughly 2 microseconds per hop.

That is the core of the Cerebras pitch. On GPU systems, generating each token typically means streaming weights out of HBM, and the speed of that memory sets a ceiling on how fast a single answer can be produced. Keeping the weights in SRAM next to the compute removes that bottleneck, at the price of needing many wafers to hold one large model.

How a pipeline serves many requests

The obvious objection is that a pipeline of 59 chips would leave most of them idle, with each waiting for a token to reach it. Cerebras answers that it keeps the pipeline full. While one stage processes a token for one request, the stage before it processes a token for another request and the stage before that works on a third.

In the K3 example each stage is one layer, but Cerebras says production deployments use much finer-grained stages and many more of them. Each stage can also handle a micro-batch, a small group of requests, so the number of requests in flight is roughly the number of stages multiplied by the micro-batch size. Smaller micro-batches make each request faster, and larger ones raise total throughput.

The ceiling on concurrency is memory. Every request in flight needs its own key-value cache on every dense-layer wafer, so the 28 GB left on each of those 24 wafers limits how many 256,000-token requests the system can hold at once. Cerebras walks through that calculation, but the equations appear only as images on the page and the post does not state a final number of concurrent requests for K3 in its text.

What the post does not show

The headline speed is not a K3 measurement. The 1,000 to 2,000 or more tokens per second figure is given for multi-trillion parameter models in general, and the post does not say which model, context length or load produced it. A footnote on the page says performance comparisons are based on third-party benchmarking or internal testing and that speed gains over GPU systems vary with workload, configuration, date and model, without naming the tests.

The post also proposes a better yardstick than concurrency or batch size: total token throughput per unit of power, such as tokens per second per megawatt, measured at the same output speed. That is a sensible way to compare inference systems, but Cerebras does not publish that figure for this setup. Nor does it give a price for 59 wafers or name a customer running K3.

Those gaps matter because the comparison is with GPU clusters that are themselves getting faster. Speed claims in this range are becoming more common, such as Inception's Mercury 3 diffusion model at 1,000 tokens per second, and buyers usually care about cost per token at a given speed more than about raw speed alone.

The licence question

The Cerebras post calls K3 open source, but the licence has a commercial condition. The Terminal, citing VentureBeat's report on the weights release, says companies running a Model as a Service business need a separate agreement with Moonshot once their revenue from it passes 20 million dollars over 12 months, and that very large products must display the Kimi K3 name. A cloud selling K3 tokens would fall into that category.

Cerebras does not mention the licence terms in its post. Its page points readers to its inference cloud, a free API and its sales team, so anyone planning to serve K3 commercially on Cerebras hardware would need to check those terms with Moonshot. The model has also attracted other commercial uses, including Goodfire's production cyber monitors built on Kimi K3.

What it means for fast inference

The post is a vendor explainer, and its value is in the layout rather than the benchmarks. It shows how the shift towards hybrid models that mix linear and full attention helps hardware like Cerebras's. Linear layers carry no growing cache, so they can be packed two to a wafer, and only the minority of dense layers need room for long contexts. A model built entirely from dense layers of the same size would need 93 wafers under the same assumptions.

Cerebras says the same method extends to larger models: work out the memory for weights and request state, spread the model across enough wafers and connect them into a pipeline. The open questions are the ones the post leaves blank, namely how many requests 59 wafers can serve at the quoted speeds, how much power they draw and what the system costs. Until Cerebras publishes those, the walkthrough explains how the model fits, not whether it is the cheapest way to run it.