Moonshot AI · 2.8T MoE · Weights Promised by July 27, 2026
Kimi K3: Specs, Release Date & Can You Run It Locally?
Kimi K3 (launched July 16, 2026) is Moonshot AI's 2.8-trillion-parameter Mixture-of-Experts model — more than double the size of the 1.1T Kimi-K2.7-Code, the previous Kimi flagship — with a 1M-token context window. As of July 20 it's API-and-app-only; Moonshot promises downloadable weights by July 27. And here's the blunt answer to the question that brought you here: no, you will not run K3 locally. The weights are ~1.4 TB even in their native 4-bit format, and Moonshot's own deployment guidance calls for 64+ accelerators. Below: full specs, API pricing, Moonshot's benchmark claims, and what Kimi fans can actually run today.
Status — as of July 20, 2026
Kimi K3 is API-and-app-only. Moonshot promises open weights by July 27, 2026. No downloadable weights, no GGUFs, and no llama.cpp / Ollama / MLX support exist today. We'll update this page the day the weights land.
Key takeaways
- →2.8T total parameters — MoE with 16 of 896 experts active per token (~1.8% activation). More than double the 1.1T Kimi-K2.7-Code, the previous Kimi flagship.
- →~1.4 TB at native 4-bit (MXFP4) — it ships 4-bit, so quantization can't rescue you. Even a ~2-bit quant would be roughly 700+ GB (estimate).
- →Moonshot's own hardware guidance: 64+ accelerators — multi-node datacenter, not an 8-GPU box, not any consumer rig.
- →API pricing: $3.00/MTok input (cache miss), $0.30 cache hit, $15.00 output — flat, no context tiering.
- →Want to actually self-host? Kimi-K2.7-Code on extreme rigs, Kimi-VL-A3B / Moonlight-16B on real hardware, or GLM-5.2 — a frontier-class open model that sits one rung below K3 on the Frontend Code Arena board and is far more practical to self-host.
Quick answer
If you came here to find out which GPU runs Kimi K3: none of them. Not one RTX card, not a stack of them, not a 512 GB Mac Studio. K3 is a datacenter model — Moonshot's own deployment guidance is "supernode" configurations with 64+ accelerators, and the weights are ~1.4 TB in their native MXFP4 4-bit format. The top search results claiming otherwise are SEO sites publishing invented specs. This page sticks to what Moonshot has actually said and what the arithmetic actually allows.
The practical playbook: use the K3 API if you want the model, and self-host from the tier below it. The Kimi K2 line is the runnable branch of the family, and GLM-5.2 is a frontier-class open model that sits one rung below K3 on the Frontend Code Arena board and is far more practical to self-host.
Specs at a glance
| Vendor | Moonshot AI |
| Launched | July 16, 2026 (API/app); open weights promised by July 27, 2026 |
| Architecture | Mixture-of-Experts — 16 of 896 experts active per token (~1.8% activation) |
| Total parameters | 2.8 trillion |
| Attention | Kimi Delta Attention (KDA); Moonshot contributed a KDA prefix-caching implementation to vLLM, to be released alongside the model |
| Context window | 1,000,000 tokens |
| Vision | Native visual understanding (per secondary sources) |
| Native weight format | MXFP4 (4-bit) |
| Weight size | ~1.4 TB (native MXFP4) |
| License | Not yet published — Modified MIT expected (K2-line precedent), unconfirmed |
| Local runtimes | None as of July 20, 2026 — no llama.cpp, Ollama, or MLX support; no GGUFs |
| Deployment guidance | Moonshot: "supernode" configurations, 64+ accelerators |
One naming note: you'll occasionally see this model called "Kimi V3." There is no Kimi V3 — the real name is K3, the successor to the K2 line.
Release date & license
K3 launched July 16, 2026 through Moonshot's API and app — the specs and timeline here trace to Moonshot's official Kimi K3 announcement. The weights themselves are not downloadable yet — Moonshot's commitment is open weights by July 27, 2026. Until then, "open-weight" is a promise, not a fact on a Hugging Face page.
The license is also unpublished. Based on the K2-line precedent, a Modified MIT license is the expectation — but that's our read, not a confirmed term sheet. If your business plan depends on the license, wait for the actual text.
One genuinely useful thing already shipped: Moonshot contributed a KDA prefix-caching implementation to vLLM, slated for release alongside the model. That means serious multi-node operators will have a serving path on day one. It does nothing for llama.cpp or Ollama users — KDA is a new attention design that would require fresh implementation work in those projects, and none exists as of July 20.
Can you run it locally? The math says no
This is the section the SEO-squatter pages get wrong on purpose. Here is the honest arithmetic:
The weights are already 4-bit
K3's native format is MXFP4. With most models, "just quantize it to 4-bit" cuts the size roughly 4×. K3 starts there — ~1.4 TB at native 4-bit — so the usual escape hatch is gone before you open it.
Even a brutal 2-bit quant doesn't fit anywhere
Back-of-envelope estimate: ~2 bits across 2.8T parameters is still roughly 700+ GB. That's past every consumer machine on the market, including a 512 GB Mac Studio — and that's before you account for any quality cost of quantizing that aggressively.
Moonshot's own guidance is 64+ accelerators
The vendor isn't pretending otherwise: recommended serving is "supernode" configurations with 64 or more accelerators — multi-node datacenter deployments. Not an 8-GPU workstation. Not a homelab.
No local tooling exists — and no dates are promised
As of July 20, 2026: no llama.cpp support, no Ollama support, no MLX support, no GGUFs (the weights aren't even out). K3's KDA attention would need new llama.cpp implementation work before any of that could happen. Any page quoting a "K3 GGUF size" or a tokens-per-second figure today is inventing it.
API pricing
Since the API is the only way to use K3 right now, the pricing matters. Official numbers, flat across all context lengths (no tiering):
| Metric | Price |
|---|---|
| Input (cache miss) | $3.00 / MTok |
| Input (cache hit) | $0.30 / MTok |
| Output | $15.00 / MTok |
The cache-hit rate is the number to watch: Moonshot reports over 90% cache hits on coding workloads. If that holds for your traffic, most input tokens land at the $0.30 rate. Output is where K3 is premium-priced — for comparison (press-cited figures), GLM-5.2's API runs $4.40/MTok output and DeepSeek V4 runs $0.87/MTok output. At $15/MTok, K3 output costs real money in agent loops that generate a lot of text.
Benchmarks — Moonshot's claims, labeled as such
Weights aren't out, so nobody outside Moonshot has run K3 on their own hardware. Everything below is either Moonshot's own numbers or early third-party API testing, such as Simon Willison's independent analysis — treat it accordingly.
- →Moonshot itself says K3 trails Claude Fable 5 and GPT-5.6 Sol overall. Unusual candor for a launch post, and a point in their credibility column.
- →Moonshot's numbers have K3 beating Claude Opus 4.8 and GPT-5.5 on coding and agentic benchmarks.
- →Reported Artificial Analysis Intelligence Index: 57. Independent testing reportedly places K3 4th among frontier models.
The one board where K3 sits at #1 — Frontend Code Arena:
| Model | Frontend Code Arena |
|---|---|
| Kimi K3 | 1,679 |
| Claude Fable 5 | 1,631 |
| GPT-5.6 Sol | 1,618 |
| GLM-5.2 | 1,587 |
What you can run instead
If K3 sent you here dreaming of frontier-class local AI, here's the realistic ladder, from extreme to actually-attainable:
Kimi-K2.7-Code — the runnable Kimi flagship
1.1T parameters. 605 GB at full precision, but 325 GB at Unsloth Dynamic 2-bit — which puts it in reach of multi-GPU / EPYC-class rigs. Extreme, but real people run it. Start with our Kimi K2 coverage for the family background.
Kimi-VL-A3B and Moonlight-16B-A3B — Moonshot on consumer hardware
These are the Moonshot models that run on machines normal people own. If you want the Kimi lineage without a server room, this is it.
GLM-5.2 — a frontier-class open model you can actually self-host
If the goal is frontier-class capability you can genuinely run, GLM-5.2 sits one rung below K3 on the Frontend Code Arena board above and is far more practical to self-host. See our best open-source LLMs guide for the full field.
Kimi K3 vs K2: what actually changed
K3 is a scale jump, not a tune-up: 2.8T total parameters with an aggressively sparse 16-of-896 expert design (~1.8% activation), a 1M-token context window, native visual understanding (per secondary sources), and the new KDA attention design. The K2 line topped out at Kimi-K2.7-Code's 1.1T parameters.
For local users the comparison is simpler than any spec sheet: the K2 line is the one you can run. K2.7-Code fits in 325 GB at Unsloth Dynamic 2-bit; K3 is ~1.4 TB before you've loaded a single context token. If you're choosing a Kimi model to self-host, the decision is made for you — read our Kimi K2.6 review and work from there.
Bottom line
Kimi K3 is a real frontier release — 2.8T total parameters, a 1M-token context window, and the #1 spot on the Frontend Code Arena board — but it is not a local model, and it won't become one when the weights land. At ~1.4 TB in its native MXFP4 4-bit format, with Moonshot's own deployment guidance calling for 64+ accelerators, K3 is a datacenter model, full stop.
The practical playbook: use the API if you want K3 — with 90%+ cache-hit rates on coding workloads, most input lands at $0.30/MTok, though $15/MTok output costs real money in agent loops — and self-host from the tier below. That means Kimi-K2.7-Code on extreme multi-GPU rigs, or GLM-5.2 for frontier-class capability you can actually run.
FAQ
What is Kimi K3?
Can I run Kimi K3 locally?
When will Kimi K3 open weights be released?
What hardware do you need to run Kimi K3?
How is Kimi K3 different from Kimi K2?
How much does the Kimi K3 API cost?
Related models
- → Kimi K2.6 — the K2-line flagship review; the runnable branch of the family
- → Kimi K2 — where the Kimi open-weight story started
- → GLM-5.2 — frontier-class open model, one rung below K3 on Frontend Code Arena
- → DeepSeek V4 — the cheap-output API comparison ($0.87/MTok)
- → Qwen3-Coder-Next — our coding-model coverage
- → Best open-source LLMs 2026 — the full comparison
Go from reading about AI to building with AI
20 structured courses. Hands-on projects. Runs on your machine. Start free.
Written by the Local AI Master Team
The team behind Local AI Master
We build Local AI Master around practical, testable local AI workflows: model selection, hardware planning, RAG systems, agents, and MLOps. The goal is to turn scattered tutorials into a structured learning path you can follow on your own hardware.