Kimi K3: World's Largest Open-Weight Model
On July 16, 2026, Moonshot AI shipped Kimi K3 — a 2.8-trillion-parameter Mixture-of-Experts model and currently the world's largest open-weight release at that class. Headlines called it the Chinese lab's moonshot. The actual number to watch is quieter: K3 scored fourth on the Artificial Analysis Intelligence Index, behind Claude Fable 5 and GPT-5.6 Sol, but squarely ahead of Claude Opus 4.8. For a model whose full weights land on Hugging Face on July 27, 2026, that's an unusual sentence to write.
This page covers what's genuinely non-obvious about K3 — the architectural changes, the pricing trap that makes it look expensive until you check the cache hit rate, and the specific tasks where it outranks every other model, open or closed.
- Understand why 2.8T parameters doesn't mean 2.8T compute: the MoE arithmetic and how sparse activation works
- Learn the three architectural innovations in K3 (KDA, AttnRes, LatentMoE) that give it 2.5× better scaling efficiency than K2
- Know the cache-hit pricing math: why K3 costs closer to $0.30/M than $3.00/M in real coding workloads
- Place K3 in the benchmark landscape: where it leads all models, where it trails, and what the hallucination rate caveat means
- Get started with the API in three lines using an OpenAI-compatible client
The one-sentence version
Kimi K3 is an open-weight (full weights dropping July 27, 2026), 2.8-trillion-parameter sparse MoE from Moonshot AI, tuned for long-horizon agentic coding and knowledge work, with native vision and a 1-million-token context window — priced like a frontier API but often cheaper in practice because coding workloads hit the prompt cache more than 90% of the time.
Three things about K3 that aren't obvious from the headlines
1. "2.8 trillion parameters" does not mean 2.8 trillion activations per token
The headline number is dramatic, but K3 is a Mixture-of-Experts model. It has 896 expert sub-networks, and only 16 experts fire per token — that's the "Stable LatentMoE" component. The model is enormous in storage but compact in compute per forward pass. At inference, the active parameter footprint is far smaller than 2.8T. This is the same architectural trade-off as DeepSeek V4 Pro (which also uses MoE), and it's why a model this large can run efficiently on manageable hardware once the weights are self-hosted.
The practical implication: don't compare parameter counts directly between dense and MoE models. A 2.8T MoE with 16/896 experts active has a different compute profile than a 70B dense model — and a very different hardware requirement for self-hosting.
2. The cache-hit rate flips the cost math completely
K3 API pricing is $3.00/M input tokens and $15.00/M output tokens — expensive at first glance. But Moonshot offers a cache-hit price of $0.30/M input (a 10× discount), and in coding workloads the company reports cache hit rates above 90%. That means the effective per-million-token input price for an ongoing coding session is closer to $0.30–$0.45, not $3.00.
Here's the practical comparison at task-level cost (sourced from third-party evaluations):
| Model | Cost per agentic task |
|---|---|
| Kimi K3 | $0.94 |
| GPT-5.6 Sol | $1.04 |
| Claude Opus 4.8 | $1.80 |
K3 also uses 21% fewer output tokens than K2.6 — it learned to be terser — which further reduces the bill. At headline prices K3 looks premium; at realistic task prices it undercuts frontier competition.
3. The architectural innovations are training-time, not post-hoc
K3 ships three new components that are baked into the model from training:
- Kimi Delta Attention (KDA) — a hybrid linear-attention mechanism that handles the 1M-token context window efficiently without the quadratic cost of standard attention at long range.
- Attention Residuals (AttnRes) — instead of uniform accumulation across depth, AttnRes selectively retrieves representations from earlier layers, letting the model "look back" at its own earlier thinking during a long agentic run.
- Per-Head Muon and Sigmoid Tanh Unit (SiTU) — optimizer and activation improvements that contributed to what Moonshot claims is a 2.5× improvement in overall scaling efficiency versus K2.
The MXFP4 weight quantization (with MXFP8 activations) is also training-aware, not applied after the fact. This matters for quality: post-hoc quantization typically costs benchmark points; quantization-aware training largely eliminates that tax.
Where K3 sits in the benchmark landscape
K3 ranked 4th overall on the Artificial Analysis Intelligence Index (as of July 2026):
| Rank | Model | Score |
|---|---|---|
| 1 | Claude Fable 5 | ~60 |
| 2 | GPT-5.6 Sol | ~59 |
| 3 | (closed tie area) | — |
| 4 | Kimi K3 | ~57 |
| 5 | Claude Opus 4.8 | ~56 |
Where K3 leads all models (open and closed): Frontend Code Arena (ranked #1 at 1,679 points), a real-world evaluation of UI component generation and iterative visual coding. The model's 1M-token context and native vision capability contribute here.
Where to apply caution: K3's hallucination rate is approximately 51% in independent evaluations — higher than frontier closed models. The benchmark accuracy jumped from K2.6's 33% to K3's 46%, but factual grounding didn't improve at the same rate. Verify K3 outputs for factual claims; it's strongest in code and structured task completion, less reliable on open-ended knowledge questions without retrieval.
DeepSWE (long-horizon software engineering): K3 scored 67.3, the highest published score on an open-weight model as of this writing, matching frontier territory.
BrowseComp (long-context navigation, no context management): 90.4 with the 1M-token window enabled — notably achieved without any chunking or retrieval strategy, which most models require at this scale.
What K3 is designed for
Moonshot K3's training leaned into long-horizon, minimal-supervision tasks — the kind where a model has to plan, tool-call, debug, iterate, and stay coherent across a large repo or a multi-hour workflow. Specific capabilities the official blog demonstrates:
- GPU kernel optimization (CUDA/Triton-level work, not just Python wrappers)
- GPU compiler development (built a MiniTriton compiler from scratch as a benchmark task)
- Chip design and RTL verification (hardware engineering)
- Multi-agent subagent orchestration — K3 can coordinate 20+ concurrent subagents in its own Kimi Work environment
- Interactive research visualizations and dashboard generation (where the vision-first design and Frontend Code Arena #1 ranking make sense)
The "thinking mode" is always enabled at launch (maximum effort). The API does not yet support tunable effort levels — at launch, every call uses max thinking, which adds tokens. Additional reasoning effort levels are on the roadmap but not available yet.
Getting started with the Kimi K3 API
K3 uses an OpenAI-compatible API shape, so if your codebase already calls GPT or Claude via an OpenAI client shim, pointing it at Kimi is a small change:
- Sign in at platform.kimi.ai, create an API key. K3 is available under the model ID `kimi-k3`.
- Set the base URL to `https://api.moonshot.cn/v1` and the model to `kimi-k3`. The client can be the standard `openai` Python or JS SDK — or OpenRouter if you prefer a single aggregator.
- Pass images in the messages array using the standard `image_url` content type. For 1M-token tasks, no special parameter is needed — the context window is always 1M.
Kimi K3 via OpenAI SDK (Python)
import openai
client = openai.OpenAI(
api_key="YOUR_MOONSHOT_KEY",
base_url="https://api.moonshot.cn/v1",
)
response = client.chat.completions.create(
model="kimi-k3",
messages=[{"role": "user", "content": "Refactor this 5,000-line Python codebase..."}],
)
print(response.choices[0].message.content)Via OpenRouter (single API key, lets you A/B K3 against Claude or GPT easily):
Kimi K3 via OpenRouter
import openai
client = openai.OpenAI(
api_key="YOUR_OPENROUTER_KEY",
base_url="https://openrouter.ai/api/v1",
)
response = client.chat.completions.create(
model="moonshotai/kimi-k3",
messages=[{"role": "user", "content": "Review this TypeScript and suggest optimizations."}],
)
print(response.choices[0].message.content)Open weights (self-hosting, from July 27, 2026): Weights will be released on Hugging Face under Moonshot AI's organization page. The model ships in MXFP4 quantization natively; broad hardware compatibility was an explicit design goal. Full hardware requirements will be confirmed at release.
K2 vs K3: which one to reach for
You might already have K2 tooling from the Kimi K2 for Claude users page. Here's how to decide:
| Kimi K2 (1T param) | Kimi K3 (2.8T param) | |
|---|---|---|
| Total params | 1 trillion | 2.8 trillion |
| Active params / token | ~32B | ~16/896 experts |
| Native vision | No | Yes |
| Context window | 128K | 1M |
| Open weights available | Now | July 27, 2026 |
| Benchmark rank | ~7th (Artificial Analysis) | 4th |
| Output cost | Lower | $15/M (offset by cache) |
| Best for | Cost-conscious agentic tool use, self-hosting now | Long-horizon visual coding, large repos, multimodal tasks |
Reach for K3 when: you need the frontier-tier quality (top-5 models), the task is long and likely to hit the prompt cache repeatedly, or vision is required. Especially useful if you want open weights for compliance/privacy but can wait until July 27.
Stick with K2 when: you need to self-host right now, cost is the primary constraint and the task doesn't benefit from K3's extra depth, or you're already running K2 in production with working tooling.
Quiz
Check yourself
0/4Sources & further reading
- Kimi K3 official tech blog — Moonshot AI — architecture specs, scaling claims, and demonstrated capabilities
- Kimi K3 quickstart — Kimi API Platform — API documentation and model ID
- Kimi K3 on OpenRouter — aggregated pricing and benchmark overview
- Simon Willison on Kimi K3 — independent analysis including the pelican benchmark and cost breakdown
- Kimi K3 complete guide — Coder Sera — benchmark aggregation and task-level cost comparisons
- Tom's Hardware: Moonshot releases 2.8T Kimi K3 — hardware and geopolitical context
- Related: Kimi K2 for Claude users — K2 is still available now with weights you can self-host immediately
- Related: DeepSeek, Qwen & the Open-Weight Wave — broader open-weight landscape
- Related: Choosing a model — when to pick open-weight vs closed frontier