Kimi K3 Open Weights Released: Download, License & Hardware

The wait is over. Today, July 27, 2026, Moonshot AI declared “Kimi K3 Open Day” and released the full Kimi K3 open weights — eleven days after the model’s July 16 launch, exactly on the date it promised. The 2.8-trillion-parameter checkpoint is now downloadable from Hugging Face, alongside the complete technical report, the inference code, and three of the infrastructure projects used to train it.

This is not a routine model drop. Kimi K3 is the largest open-weight AI model ever released — the world’s first open 3T-class model — and it lands with benchmark numbers that sit within striking distance of Claude Fable 5 and GPT-5.6 Sol, the strongest closed systems on the market. From today, anyone can download a frontier-class model, inspect it, fine-tune it, and run it on their own hardware. No API key, no per-token bill, no vendor in the middle.

This article covers everything that was released, what the license actually allows, the honest hardware math, how K3 stacks up against the closed frontier, and the caveats most launch-day coverage is skipping.

What exactly got released today

Moonshot didn’t just upload a checkpoint. The Open Day release is a bundle:

• The model weights — the full 2.8T-parameter model on Hugging Face at moonshotai/Kimi-K3, in native MXFP4 safetensors (~594GB). Quantization-aware trained from the SFT stage, so the MXFP4 weights are the real weights, not a lossy afterthought.
• The Kimi K3 technical report — k3_tech_report.pdf in the GitHub repo (MoonshotAI/Kimi-K3, titled “Open Frontier Intelligence”). It covers the KDA + AttnRes architecture (KDA and Gated MLA mixed at a 3:1 ratio), Stable LatentMoE training stability, the MoonViT-V2 vision encoder trained from scratch, post-training recipes, RL infrastructure for million-token contexts, and full ablations.
• Training infrastructure, open-sourced — MoonEP (the fully balanced expert-parallel training system), FlashKDA (the KDA kernel stack), and AgentEnv (the agent training environments). This is the part that matters for researchers: not just the artifact, but meaningful pieces of how it was built.
• Serving support from day 0 — Moonshot contributed a KDA-aware prefix-caching implementation to vLLM (KDA breaks conventional prefix caching), with additional kernels from NVIDIA and AMD workstreams. SGLang has a cookbook and TokenSpeed has recipes. Together AI committed to serverless K3 inference the same day weights dropped, with Fireworks AI and others expected to follow within days.

The announcement went out through Moonshot’s official channels — including a pinned post on the Kimi X account (@Kimi_Moonshot) that crossed 2 million views and 21,000 likes within its first three hours — framed around a simple message: for a technology with as far-reaching impact as AGI, a broad and open ecosystem is the most suitable foundation.

Kimi K3 at a glance

The full spec sheet, straight from the official model card:

	Kimi K3
Maker	Moonshot AI (Beijing)
Weights released	July 27, 2026 (API live since July 16)
Architecture	Mixture-of-Experts, 93 layers (1 dense)
Total parameters	2.8 trillion
Activated per token	104B
Experts	896 routed (16 active) + 2 shared
Attention	69 KDA layers + 24 Gated MLA layers, 96 heads
Context window	1,048,576 tokens (1M)
Vision	Native — MoonViT-V2 encoder (401M params), text + image input
Quantization	MXFP4 weights / MXFP8 activations (quantization-aware training)
Download size	~594GB (safetensors)
License	Kimi K3 License (modified-MIT family)
API price	$0.30 / $3.00 / $15.00 per 1M tokens (cache-hit / input / output)
Reasoning	Always-on thinking; reasoning_effort: low, high, max

For a line-by-line explanation of what each of these specs means in practice, see our Kimi K3 specifications breakdown.

The biggest open-weight model ever released

Scale is the headline. At 2.8 trillion total parameters, Kimi K3 is 75% larger than DeepSeek V4 (1.6T, the previous open-weight record holder) and nearly 3× the size of Kimi K2 (1T) from a year ago. Alibaba has signaled a 2.4T Qwen 3.8 open-weights release is coming — but it hasn’t shipped. Today, K3 stands alone in the 3T class.

Two things make this more than a vanity number. First, Kimi models have set the upper bound of open-model sizes for nine of the past twelve months — K3 extends a deliberate strategy, not a one-off stunt. Second, sparsity makes the scale usable: only 16 of 896 experts (plus 2 shared experts) fire per token, so you get a 2.8T model’s knowledge at roughly 104B parameters of compute per step. Combined with Kimi Delta Attention — which keeps a 1M-token context from scaling quadratically — Moonshot claims a ~2.5× scaling-efficiency gain over Kimi K2: each unit of compute buys about 2.5× more intelligence than before.

Benchmarks: how the open model stacks up

Here’s the context that makes today’s release matter. These are Moonshot’s matched-harness evaluation numbers (all models at maximum reasoning effort), now reproducible by anyone because the weights are public:

Benchmark	Kimi K3	Best closed rival	Rival score
Terminal-Bench 2.1	88.3	GPT-5.6 Sol	88.8
SWE-Marathon	42.0	Claude Opus 4.8	40.0
FrontierSWE	81.2	Claude Fable 5	86.6
DeepSWE	67.5	GPT-5.6 Sol	73.0
BrowseComp	91.2	GPT-5.6 Sol	90.4
MCPMark-Verified	94.5	GPT-5.6 Sol	92.9
GPQA-Diamond	93.5	GPT-5.6 Sol	94.1

The honest read: K3 wins some, loses some, and is never far behind. It beats every closed model on SWE-Marathon (long-horizon software engineering), BrowseComp (agentic browsing) and MCPMark (tool use). It trails on FrontierSWE and DeepSWE. Moonshot itself concedes Claude Fable 5 and GPT-5.6 Sol remain ahead overall — a rare moment of vendor honesty.

Independent trackers tell the same story: #2 overall on the Vals AI index, #3–4 on the Artificial Analysis Intelligence Index (score 57, level with Claude Opus 4.8 and GPT-5.5), and #1 on the Frontend Code Arena. Nathan Lambert’s assessment at Interconnects is the bluntest: “It is clearly the strongest open model ever released” — and the open-to-closed capability gap has compressed from a debated 6–9 months to roughly 3–5 months.

The launch-week demos back up the agentic claims: K3 built MiniTriton, a working Triton-like GPU compiler from scratch; designed and verified a 45nm chip in a single 48-hour autonomous run; and reproduced a computational-astrophysics research pipeline (20+ papers cross-validated, 3,000+ lines of code) in about two hours. For deeper benchmark breakdowns against specific rivals, see our comparisons of Kimi K3 vs Claude Fable 5 and Kimi K3 vs GLM-5.2.

The Kimi K3 License: what you’re actually allowed to do

Both the code repository and the model weights ship under the Kimi K3 License. In practical terms, Moonshot’s announcement says everyone can download and deploy K3 “whether for internal research and development or for integration into end-user products” — with “other use cases” deferred to the license text. That phrasing matches the modified-MIT family Moonshot used for the entire K2 series, which permits commercial use, self-hosting, fine-tuning and redistribution — with one notable precedent: K2.7-Code’s license adds an attribution requirement once a product crosses roughly 100 million monthly active users or $20 million in monthly revenue.

Two honest cautions:

• Read the LICENSE file in the repo before you build on it. A modified MIT is not MIT — the modifications are the whole story, especially around redistribution, derivative models and white-labelling.
• Open-weight is not open-source. You get the weights, inference code, an unusually detailed technical report and real training infrastructure — but not the training data or the full pipeline. You can fine-tune, distill, deploy and inspect. You cannot reproduce the training run from scratch.

For most teams — enterprises needing data residency, startups building products, researchers doing interpretability or safety work — this license is permissive enough to proceed today. For the primary source, see Moonshot’s official Kimi K3 announcement.

Can you actually run it? The 1.4TB reality

Here is the part to be brutally honest about: nobody is running this on a home rig.

The download is ~594GB in native MXFP4. Loaded for serving, you need roughly 1.4TB of fast GPU memory — before the KV cache for a 1M-token context. Moonshot’s own guidance recommends supernode configurations with 64 or more accelerators. Community testing suggests an 8×H100 (80GB) node can load it experimentally, but that is a demo, not a deployment. MXFP4 runs natively on NVIDIA Blackwell and AMD MI400-class silicon; older cards won’t give you the format for free.

So who is the open-weight release actually for?

Your situation	Practical path
Individual developer / hobbyist	Use the Kimi app or API — open weights don’t change your life today
Startup / product team	Third-party hosts (Together AI, Fireworks, etc.) serving K3 within days — Western infrastructure, no 64-GPU cluster
Enterprise with data-residency rules	Self-host on your own cluster or a private cloud — this is the group open weights truly unlock
Research lab	Download, inspect, fine-tune, distill into smaller models — the tech report makes this genuinely useful
r/LocalLLaMA quant community	GGUF Q4/Q2 builds expected within days — but even quantized, 2.8T is hundreds of GB

The distillation point deserves emphasis. The biggest long-term impact of open K3 weights may not be people running K3 — it’s the wave of smaller fine-tunes and distilled models that inherit K3’s capabilities at runnable sizes. That’s exactly what happened after DeepSeek R1.

API vs self-host: the cost math

If you don’t need to own the weights, the hosted API remains the cheapest entry point — and Moonshot’s pricing is aggressive for a frontier-class model: $0.30 per million cache-hit input tokens, $3.00 standard input, $15.00 output, flat across the 1M window. Mooncake’s disaggregated inference architecture reportedly delivers cache-hit rates above 90% in coding workloads, so real-world costs often sit far closer to $0.30 than $3.00.

Against Claude Fable 5 at $10/$50, that’s a 3.3× gap on input and output before caching — and self-hosting undercuts both once your volume justifies the hardware. The calculus is simple: the API for evaluation and bursty work, hosted third-party inference for production without ops overhead, and self-hosting when volume, privacy or compliance makes per-token billing the expensive option. You can also try K3 free in the Kimi app first — grab the free credits here — before committing to any infrastructure decision.

What independent testing found (the part most coverage skips)

Open weights mean open scrutiny, and the independent numbers from launch week deserve equal billing with the vendor charts:

• Hallucination regression. On Artificial Analysis’s AA-Omniscience benchmark, K3 hallucinated on roughly 51% of test cases — worse than Kimi K2.6’s 39%. Coding ability and factual reliability are different capabilities; treat K3 differently from Fable 5 or GPT-5.6 on knowledge-retrieval workloads where answers can’t be verified downstream.
• Speed. At ~35 tokens/second, K3 was the slowest flagship one reviewer measured, and it’s verbose — long reasoning traces inflate both latency and output-token bills.
• Thinking-history fragility. K3 was trained in “preserved thinking history” mode: your harness must pass back the full reasoning_content every turn, and switching mid-session from another model can destabilize it. Use a verified harness like Kimi Code CLI.
• Excessive proactiveness. Moonshot warns K3 may make unexpected decisions on ambiguous tasks — constrain it explicitly in the system prompt or AGENTS.md for bounded workflows.

None of this cancels the release. It just means: deploy it where its strengths (long-horizon coding, agentic tool use, multimodal reasoning) are verifiable, and measure before you migrate high-volume workloads.

Why today matters beyond the download

The strategic picture is bigger than one repository:

• Open weights are winning the usage war. Per Bloomberg Intelligence, Chinese open-weight models’ share of overall token usage has risen to 68% following K3 and GLM-5.2 — and notably, AWS Bedrock, Azure Foundry and Google Vertex don’t offer these models. Self-hosting and third-party hosts are the only Western access route, which is precisely what today enables.
• It’s already a business, not a subsidy. Moonshot’s daily revenue reportedly jumped at least 6× after the K3 launch, demand forced it to pause new subscriptions, and the company is reportedly raising at up to a $50B valuation while weighing a Hong Kong listing as early as this year.
• Markets repriced the threat within 24 hours of launch. On July 17, Z.ai fell ~28% and MiniMax ~16%; the Nasdaq and Nvidia dipped too. Investors read K3 correctly: scarcity and pricing power for closed frontier models look less durable when a near-frontier model goes free.
• The geopolitical friction makes owning the artifact valuable. With US officials publicly floating distillation accusations and even sanctions talk, a downloadable checkpoint is the one distribution channel that can’t be rate-limited, waitlisted or switched off. Once the weights are on a thousand servers, the genie doesn’t go back in the bottle.

How to get started today

1. Just want to use it? Open kimi.com or the Kimi app and select K3 — or run Kimi Code CLI and pick it with /model. Full walkthrough: Kimi K3 download for PC.
2. Building a product? Hit the API (kimi-k3, OpenAI/Anthropic-compatible) with reasoning_effort set to low, high or max — then watch Together AI, Fireworks and OpenRouter for hosted endpoints over the next 48 hours.
3. Self-hosting? pip install -U vllm, then pull moonshotai/Kimi-K3 from Hugging Face with git-lfs. Plan for 1.4TB+ of GPU memory, read the LICENSE and the technical report first, and use the official vLLM recipes — KDA-aware prefix caching is what makes serving economics work.
4. Researching? Start with k3_tech_report.pdf — the ablations on KDA/AttnRes and Stable LatentMoE are the real substance — plus the MoonEP, FlashKDA and AgentEnv repos.

FAQ

Where can I download the Kimi K3 open weights?

The official weights live on Hugging Face at huggingface.co/moonshotai/Kimi-K3, with the code, LICENSE and full technical report (k3_tech_report.pdf) in the GitHub repository MoonshotAI/Kimi-K3. The download is roughly 594GB of MXFP4 safetensors, so use git-lfs or the HF CLI with resume support.

Is Kimi K3 free for commercial use?

Yes, in practice. The weights ship under the Kimi K3 License — the modified-MIT-style license family Moonshot used for the K2 series — which permits commercial deployment, fine-tuning and redistribution with conditions. The K2 precedent added an attribution clause for products above ~100M monthly users or ~$20M monthly revenue, so read the LICENSE file in the repo before shipping a large product.

Can I run Kimi K3 locally on my own PC?

Realistically, no. Serving the 2.8T model needs roughly 1.4TB of fast GPU memory, and Moonshot recommends supernode setups with 64 or more accelerators. An 8×H100 node can load it experimentally, but for almost everyone the practical paths are the Kimi API, a third-party inference host, or the Kimi app.

What is the difference between open-weight and open-source?

Open-weight means the trained model weights are public, so anyone can download, run and fine-tune the model. Open-source would additionally publish the training data and full training pipeline. Kimi K3 releases the weights, inference code, a detailed technical report and training-infrastructure projects (MoonEP, FlashKDA, AgentEnv) — but not the training data — so “open-weight” is the accurate term.

Is Kimi K3 better than GPT-5.6 and Claude Fable 5?

It is the strongest open-weight model ever released and it beats the closed flagships on several tests — SWE-Marathon (42.0), BrowseComp (91.2) and MCPMark-Verified (94.5) among them — but Moonshot itself concedes Claude Fable 5 and GPT-5.6 Sol remain ahead overall. Independent trackers place K3 at #2–#4 across all models, open or closed.

How big is the Kimi K3 download and what hardware does it need?

About 594GB on disk in native MXFP4 safetensors, and roughly 1.4TB of GPU memory loaded. Moonshot recommends 64+ accelerators configured as a supernode; MXFP4 runs natively on NVIDIA Blackwell and AMD MI400-class silicon. Community GGUF quants are expected within days, but even a Q4 build of a 2.8T model is multi-hundred-GB territory.

The bottom line

July 27, 2026 is the day the frontier went open. Moonshot kept its promise to the day: the world’s first open 3T-class model, the largest open-weight release in history, a license that permits real commercial use, a technical report with genuine substance, and day-0 serving support across vLLM, SGLang and major inference providers.

K3 doesn’t dethrone Claude Fable 5 or GPT-5.6 Sol — Moonshot says so itself, and the hallucination numbers urge care on factual workloads. But “3–5 months behind the absolute frontier, free to download, yours to run” is a proposition the industry has never had before. For enterprises locked out of Chinese models on US clouds, for researchers who needed inspectable frontier weights, and for the distillation wave that starts tonight — this is the most consequential open-weight release since DeepSeek R1.

Keep reading: the complete Kimi K3 guide, the full Kimi K3 specifications breakdown, the K3 release timeline, and our head-to-heads — K3 vs Claude Fable 5, K3 vs GPT-5.6 and K3 vs GLM-5.2.