2.8 Trillion Parameters, Free to Download: Inside Moonshot AI's Kimi K3

I've spent a lot of this year reading model cards that describe things I can look at but never touch. Kimi K3 is different. Moonshot AI announced it on July 16, 2026, and eleven days later, on July 27, put the full weights on Hugging Face under a custom license. It's a 2.8 trillion parameter model, and you can download it.

Moonshot's own phrasing for this is "the world's first open 3T-class model." That's marketing rounding, not an official weight class, but the underlying number is real: 2.8 trillion total parameters, sitting on Hugging Face right now under Moonshot's custom Kimi K3 License, downloadable by anyone with the hardware to run it. Only 104 billion of those parameters activate on any given token, which is the detail that makes the whole thing feasible at all.

What makes July 2026 the moment to pay attention is the combination: frontier-class scale, an open license, and a gap between announcement and weights short enough that this doesn't feel like a staged rollout. By the end of this piece you'll know what's actually new in the architecture, where K3 wins and loses against the closed frontier, and what it would cost you to run or call it.

Kimi K3 at a glance

Who's behind it

Moonshot AI is a Beijing company founded in 2023 by Yang Zhilin, a CMU PhD who did research stints at Google Brain and Meta AI, along with co-founders. The name is a Pink Floyd reference, after The Dark Side of the Moon.

The company's backers include Alibaba, Tencent, HongShan, and IDG. In May 2026, Moonshot raised $2B at a $20B valuation, led by Long-Z Investments (Meituan's venture arm), with state-backed participants China Mobile, Tsinghua Capital, and CPE Yuanfeng also in the round. That brought the company's total raised to roughly $3.9B across six months. There's reportedly talk of a pre-IPO round targeting a valuation as high as $50B and a Hong Kong listing, though that's unconfirmed.

The strategic backdrop matters here. Moonshot is one of several Chinese labs — alongside DeepSeek, Qwen, and GLM — shipping open-weights models at increasingly serious scale, in a climate shaped by US compute export controls. That combination pushes toward efficiency-first architecture decisions rather than just throwing more accelerators at the problem. K3's quantization choices, which I'll get to, read as part of that same pressure: a model this large has to be cheap to serve, or nobody but the vendor can afford to run it.

What's actually new

The headline architectural idea in K3 is Kimi Delta Attention, or KDA — a hybrid linear-attention mechanism. Of the model's 93 layers, 69 run KDA and 24 run Gated MLA, a full-attention mechanism, with one additional dense layer. That's roughly a 3:1 interleave of linear to full attention. Linear attention is what makes a 1,048,576-token context window tractable in the first place: full attention's cost grows quadratically with sequence length, so a model that leaned entirely on Gated MLA at this context size would be far more expensive to run. Interleaving in the full-attention layers is Moonshot's way of keeping the quality benefits of true attention at a fraction of the layers, rather than paying for it everywhere.

The second idea is Attention Residuals, or AttnRes. Instead of every layer uniformly accumulating information from everything before it, AttnRes lets a layer selectively retrieve from earlier layers' attention. It's a routing decision applied to what a layer looks back at, not just what it attends to within its own input.

The third piece is the Mixture-of-Experts design itself, which Moonshot calls Stable LatentMoE. K3 has 896 experts, and each token routes to 16 of them plus 2 shared experts — routing happens in latent space using a technique Moonshot calls "Quantile Balancing." That sparsity is why 2.8 trillion total parameters becomes 104 billion active parameters per token: you're only ever running a sliver of the model. Moonshot claims roughly 2.5x scaling-efficiency gain over the prior Kimi K2 generation from this design, though that's a vendor number.

Underneath all of this, K3 trains with a Per-Head Muon optimizer and a SiTU-GLU activation function, and uses a 160K vocabulary. On the deployment side, the model is quantization-aware trained for MXFP4 weights with MXFP8 activations — meaning the low-precision format isn't bolted on after training, it's what the model was trained to expect. That's a serving-cost decision as much as an architecture one: MXFP4 is native on the latest NVIDIA and AMD accelerators, and training for it directly avoids the quality loss that post-hoc quantization usually costs you. Even so, the weights are about 1.4TB on disk.

Open original ↗

Architecture summary, based on Moonshot AI's technical report, Jul 2026.

Spec sheet

The numbers

Open original ↗

Moonshot-reported, model card, Jul 2026.

The honest summary, in Moonshot's own words from the announcement: K3 "still trails" Claude Fable 5 and GPT-5.6 Sol overall, but consistently outperforms every other model they tested. Both halves of that sentence check out against the model card.

Where K3 genuinely leads is long-horizon agentic work. On SWE-Marathon it scores 42.0 against Claude Fable 5's 35.0 and GPT-5.6 Sol's 39.0. On MCPMark-Verified it hits 94.5 versus 87.4 and 92.9. On BrowseComp it's 91.2 against 88.0 and 90.4. On AutomationBench it's 30.8 against 29.1 and 29.7. These are the benchmarks about sustained, multi-step tool use and browsing, and K3 wins all four against both named frontier competitors.

Where it trails is frontier coding and holistic task quality. On FrontierSWE, K3 scores 81.2 against Claude Fable 5's 86.6. On DeepSWE it's 67.5 against GPT-5.6 Sol's 73.0. And on GDPval-AA v2, an Elo-style holistic evaluation, K3 comes in at 1686 — third place, behind Claude Fable 5 at 1747 and GPT-5.6 Sol at 1736. That's a real gap, not a rounding difference.

Vendor-reported (Moonshot model card, "max" effort, Jul 2026)

These numbers all come from Moonshot's own model card — treat them as vendor-reported until an independent lab reproduces them.

Independent (Artificial Analysis, Jul 2026)

Artificial Analysis ranks K3 first of 98 models in its class on their Intelligence Index — more than double the class median. But their independent measurement also flags something the model card doesn't: K3 is slow and verbose. Output speed of 32.9 tokens per second is roughly half the class median of 64.8, time to first token is more than double the median, and running Artificial Analysis's full index cost $2,437.41 largely because K3 generates about 30% more output tokens than the median model to get there.

What it's like to use

Moonshot claims 90%+ cache-hit rates on coding workloads, which is where that $0.30 rate actually matters — a coding agent that keeps re-sending the same repository context should be paying the cache-hit price most of the time, not the cache-miss one. Moonshot also claims K3 needs 21% fewer output tokens than the prior K2.6 generation to do equivalent work. Even accounting for that efficiency gain, per-token pricing on K3 is roughly 3-4x higher than K2.6's rates from its era (around $0.95/$4).

You can reach K3 through the kimi.com apps on iOS, Android, and HarmonyOS, the Kimi Work desktop app, the Kimi Code CLI, Kimi Enterprise, or directly through the API at platform.kimi.ai. Third-party hosts including OpenRouter have offered it since the weights dropped.

If you want to self-host instead of calling the API, the realistic floor is about 1.4TB of aggregate GPU memory — think eight nodes of eight 80GB accelerators each, which is the shape Moonshot itself points to, recommending 64 or more accelerators. Moonshot recommends serving through vLLM, SGLang, or TokenSpeed, and has upstreamed KDA prefix-caching support directly into vLLM, which should help with exactly the kind of repeated-context coding workloads the cache-hit pricing is built around.

One behavioral note worth knowing before you build on this: K3 has thinking turned on by default, with only "max" reasoning effort available at launch (low and high tiers are promised later). Multi-turn quality degrades noticeably if you drop the thinking history between turns — if you're building a chat or agent loop on top of K3, you need to carry that state forward, not just the visible conversation.

Why it matters

The interesting thing about K3 isn't any single benchmark row. It's that a 2.8 trillion parameter model with a 1M-token context window and genuine agentic strength is now something you can download rather than something you can only rent. That changes who gets to run frontier-scale AI — not just the labs with the compute to train it, but anyone with roughly 1.4TB of GPU memory to serve it, or anyone willing to pay API rates that undercut what closed labs charge for comparable capability.

That's also pressure on the closed labs' pricing, whether or not K3 beats them outright. Moonshot says it still trails Claude Fable 5 and GPT-5.6 Sol overall, and the benchmark table backs that up on frontier coding specifically. But "still trails on some axes, leads on others, and it's free to download" is a genuinely different competitive position than "trails across the board."

If you're a solution architect deciding whether to spend time on this, my honest read is: evaluate it specifically for agentic and long-context workloads, where the SWE-Marathon, MCPMark, BrowseComp, and AutomationBench numbers suggest real strength, rather than as a general coding-assistant replacement. And do the serving-cost math carefully before you commit to self-hosting — 1.4TB of GPU memory and 64+ accelerators is not a casual infrastructure decision, and the API's cache-hit pricing may be the more practical path unless you're running this at real volume.

The verdict

Kimi K3 is the first time "frontier-scale" and "download it yourself" have meant the same model at the same time.

Moonshot is upfront about where K3 falls short, and it's worth taking them at their word on three points: multi-turn quality degrades if you drop the thinking history, the model shows excessive proactiveness — it makes autonomous decisions on minor issues you might not want it deciding — and Moonshot itself describes a "noticeable gap in user experience" against Claude Fable 5 and GPT-5.6 Sol. Add to that what Artificial Analysis measured independently: K3 runs at 32.9 tokens per second against a class median of 64.8, and it's meaningfully more verbose, generating 130M tokens to run their evaluation against a 99M median. It's a genuinely capable, genuinely open model with real agentic strength — it is not a faster or more polished one.

References

1. Official announcement — Moonshot AI ↗

2. Model card and weights — Hugging Face ↗

3. Technical report (PDF) — MoonshotAI GitHub ↗

4. Kimi K3 License ↗

5. Independent evaluation — Artificial Analysis ↗

6. API pricing — Kimi API platform ↗

7. Funding report — TechCrunch, May 7, 2026 ↗