Kimi K3 Open Weights Are Out: 1.56 TB and Who Can Run It

Moonshot shipped the Kimi K3 open weights on July 27, 2026, eleven days after the model went live through the API. The download is real and public, and at 1.56 TB across 96 safetensors shards, it is also the point where most people discover that "open" and "runnable" are different words. Here is what landed, what the license allows, and what it takes to serve it.

What Moonshot shipped

The full checkpoint is on Hugging Face at moonshotai/Kimi-K3, with a ModelScope mirror for users in China. The repo is 1.56 TB: 96 safetensors shards plus config.json, the modeling and tokenizer code (modeling_kimi_k3.py, encoding_k3.py, a 160K-vocab tiktoken model), vision preprocessing, and the LICENSE file. The technical report went up alongside it in the MoonshotAI GitHub repo.

Three details in the model card matter more than the headline parameter count:

• The model card confirms 104B activated parameters out of 2.8T total: 16 of 896 routed experts per token, plus 2 shared experts, across 93 layers. That active count was not public before the weights dropped.
• The weights are natively MXFP4. Moonshot applied quantization-aware training from the SFT stage onward, with MXFP8 activations. This is not a post-hoc quant of a BF16 checkpoint; the 4-bit weights are the release.
• Attention is a 69/24 split between Kimi Delta Attention layers and Gated MLA layers, over a 1,048,576-token context window.

Adoption signals moved fast. The repo carried 6.6k likes on July 28, 2026, one day after the initial commit landed in its commit history, and community conversions were already up: unsloth/Kimi-K3-GGUF was created the same evening, and GrEarl/Kimi-K3-GGUF had a full Q2_K conversion uploaded by the next morning.

The Kimi K3 License is not MIT

Earlier Kimi flagships shipped under a Modified MIT license. K3 does not. It ships under a document called the Kimi K3 License, and while the body is MIT-derived — use, copy, modify, merge, publish, distribute, sublicense, sell, fine-tune, create derivatives — it adds two conditions worth reading before you build on it.

The Model-as-a-Service clause. The operative text: "If the Licensee or any of its affiliates operates a Model as a Service business, and the aggregate revenue of the Licensee and its affiliates exceeds 20 million US dollars ... in total over any consecutive 12 months, the Licensee must enter into a separate agreement with Moonshot AI before using the Software or its derivative works for any commercial purpose." MaaS is defined in the license as giving a third party inference or fine-tuning access in a way that lets them control inputs, parameters, or training data. The license explicitly carves out two things that are not MaaS: end-user products where model capability is embedded in specific features, and mere relaying of requests to models hosted by someone else.

The attribution clause. If a commercial product built on K3 crosses 100 million monthly active users or 20 million USD in monthly revenue, "Kimi K3" must be displayed prominently in that product's UI.

Both clauses are waived for purely internal use, meaning anything that does not expose the model, its outputs, or its capabilities to third parties, and for access through Moonshot's official products or certified inference partners. Reading the exemptions literally: fine-tuning K3 on internal data is covered by the internal-use carve-out in Section 4(a), and embedding it as a product feature is named in Section 2 as something that is not MaaS. Reselling K3 inference as a service is the case the added clauses are written for, and the $20M threshold is where it stops being a license question and becomes a contract negotiation. Read the LICENSE yourself before committing a roadmap to it; the summary here is a reading of the text, not legal advice.

The hardware reality of 1.56 TB

The Kimi K3 open weights are downloadable by anyone. Serving them is not.

vLLM's official K3 recipe states the requirement plainly: at least 8× GB300, and multi-node for real production traffic. On the AMD side it lists at least 8× MI355X or MI350X with the ROCm image. SGLang publishes a K3 cookbook with the same class of target.

If you are actually provisioning this, the recipe's operational notes are the part worth reading twice. Serving runs from the dedicated vllm/vllm-openai:kimi-k3 image (or vllm/vllm-openai_rocm:kimi-k3 on AMD), not stock vLLM. Cross-node traffic wants --all2all-backend deepep_v2 over RDMA or flashinfer_nvlink_one_sided over NVLink, with UCX_TLS="rc,cuda_copy" set so KV cache transfer stays on RDMA. The MoE backend recommendation splits by topology: deep_gemm_mega_moe for expert-parallel deployments, flashinfer_trtllm for TP>1. The recipe also flags that K3 occasionally emits a tool-call format its own parser rejects, so schema validation plus retry belongs in your serving layer from day one.

The usual escape hatch, quantizing it down, mostly does not work here, because MXFP4 already is roughly 4.25 bits per parameter. The compression headroom that made 1T-class models tractable on a workstation was spent before you downloaded anything. The first community 2-bit GGUF conversion to appear lands at 928 GB across 94 shards, which is a 40% saving on a number that was never the binding constraint.

Add KV cache for anything approaching the 1M-token context and the working set climbs from there. The most striking day-one self-host report came from a team claiming to run the official MXFP4 weights across 80× RTX 5090s on plain Ethernet, with no HBM and no re-quantization, at roughly 20 tokens/second single-stream untuned. It is an unaudited first-day claim from a single post, not a benchmark, and one configuration does not define a minimum. It is worth citing only for its direction: the cheapest reported path to running K3 on consumer silicon involved eighty flagship GPUs and produced a speed most people would call sluggish.

Ollama is worth calling out specifically, because it is the first thing people try. The library entry exists, but it resolves to kimi-k3:cloud, which is Ollama's hosted routing rather than a local pull. There is no laptop or single-workstation path to this model today, and because MXFP4 is the native format rather than a convenience quant, the usual community route of aggressive re-quantization has less room to work with than it did for the K2 line. llama.cpp support is still in motion, so check current status rather than assuming either way.

Where to run Kimi K3 today

The practical answer for almost everyone is a hosted endpoint, and the open-weight release did what open-weight releases do: third-party hosts lit up within a day. Prices below are per million tokens, in/out, as listed on July 28, 2026.

Two things to check before you pick one. First, context window varies wildly. Nebius serves the same list price at an 8K window, which removes the single biggest reason to use K3. Second, quantization varies: Moonshot serves the native MXFP4, Baseten runs FP8, and several hosts do not state a precision at all. For long-horizon agentic work, matching the reference precision and the full 1M window generally matters more than the price difference; for short prompts at high volume, latency and regional availability may well outrank both.

Beyond the direct endpoints, OpenRouter aggregates them behind one key, and multi-model gateways route K3 alongside other open Chinese frontier models; AIReiter exposes the same class of models through an Anthropic-compatible API if your tooling already speaks that protocol. Moonshot's own endpoint offers both OpenAI- and Anthropic-compatible surfaces. Full rate and tier details are in the Kimi K3 pricing breakdown.

Self-host or use a hosted endpoint?

Run the arithmetic first. At $3/$15 per million tokens, a billion output tokens costs $15,000 and a billion input tokens costs $3,000. Set that against the minimum viable self-host: an 8× GB300 class node, which is a data-center capital purchase or a rental billed by the accelerator-hour, plus interconnect, power, cooling, and an engineer who knows --all2all-backend from memory. Neither NVIDIA nor the major clouds publish a list price for that configuration, so build the comparison from a live quote rather than a rule of thumb, and remember the hardware cost is fixed while the API cost scales with what you actually use.

Self-hosting the Kimi K3 open weights earns its keep in three situations, and they are narrower than they sound:

1. Air-gapped or data-residency requirements that no third-party endpoint can satisfy. This is the strongest case, and cost is not the deciding factor.
2. Fine-tuning on proprietary data. The license permits it outright, and this is something no hosted endpoint gives you. Note the training cost is separate from and larger than the serving cost.
3. Sustained volume at saturation. If you are keeping a multi-node cluster busy around the clock, owned hardware can undercut per-token pricing. Occasional bursts do not qualify.

If none of those describe you, use an endpoint and treat the weights as an option rather than a plan. The value of an open-weight frontier model to most teams is not that they will run it. It is that the price of the hosted version now has to compete with the possibility that they could.

FAQ

Is Kimi K3 open source?

It is open-weight. The full 2.8T checkpoint is downloadable and the Kimi K3 License permits use, modification, distribution, and fine-tuning. Training data and the full training pipeline were not released, and the license adds a revenue-triggered clause for Model-as-a-Service operators, so it is not OSI-style open source.

Can I run Kimi K3 on Ollama locally?

No. Ollama's kimi-k3 entry is kimi-k3:cloud, which routes to a hosted endpoint. The native MXFP4 weights are 1.56 TB and a community 2-bit GGUF is still 928 GB, so there is no local path on consumer hardware.

What license are the Kimi K3 weights under?

The Kimi K3 License: MIT-derived, but requiring a separate agreement with Moonshot if you operate a Model-as-a-Service business exceeding $20M in revenue over any 12 months, plus UI attribution above 100M MAU or $20M monthly revenue. Internal use is exempt from both.

Where can I use Kimi K3 without downloading it?

Moonshot's own API and the Kimi app, plus Baseten, Fireworks, and Nebius. All four list $3/$15 per million tokens as their base rate on July 28, 2026, but the comparison is conditional: Fireworks also runs a $4.50/$22.50 tier, and Nebius serves the base rate at an 8K context window instead of 1M. For what the model is and how it benchmarks, see the Kimi K3 overview.