Kimi K3 Is a 2.8-Trillion-Parameter Open-Weight Monster

Moonshot AI’s new model has 2.8 trillion parameters, can read text and images, and accepts up to one million tokens. Its weights are available to download from Hugging Face. It also performs in the same broad class as the best closed models from Anthropic and OpenAI.

That availability sounds exciting until you look at the download. It’s not something you can run on your gaming pc. Four-bit compression still leaves K3 far beyond a normal workstation.

K3 at a glance

Kimi K3	What it means
2.8T total parameters	It is the first openly released model in the three-trillion-parameter class
104B active parameters	Only part of the model works on each token
896 experts	Small specialist networks inside the model
16 routed + 2 shared experts active	The model chooses a small team for each token
1M-token context	It can accept very large documents and codebases
MXFP4 weights	The downloaded model is stored at roughly four bits per weight
Text and vision	It can understand text and images natively

K3 is currently the largest open-weight model by parameter count. “Open weight” means you can download and run the trained model. The weights use Moonshot’s own license rather than a standard open-source software license.

How can 2.8 trillion parameters be usable?

K3 is a mixture-of-experts, or MoE. Its 896 specialist networks are like departments in a large company. A router sends each token to 16 specialists, while two generalists always help.

That is why K3 has 2.8 trillion parameters in storage but uses about 104 billion for each token it generates. It still needs memory for the whole company, but it only pays the full compute cost for the small team currently working.

The two parameter counts answer different questions:

Total parameters mostly determine how much memory and storage you need.
Active parameters have a large effect on generation speed and compute.

K3 therefore behaves more like a very large 100B model while thinking, but it occupies storage like a 2.8T model. Sparse models are clever, not magic.

Kimi Delta Attention

Normal attention lets a model look back through the conversation to decide what matters next. With a million-token context, repeatedly looking through everything becomes expensive.

Kimi Delta Attention (KDA) gives the model a more compact, continually updated memory. New information can change that memory instead of forcing the model to reread every old detail in the expensive way. K3 mixes 69 KDA layers with 24 gated MLA layers, which provide occasional fuller attention.

The notebook analogy works well:

Full attention is searching every page of a notebook.
Delta attention is maintaining a useful set of notes as you read.
The occasional MLA layer checks the wider notebook when needed.

K3 also introduces Attention Residuals, which improve how information moves between layers. Their job is to keep relevant information alive through a very deep model without spending more compute.

It was built around four-bit weights

K3’s official checkpoint uses MXFP4 weights and MXFP8 activations. Four-bit models are often made by training a larger format and compressing it afterward. K3 instead used quantization-aware training during its final training stage, so it learned while accounting for the lower-precision format.

That should reduce the quality loss normally associated with aggressive compression. It also explains why the official download is already quantized rather than being a huge BF16 checkpoint.

MXFP4 is not the same thing as a typical GGUF Q4_K_M file, although both average around four bits per weight. Formats, scaling rules and hardware support differ. My beginner’s guide to LLM quantization explains the alphabet soup.

Benchmarks against Fable and Sol

Moonshot’s published results put K3 near Claude Fable 5 and GPT-5.6 Sol.

Here are five results from the official model card:

Benchmark	Kimi K3	Claude Fable 5	GPT-5.6 Sol
GPQA Diamond, hard science questions	93.5	92.6	94.1
ProgramBench, coding	77.8	76.8	77.6
Terminal-Bench 2.1, computer use	88.3	88.0	88.8
FrontierSWE, software engineering	81.2	86.6	71.3
SWE-Marathon, long coding work	42.0	35.0	39.0

Benchmarks cannot promise the same ranking for your work. Moonshot reports its own model here, so independent tests carry more weight.

The API costs $3 in and $15 out

Moonshot’s API price is $3 per million input tokens and $15 per million output tokens. At launch, providers including OpenRouter list the same base token rates.

This is really competitive for it’s performance.

Every launch provider I checked lists the same base price. Coordinated launch terms or ordinary resale economics could explain it. No public source confirms a special licensing deal. Caching, tools and web search may be billed separately.

Can I run Kimi K3 locally?

Technically yes. Practically, not on a normal workstation.

The MXFP4 weights alone are roughly 1.4 TB before metadata, caches and runtime overhead. A 24 GB graphics card can hold less than two percent of that. Even a 512 GB Mac Studio is nowhere close.

Official vLLM and SGLang recipes target datacenter hardware including NVIDIA B200, B300/GB300, H200 and H100, plus AMD MI350X and MI355X. The common deployment shape is 16 Enterpeise GPUs. Moonshot’s peak-throughput recipe scales to 32 GPUs, commonly four eight-GPU nodes. If you have 80 RTX 5090s laying around you could give it a try too.

So “local” here means a server room or a very expensive rented cluster:

Download roughly 1.4 TB of weights.
Use 16 supported high-memory accelerators for a workable deployment.
Connect them with very fast interconnects.
Run the official vLLM or SGLang recipe.

Do not try to split this across a pile of gaming PCs over ordinary Ethernet. Loading may be possible with enough combined RAM, but communication overhead would make it painfully slow.

The API is the sensible route for most people. Models in the 7B–32B range at Q4 fit far more realistic home hardware; my local AI hardware guide covers the options.

Who benefits from open weights

Few people will host K3 at home. Researchers can inspect its weights, specialist providers can deploy them, and companies with strict data rules can keep the model inside their own infrastructure.

Its design also points to Moonshot’s priorities: more experts, fewer active at once, longer memory, native vision and low-precision training from the start.

You probably will not run Kimi K3 under your desk in the near future, but who knows, the local ai space moves very fast and maybe one day it could run on a smartphone.