Verdict: Kimi K3 is the first open-weight AI model that genuinely competes with the top closed frontier systems on real work, not just benchmarks. Released July 16, 2026, by Beijing-based Moonshot AI, the 2.8-trillion-parameter model trails only Claude Fable 5 and GPT-5.6 Sol on overall capability, yet took the #1 spot on Arena.ai's Frontend Code leaderboard — a human-voted coding benchmark that Anthropic and OpenAI had dominated. For builders, the significance is structural: the gap between "download it yourself" and "pay a frontier lab per token" has essentially closed, at least for coding and long-context work.
Last verified: 2026-07-31 · Pricing, benchmark scores, and hardware specs are vendor-reported and volatile — re-check before committing to a production stack.
TL;DR
- 2.8 trillion parameters in a Mixture-of-Experts design (896 experts, 16 active per token) — the largest open-weight model ever shipped (Moonshot blog).
- 1-million-token context window with native image understanding — enough for an entire codebase or years of business records in one prompt.
- API pricing: $3/M input, $0.30/M cached input, $15/M output — roughly a third of Claude Fable 5's $10/$50 and well under GPT-5.6 Sol's $5/$30 (Moonshot platform docs).
- #1 on Frontend Code Arena with 1,679 Elo, beating Claude Fable 5 (1,631) and GPT-5.6 Sol (1,618) on 483,895 blind human votes (Arena.ai leaderboard, July 2026).
- Self-hosting is not for hobbyists: the MXFP4 checkpoint needs ~1.4 TB of GPU memory and 64+ accelerators in a supernode configuration.
What Is Kimi K3?
Kimi K3 is Moonshot AI's flagship large language model, launched July 16, 2026, and available through the Kimi web app (kimi.com), Kimi Work desktop app, Kimi Code terminal tool, and the Moonshot API. Full model weights were released by July 27, 2026 under the Kimi K3 License (a modified-MIT-style license permitting commercial use), making it the first open-weight model in the "3-trillion-parameter class" (Moonshot blog; Moonshot API docs).
"Open-weight" means anyone can download the trained model files, inspect them, fine-tune them, and run them on their own hardware — no API key, no per-token bill. This is the mechanism that lets a Chinese startup ship frontier-level intelligence to developers globally, including those who need data residency, air-gapped deployment, or simply no vendor lock-in.
The model is built for three workload types where long context and sustained reasoning matter more than snappy single-turn chat: long-horizon coding (multi-file refactors, compiler development, terminal agent tasks), agentic knowledge work (deep research reports, interactive dashboards), and complex reasoning. Moonshot itself states that K3's "overall performance still trails the most powerful proprietary models, Claude Fable 5 and GPT 5.6 Sol," but that it "demonstrated frontier-level performance across our evaluation suite, consistently outperforming other tested models" (Moonshot blog).
How Does Kimi K3's Architecture Work?
Kimi K3's architecture has two layers worth understanding: the Mixture-of-Experts routing that makes a 2.8T model affordable to run, and the attention innovations that let it handle a million tokens without the cost exploding.
Mixture-of-Experts: 16 of 896, not all at once
K3 uses a sparse Mixture-of-Experts (MoE) design. Instead of activating the entire 2.8-trillion-parameter network for every token, a router selects 16 of 896 specialized sub-networks ("experts") per token. Only about 1.8% of the model's total capacity fires for any given input — Moonshot calls this "Stable LatentMoE" (Moonshot blog).
The practical effect: the total knowledge capacity is enormous (you can store a lot in 2.8T parameters), but the per-token compute cost is closer to a much smaller model. Active parameters are estimated at 40–60 billion per token, roughly double Kimi K2.6's 32 billion (morphllm.com). This is why a model that sounds apocalyptic on a spec sheet — 2.8 trillion parameters! — can price its API at $3/M input rather than something a startup cannot afford.
Kimi Delta Attention: the trick that makes 1M context cheap
Standard transformer attention is quadratic: double the context length and you roughly quadruple the attention cost. At a 1-million-token context, that curve is brutal — the KV cache (the memory the model uses to remember earlier tokens) dominates everything.
Kimi Delta Attention (KDA) is Moonshot's workaround. It is a hybrid linear-attention mechanism: most layers use a linear-attention formulation whose cost grows closer to linearly with sequence length, interleaved with full-attention layers at a 3:1 ratio (three linear layers for cheap local structure, one full-attention layer for sharp global recall) (arXiv:2510.26692, the Kimi Linear paper). Moonshot reports this cuts KV-cache memory by up to 75% and delivers up to 6× faster decoding at 1M-token context — or 6.3× depending on which Moonshot figure you cite (Moonshot blog; morphllm.com; arXiv:2510.26692).
Why this matters for builders: the 1M-context APIs from OpenAI and Anthropic typically charge a long-context premium because serving those windows with standard attention is expensive. KDA flattens that premium out of the cost structure — K3's $3/$15 pricing is the same whether you send 1,000 tokens or 1,000,000.
Attention Residuals: a smarter skip connection
The second architectural change is Attention Residuals (AttnRes). In a standard transformer, residual connections add each layer's input back to its output — a "skip path" that makes deep networks trainable. Attention Residuals replace that fixed unit-weight addition with a learned weighted sum: each layer selectively retrieves representations from earlier layers based on an attention score, rather than accumulating everything uniformly (Moonshot blog; Sebastian Raschka, architecture notes).
Moonshot reports this gives "consistent scaling gains" — the benefit grows with model size — at the cost of roughly 4% extra training time and ~2% extra inference cost (Sebastian Raschka). Combined with KDA and the sparse MoE, Moonshot claims K3 achieves ~2.5× better overall scaling efficiency than Kimi K2 — meaning the same compute budget produces materially more intelligence (Moonshot blog).
Notably, K3 also drops RoPE (rotary positional embeddings) entirely in favor of NoPE (no positional embeddings) across all layers — inherited from the Kimi Linear research line, and a first for a frontier-scale model (Sebastian Raschka).
How Does Kimi K3 Perform on Benchmarks?
Every K3 benchmark in the table below is vendor-reported by Moonshot. The AI community has flagged that open-lineage models keep producing stunning vendor numbers, and benchmark contamination (test data leaking into training data) is a live concern. Treat these as Moonshot's claims until independent harnesses land — typically a few weeks after release (morphllm.com; benchlm.ai).
That caveat matters, but so does the honest read of the numbers: even with a discount for vendor inflation, K3 lands in the frontier tier.
Coding and agentic benchmarks (Moonshot-reported)
| Benchmark | Kimi K3 | What it measures | Source |
|---|---|---|---|
| Frontend Code Arena | 1,679 Elo (#1) | Human-voted front-end coding tasks | Arena.ai (independent) |
| Terminal-Bench 2.1 | 88.3% | Terminal/CLI agent tasks | Moonshot blog |
| BrowseComp | 91.2% | Single-agent web research, no context compression | Moonshot blog |
| Program Bench | 77.8% | Program synthesis | Moonshot blog |
| FrontierSWE | 81.2 | Agentic software engineering | Moonshot blog |
| DeepSWE | 67.5% | Hard multi-step SWE tasks (#1 published at release) | Moonshot blog; aireleasetracker.com |
| SWE Marathon | 42.0% | Long-horizon task execution | Moonshot blog |
The Frontend Code Arena result is the standout because it is not a vendor benchmark. Arena.ai runs Elo-style blind voting: real developers see two anonymous models generate front-end code side by side and pick the winner. K3 entered the board at #1 with 1,679 Elo from 483,895 votes, placing ahead of Claude Fable 5 (1,631) and GPT-5.6 Sol (1,618). It won six of seven task domains — Brand & Marketing, Reference-Based Design, Data & Analytics, Consumer Product, Simulations, and Content-Creation Tools — losing only the Gaming category to Fable 5 (Arena.ai; fourweekmba.com; santageai.com). That is a 17-position jump from Kimi K2.6's #18 spot.
Reasoning and knowledge benchmarks
| Benchmark | Kimi K3 | What it measures | Source |
|---|---|---|---|
| GPQA Diamond | 93.5% | Graduate-level science QA (strongest open-weight score at launch) | Moonshot blog |
| Humanity's Last Exam (w/ tools) | 56 | Frontier knowledge + tool use | Moonshot blog |
| MMMU-Pro | 81.6% | Multimodal (image + text) understanding | Moonshot blog |
| MathVision (w/ Python) | 97.8% | Visual math with code execution | Moonshot blog |
On GPQA Diamond — the graduate-level science reasoning benchmark that even domain-expert humans struggle with — K3's 93.5% was the highest open-weight score published at launch, ahead of Claude Opus 4.8's reported 91.0% and roughly matching GPT-5.5's 93.5% (hokai.io; Moonshot blog). GPQA is largely saturated at the frontier — the top proprietary models cluster within a few points of each other — so a 93.5% from an open model is a real achievement even with vendor-result caveats.
On broader agentic work, K3 trails the top two closed models. On GDPval-AA v2 (the Artificial Analysis agentic benchmark across 44 occupations), K3 scored 1,668 Elo — second place, but clearly behind Claude Fable 5 (1,760) and GPT-5.6 Sol (1,748) (Moonshot blog; codersera.com). The general pattern: K3 wins or ties on coding and long-context agentic tasks, loses on broad reasoning, soft-skill dialogue, and open-ended creative writing where Fable 5 and GPT-5.6 Sol feel more polished (five.reviews).
Where K3 falls short
Independent testing flagged two real weaknesses worth knowing before committing:
- Hallucination rate rose to 51% on AA-Omniscience versus 39% for predecessor K2.6 — accuracy gained 13 points but the model also makes up more facts, which matters for any workload where correctness is load-bearing (five.reviews; hokai.io).
- No SOC 2, ISO 27001, or HIPAA disclosed — documentation is Chinese-first, and as a Chinese-vendor-hosted API it carries data-residency risk under China's National Intelligence Law. Self-hosting the open weights is the compliance path (hokai.io; aitoolsrecap.com).
If your workload is factual lookup, regulated, or requires named compliance certifications, verify on your own data before deploying.
How Much Does Kimi K3 Cost?
K3's pricing is flat across the full 1M-token context — no long-context premium, which is the economic case for KDA architecture.
| Provider | Input (per M tokens) | Cached input | Output | Context |
|---|---|---|---|---|
Moonshot API (kimi-k3) |
$3.00 | $0.30 | $15.00 | 1M, flat |
OpenRouter (moonshotai/kimi-k3) |
$3.00 | varies | $15.00 | 1M |
Sources: Moonshot platform docs; morphllm.com.
For comparison, Claude Fable 5 lists at roughly $10/$50 per M tokens and GPT-5.6 Sol at $5/$30 — K3's output rate is roughly a third of Fable 5's and half of Sol's. On Artificial Analysis's blended Intelligence Index, K3 measured $0.94 per task, cheaper than GPT-5.6 Sol ($1.04) and about half of Claude Opus 4.8 ($1.80), though well above open peers like GLM-5.2 ($0.32) and DeepSeek V4 Pro ($0.04) (hokai.io).
The pricing structure makes K3 the sweet spot if you need frontier-tier coding and reasoning at medium budget. Cheaper open models exist — Ling 3.0 Flash at 124B and DeepSeek V4 serve many coding tasks at a fraction of the cost — but they do not match K3 on long-context agentic work where the 1M window and KDA actually matter.
Can You Self-Host Kimi K3?
This is the part most coverage glosses over. The download is ~594 GB in native MXFP4 safetensors; loaded for serving, K3 needs roughly 1.4 TB of fast GPU memory before the KV cache for a 1M-token context. A 16-bit copy would run about 5.6 TB (k3-kimi.com; oflight.co.jp; Hugging Face blog).
Moonshot recommends a supernode configuration with 64 or more accelerators — that is 8 nodes of 8× H100 80GB, roughly 5.12 TB of aggregate GPU memory with the interconnect bandwidth needed to route across 896 experts (Moonshot blog; oflight.co.jp). A single 8-GPU H100 node (640 GB) cannot even load the weights, let alone serve them.
| Config | Aggregate GPU memory | Can it run K3? |
|---|---|---|
| 1× RTX 5090 (32 GB) | 32 GB | No — under 1/40th of the weights |
| 8× H100 80GB (1 node) | 640 GB | No — cannot even load the weights |
| 16× H100 80GB (2 nodes) | 1.28 TB | Marginally short |
| 64× H100 80GB (8 nodes) | 5.12 TB | Yes — Moonshot's minimum recommendation |
Source: oflight.co.jp.
The practical floor is reserved capacity on a cloud GPU cluster — roughly $50/hour on AWS/Azure/GCP for 64× H100-class instances, or on-prem infrastructure costing hundreds of thousands of dollars (aitoolsrecap.com). Native MXFP4 hardware (NVIDIA Blackwell B200, AMD MI400) roughly doubles throughput versus emulation, cutting the node count (Hugging Face blog; dev.to).
For nearly everyone reading this, self-hosting is not happening on day one. The realistic paths:
- Use the hosted API (Moonshot, OpenRouter) for most workloads.
- Wait for community-quantized GGUF builds — smaller, CPU-runnable, useful for testing but losing capability at aggressive compression. These usually appear within days of a major open-weight drop.
- Run K3 on managed inference providers (Together AI, Fireworks, Northflank) that handle the cluster orchestration for you.
For builders exploring the open-weight frontier, Moonshot contributed its KDA prefix-caching implementation upstream to vLLM, so the canonical inference stack already supports K3 out of the box. SGLang and TensorRT-LLM are viable on builds with KDA support; single-machine tools like llama.cpp and Ollama are out of scope at this scale (oflight.co.jp; dev.to). If you want a self-hostable model that runs on a single workstation today, a 7B–70B model like GLM-5.2 on consumer hardware is the right scale, not a 2.8T MoE.
Why Kimi K3 Matters if You Are Not a Frontier Lab
The structural story is not "a Chinese model scored high on benchmarks." It is that the cost curve of frontier intelligence has bent again, and faster than most people expected.
Three shifts worth tracking:
Open weights now reach the frontier tier. A year ago, open models were a tier behind the closed leaders. K3 lands within a few points of Claude Fable 5 and GPT-5.6 Sol on the metrics that matter for coding work, and beats both on the independent Frontend Code Arena. For a deeper look at the closed-vs-open decision framework — including when open weights actually win — see our open-weight vs closed AI models builder's guide.
Long-context economics changed. KDA's 75% KV-cache reduction is why K3 can price a 1M-token context flat at $3/$15. This puts pressure on every closed lab that currently charges a long-context premium, and it makes previously uneconomic workloads — entire codebase refactors, year-of-customer-history analysis in one prompt, repository-scale agentic coding — viable for small teams. Our Chinese AI models decision guide covers where DeepSeek, Kimi, GLM, and Qwen each fit if you are choosing across the open-weight landscape.
The "buy vs host" math flipped for some workloads. If you are paying $50/M output tokens to a closed lab and K3's $15/M output serves your workload at parity, self-hosting on managed inference or even reserved cloud GPU capacity can pay back within weeks at scale. The caveat is the self-hosting footprint — 1.4 TB of weights and 64+ accelerators is infrastructure, not a workstation task. The self-hosting guide for Laguna S 2.1 walks through the same buy-vs-host calculation at smaller scale if you want a template before tackling K3.
What This Means for You
If you are a developer doing agentic coding or long-context work: try the Kimi K3 API via kimi.com or OpenRouter at $3/$15. The 1M context and exposed reasoning traces (Moonshot streams the model's thinking as separate deltas) make it a strong fit for multi-file refactors, deep research, and debugging agent behavior — areas where you currently pay a long-context premium to Anthropic or OpenAI.
If you care about data residency or compliance: the open weights are the path. Self-hosting needs real infrastructure (64+ accelerators), but managed inference providers like Together AI or Fireworks are the shortcut if you cannot build a cluster. Note that Moonshot's hosted API is a Chinese-vendor product and carries NI Law data-residency risk — not suitable for regulated workloads without your own deployment.
If you are choosing between open models: K3 wins on capability, but cheapers peers win on price. Ling 3.0 Flash at 124B and DeepSeek V4 serve many coding tasks at a fraction of K3's cost. Reach for K3 when you specifically need the 1M-context window or frontier-tier coding quality; reach for the smaller open models when you need volume at the lowest per-token price.
If you are tracking AI policy: the open-weights debate is now a live policy fight in Washington. More than 230 companies signed the Open Weights and American AI Leadership letter in July 2026, with Anthropic notably absent — see our coverage of the Anthropic open-weights position and the decision guide for Chinese AI models for the regulatory context.
FAQ
Q: Is Kimi K3 better than Claude or GPT-5?
A: No, not overall. Moonshot itself states K3 trails Claude Fable 5 and GPT-5.6 Sol on broad capability. However, K3 beats both on the independent Arena.ai Frontend Code leaderboard (1,679 Elo vs Fable 5's 1,631 and Sol's 1,618), and it leads several coding benchmarks like Program Bench (77.8) and SWE Marathon (42.0). For long-context coding work specifically, K3 is competitive; for open-ended reasoning, dialogue, and creative writing, the closed leaders still feel more polished.
Q: Is Kimi K3 free to use?
A: The model weights are free to download and the license (Kimi K3 License, modified-MIT-style) permits commercial use. The hosted API is not free: $3 per million input tokens, $0.30 for cached input, and $15 per million output tokens, with no long-context premium. A 10–30% top-up bonus promotion runs through August 11, 2026 (Moonshot platform docs).
Q: Can I run Kimi K3 on my own computer?
A: Realistically, no. The native MXFP4 weights need ~1.4 TB of GPU memory to serve (the download itself is ~594 GB), and Moonshot recommends 64 or more accelerators configured as a supernode. A single 8× H100 node (640 GB) cannot even load the weights. Community GGUF quantizations for smaller hardware are expected but will still be multi-hundred-GB at any usable quality level. If you want a self-hostable model on consumer hardware, look at 7B–70B models like GLM-5.2 instead.
Q: What is Kimi Delta Attention and why does it matter?
A: Kimi Delta Attention (KDA) is a hybrid linear-attention mechanism that interleaves cheap linear-attention layers with full-attention layers at a 3:1 ratio. It cuts KV-cache memory by up to 75% and delivers up to 6× faster decoding at 1M-token context, which is why K3 can offer flat $3/$15 pricing across the full context window rather than charging a long-context premium like most frontier APIs.
Q: What is the context window on Kimi K3?
A: 1,048,576 tokens (1 million), roughly 750,000 words. K3 also has native image understanding, so the context can include text and images together. The max output is 131K tokens by default, extendable to 1M.
Q: Does Kimi K3 hallucinate more than its predecessor?
A: Yes, according to independent testing. K3's accuracy climbed from K2.6's 33% to 46% on AA-Omniscience (a 13-point gain), but the hallucination rate rose from 39% to 51%. The model is more capable and more confident — which means more wrong answers when it does not know. Test on your own data before deploying on any factual workload.
Discussion
0 comments