The short version
On July 16 Moonshot AI shipped Kimi K3, and ten days later they did the thing that actually matters: they released the open weights. It is a ~2.8-trillion-parameter mixture-of-experts model with a one-million-token context window, and it is the first open-weight release I've read where the architecture is the headline, not the parameter count.
The parameter count is a little misleading anyway. K3 is sparse — of its 2.8T total parameters, only about 50B are active per token (16 of 896 experts fire on any given step). So you get the knowledge capacity of a very large model and, per token, roughly the compute of a mid-sized one. That trade is the whole game in open-weight models right now, and K3 pushes it further than anything before it.
What Moonshot actually changed
Most "new" models are the same transformer with more data. K3 is not, and three pieces are worth understanding.
Kimi Delta Attention (KDA). Standard attention is quadratic in sequence length — double the context, quadruple the cost — which is why a million-token window has been economically silly. KDA is a hybrid linear attention: it swaps the quadratic mechanism for a linear one in a subset of layers, keeping full attention only where it earns its cost. That is the trick that makes 1M tokens affordable rather than a demo.
Attention Residuals (AttnRes). Normally each layer attends to the output of the layer just below it. AttnRes lets a layer reach back and pull representations from arbitrary earlier layers. In a deep MoE stack that matters — information stops getting bottlenecked through every intermediate layer.
Stable LatentMoE. Routing tokens to experts is where big MoE models get unstable. Moonshot route in latent space with something they call Quantile Balancing, and report ~2.5× better scaling efficiency than K2. Add a per-head Muon optimizer, a SiTU activation, and Gated MLA for KV-cache management, and the theme is consistent: every choice is about making a very large, very long-context model stable and cheap to run, not about topping one more leaderboard.
The quantization is the sleeper feature
K3's weights ship in MXFP4 — 4-bit floating point with per-block scaling — with MXFP8 activations, and, crucially, it was quantization-aware trained from the fine-tuning stage rather than squashed down afterward. So the 4-bit weights aren't a lossy convenience; they're what the model was trained to be.
This is the detail that changes who can run it. The full weights are ~1.4 TB, and Moonshot's own guidance is an 8-node cluster of 8×80 GB GPUs. That is not a laptop — but for a 2.8T model it is dramatically less iron than a naïve FP16 release would demand, and it is why "open weights" here is a real offer to serious labs rather than a press release.
How to use it
Three doors, in rough order of how quickly you'll get value:
The hosted API. K3 went live on Moonshot's platform on launch day in two variants — K3 Max for chat and agent work, and K3 Swarm Max for large-scale parallel workloads. The API is OpenAI-compatible, so trying it is a base-URL and a model-name change:
from openai import OpenAI
client = OpenAI(
api_key="YOUR_MOONSHOT_KEY",
base_url="https://api.moonshot.ai/v1", # point at Moonshot, or any host serving the weights
)
resp = client.chat.completions.create(
model="kimi-k3-max",
messages=[{"role": "user", "content": "Summarise this 900-page contract."}],
)
print(resp.choices[0].message.content)Kimi Code and the Kimi app. If you just want to feel the model, it's already wired into Moonshot's coding tool and the consumer apps (including iOS). Good for the agentic-coding story, which is where K3's reported numbers are strongest.
The open weights. For anyone who needs the model on their own metal — regulated data, air-gapped environments, custom fine-tunes — the MXFP4 weights are downloadable. This is the path that makes K3 matter strategically, and the one I'd watch: the interesting fine-tunes won't come from Moonshot.
How it stacks up against the open-weight frontier
Until last month the open-weight frontier was a three-way argument between Moonshot's own Kimi K2, the DeepSeek line, and Qwen — all excellent, all landing in the 128K–256K context range with conventional attention. K3's pitch against that field isn't "higher MMLU." It's a different shape:
Context: 1,000,000 tokens versus the ~256K everyone else tops out at — and, because of KDA, at a cost that doesn't make you flinch.
Efficiency: MXFP4-native weights and ~50B active parameters mean the serving cost per token is closer to a mid-sized model than its 2.8T headline suggests.
Agentic focus: Moonshot report the model leading on coding and browsing-style tasks — SWE Marathon 42.0, Program Bench 77.8, DeepSearchQA F1 95.0, BrowseComp 91.2, GPQA-Diamond 93.5. Those are the vendor's own numbers, so treat them as a claim to be checked, not a verdict — independent evals are still landing as I write this.
The story of open-weight models in 2026 isn't "China caught up." It's that the frontier moved from how much do you know to how cheaply can you stay coherent over a million tokens — and on that axis, K3 is currently the one to beat.
If you only take one thing from the report: the era where a long context window was a luxury feature is over. K3 makes it the default, and once it's the default, a lot of the RAG scaffolding we've all been building starts to look like a workaround for a limitation that no longer exists. That's the part I'll be thinking about.