What Kimi-Linear-REAP-35B-A3B-Instruct is
Kimi-Linear-REAP-35B-A3B-Instruct is an open-weight, instruction-tuned causal language model published by Cerebras. It is designed to generate and understand text, including code, mathematical solutions, reasoning traces, long-context answers, and function-calling requests. The model was released as an MIT-licensed checkpoint and is intended to be downloaded and run through compatible inference software rather than consumed as a separately priced hosted Cerebras model.
The model belongs to the Kimi Linear family but is not the original Moonshot AI checkpoint. Cerebras produced it from Kimi-Linear-48B-A3B-Instruct using REAP, short for Router-weighted Expert Activation Pruning. The published release date is November 6, 2025. In Cerebras's current model catalog, it is best understood as an efficiency-oriented derivative: it preserves the general purpose of the larger base model while reducing the number of experts and total parameters that must be stored.
The name describes the main architecture and compression choices. “35B” refers to approximately 35 billion total parameters, while “A3B” indicates approximately 3 billion activated parameters per token. “Instruct” identifies the instruction-tuned version, intended to follow user requests rather than serve as a raw base model.
How REAP compression works
A sparse mixture-of-experts, or MoE, model contains multiple specialist sub-networks called experts. A router examines each token and selects a subset of those experts for processing. This means the model can have a large total parameter count without using every parameter for every token.
Cerebras applied a 30% expert-pruning rate to the Kimi-Linear model. The resulting checkpoint has 180 experts and activates 8 experts per token. REAP uses information from router gate values and expert activation norms to identify experts that can be removed. Importantly, the method keeps the router's input-dependent selection behavior for the experts that remain. This differs from expert-merging approaches, which combine expert weights and can change how routing works.
According to the supplied model research, the pruning is a one-shot compression process and does not require additional fine-tuning after pruning. The practical result is a 35B-total-parameter model derived from a 48B model, with approximately 3B parameters active for each token. This can reduce memory and deployment requirements compared with the uncompressed checkpoint, although the model remains large and is not a lightweight model in absolute terms.
Verified technical specifications
| Specification | Details |
|---|---|
| Model | Kimi-Linear-REAP-35B-A3B-Instruct |
| Provider and publisher | Cerebras |
| Underlying checkpoint | Moonshot AI's Kimi-Linear-48B-A3B-Instruct |
| Architecture | Sparse mixture-of-experts causal language model |
| Total parameters | 35 billion |
| Activated parameters | Approximately 3 billion per token |
| Experts | 180 after pruning |
| Activated experts | 8 per token |
| Layers | 27 |
| Attention heads | 32 |
| Context length | 1,048,576 tokens |
| License | MIT |
| Primary output | Text |
| Hosted API price | Not specified for this checkpoint |
The one-million-token context limit is a documented model-card specification, not a guarantee that every deployment can process a full million-token prompt at practical speed or within available memory. Runtime limits can also depend on the serving framework, hardware configuration, context allocation, and quantization choices.
Coding, reasoning, and other capabilities
Kimi-Linear-REAP-35B-A3B-Instruct is intended for general instruction following with particular relevance to coding, agentic coding, mathematics, function calling, general reasoning, and long-context question answering. It can be used for tasks such as generating code from a specification, explaining an unfamiliar codebase, working through mathematical problems, extracting information from lengthy documents, or producing structured requests for external tools.
Function calling is supported according to the supplied model information. This allows an application to provide tool definitions and ask the model to produce calls that an orchestration layer can execute. The model itself does not execute external tools, browse the web, or provide a separate web-search service. Developers still need to validate generated arguments, run tools securely, and return results to the model.
The model card reports results that are close to those of the uncompressed Kimi-Linear-48B-A3B-Instruct across several evaluated tasks, although the exact outcome varies by benchmark. Reported results include 87.2 on HumanEval, 83.6 on MBPP, 30.2 on LiveCodeBench using the stated evaluation range, 40.0 on AIME25, 80.8 on MATH-500, and 37.2 on LongBench v2. FRAMES was reported at 52.3; the model card notes that this benchmark relies more heavily on internal factual knowledge and showed a larger degradation after pruning.
Those benchmark figures are provider-reported evaluation results rather than a universal performance guarantee. Actual results depend on prompt design, sampling settings, context size, hardware, evaluation methodology, and the particular version of the serving stack. The evidence supports a useful balance between compressed deployment and broad language-model capability, but it does not establish that the model will outperform every smaller or larger alternative.
Context and output limits
The model has a documented context length of 1,048,576 tokens, making it suitable for unusually long source files, large document collections, extended conversations, and long-running analysis workflows. A context window includes the input prompt and the generated continuation, so a full-length prompt leaves less room for output.
No authoritative maximum generation-token limit is provided for this exact checkpoint in the supplied research. Users should therefore treat the one-million-token figure as the total context capacity, not as a promise of one million input tokens plus unlimited output. The effective output limit will be set by the model implementation, serving framework, memory configuration, and request parameters.
Long context also has a cost in operational terms. Even with sparse activation, attention-state memory and the storage of model weights can become substantial as the prompt grows. A deployment that supports the advertised context length may still need distributed inference, careful batching, quantization, or conservative concurrency settings.
Deployment and serving
The checkpoint can be loaded with Transformers using its custom model implementation. The model documentation also lists compatible vLLM releases, SGLang, Docker Model Runner, and quantized-model workflows as deployment options. Cerebras documents vLLM serving with tensor parallelism, automatic tool choice, and the Kimi K2 tool-call parser.
Because support for Kimi-Linear can depend on the version of the serving framework, operators should verify compatibility before building a production system. The model card's use of custom model code also means that a Transformers deployment may require enabling trusted remote code. That setting should be evaluated as a software-supply-chain decision and used only when the checkpoint and environment are trusted.
The sparse architecture reduces active computation relative to a dense model with a similar total parameter count, but it does not eliminate the need to store the model's total weights. The 35B checkpoint therefore offers a lower-memory path than the 48B source model, not the hardware profile of a small local model. Substantial memory and, for demanding workloads, parallel hardware may still be required.
Pricing and availability
Kimi-Linear-REAP-35B-A3B-Instruct is available as an open-weight model under the MIT license. The supplied model documentation does not list an official Cerebras-hosted inference price, input-token price, output-token price, subscription plan, or maximum generation-token limit for this exact checkpoint.
That pricing structure makes the model different from a hosted API model. Running it locally or on rented infrastructure avoids a vendor token tariff for the checkpoint itself, but the operator pays for hardware, storage, electricity or cloud runtime, engineering, monitoring, and maintenance. The lower parameter count and sparse activation pattern may improve the deployment economics compared with the original 48B model, but the actual cost depends on hardware and workload utilization.
Main strengths and limitations
Strengths
- Reduced size relative to its source model: 30% expert pruning produces a 35B-total-parameter checkpoint from the 48B Kimi-Linear model.
- Low active parameter count: approximately 3B parameters are activated per token, with 8 of 180 experts selected.
- Very long context: the documented 1,048,576-token context supports large documents and extended code or reasoning workflows.
- Broad task coverage: the model targets coding, mathematics, reasoning, function calling, and general text generation.
- Open deployment: the MIT license and listed Transformers, vLLM, SGLang, Docker Model Runner, and quantization paths support self-hosted experimentation.
Limitations
- Still hardware-intensive: 35B total parameters and a million-token context can require substantial memory and distributed infrastructure.
- No official hosted price: users must operate the checkpoint or arrange infrastructure themselves; there is no supplied Cerebras per-token price for this model.
- Potential quality regressions after pruning: reported results are generally close to the uncompressed model, but some tasks degrade, with a larger reported drop on FRAMES.
- Text only: the model does not natively accept images, audio, or video and does not generate images, audio, or video.
- Deployment compatibility matters: custom model support and Kimi-Linear-aware serving versions may be necessary.
- Unknown maximum output: the supplied documentation does not specify a separate maximum generation length.
When to choose this model
Choose Kimi-Linear-REAP-35B-A3B-Instruct when you want an open-weight model for self-hosting and need a combination of coding, reasoning, tool-use, and very long-context capabilities. It is particularly relevant when the original 48B Kimi-Linear checkpoint is too expensive or memory-intensive, but a smaller model would impose an unacceptable capability or context trade-off.
It is also a reasonable research target for testing MoE compression, long-context applications, local coding assistants, document analysis, and agent workflows that require function-call generation. Its MIT license can be useful for deployments that need an open model rather than a closed hosted endpoint, subject to the operator's own compliance and security review.
Another option may be more appropriate when simplicity, low latency, or minimal hardware cost is the priority. A smaller dense model can be easier to deploy and operate even if it has a shorter context window or less capability. The original Kimi-Linear-48B-A3B-Instruct may be preferable when preserving the unpruned model's quality is more important than reducing deployment requirements. A managed API may also be a better fit for teams that do not want to maintain inference infrastructure, although this exact checkpoint has no supplied official hosted Cerebras price.
Bottom line
Kimi-Linear-REAP-35B-A3B-Instruct is a compressed, open-weight sparse MoE model that targets a practical middle ground between the larger Kimi-Linear checkpoint and smaller deployments. Its defining features are REAP-based 30% expert pruning, approximately 3B active parameters per token, an unusually large 1,048,576-token context, and support for coding, reasoning, mathematics, and function calling. The trade-off is that the model remains operationally demanding, has no documented hosted token price, and may lose performance on some tasks after pruning. For teams prepared to run their own infrastructure, it offers a technically substantial long-context model with lower requirements than its 48B source checkpoint.