Preface¶

On July 27, 2026, Moonshot AI released the full model weights of Kimi K3 on Hugging Face. With a total parameter count of 2.8T and approximately 104B activated per token, the official team dubbed it the world’s first open 3T-class model. The weights are packaged in MXFP4 format, totaling around 1.56 TB split across 96 safetensors shards, making it the largest state-of-the-art open-weight model publicly available for download as of this writing.

Kimi K3 is not a “small trial version” but Moonshot’s current most powerful agentic multimodal model. It natively supports text and image inputs with a 1 million token context window, targeting long-range programming, knowledge work, and reasoning tasks. The model was first launched on platforms like Kimi.com and Kimi API around July 17, 2026; the full weights and GitHub repository were made publicly available on July 27. The open-source community and Hacker News immediately launched discussions around its MoE architecture, MXFP4 quantization scheme, and whether “ordinary people can self-host” it.

This article sorts out the core specifications, architectural highlights, and access methods of Kimi K3 based on Moonshot’s official blog, GitHub repository, and Hugging Face model card.

Kimi K3 Model Overview¶

Kimi K3 is a native multimodal agent model, with the core positioning of “Open Frontier Intelligence”. Unlike releases that only open partial layers or distilled versions, Moonshot has released the full weights this time for research and deployment use.

The key specifications provided by the official team are as follows:

Moonshot stated that compared to Kimi K2, K3 has approximately a 2.5× improvement in overall scaling efficiency. In official evaluations, K3 achieved state-of-the-art performance on multiple coding, agentic, and multimodal benchmarks, but the overall experience still slightly lags behind closed-source flagship models such as Claude Fable 5 and GPT-5.6 Sol — the official team explicitly acknowledged this gap in their blog post.

Architecture: KDA, AttnRes and Stable LatentMoE¶

The architectural updates of Kimi K3 are the focus of community discussions. It is not simply stacking parameters, but has made multiple modifications to the attention mechanism and MoE routing.

Kimi Delta Attention and Attention Residuals¶

Kimi Delta Attention (KDA) is used to more efficiently scale attention computations; Attention Residuals (AttnRes) allows the model to selectively retrieve representations across depth dimensions instead of accumulating them uniformly. Together, they form the attention backbone of K3 at the trillion-parameter scale.

Out of the 93 layers, 69 use KDA and 24 use Gated MLA (Multi-head Latent Attention). The hidden dimension is 7168, and the number of attention heads is 96. The activation function is SiTU-GLU.

Stable LatentMoE: Selecting 16 out of 896 Experts¶

The MoE section adopts the Stable LatentMoE framework: among 896 routing experts, each token activates 16 experts, plus 2 shared experts that participate in calculations at all times. The MoE hidden dimension is 3072, and the Latent MoE dimension is 3584.

At such a high sparsity level, expert load balancing becomes the key to training and inference. Moonshot introduced mechanisms such as Quantile Balancing (allocating experts based on router score quantiles) and Per-Head Muon (independent optimization per attention head) to stabilize training at the 2.8T scale.

Native MXFP4 Quantization¶

Kimi K3 adopted quantization-aware training starting from the SFT phase, with weights stored in MXFP4 and activations computed in MXFP8. This means the released weights are already in 4-bit floating-point format, and no additional PTQ is required for inference on compatible hardware.

MXFP4 uses block-level shared scale 4-bit floating-point representation. The official team stated that this choice balances hardware compatibility and inference efficiency. The actual downloaded checkpoint is approximately 1.56 TB (96 safetensors shards), which is lower than the theoretical full BF16 precision size, but still poses a hard threshold for storage and bandwidth.

Open Weights, Code and Licenses¶

Release Content and Timeline¶

• Around July 17, 2026: K3 became available on platforms including Kimi.com, Kimi Work, Kimi Code, and Kimi API.
• July 27, 2026: The full model weights were released on Hugging Face (moonshotai/Kimi-K3), and the GitHub repository MoonshotAI/Kimi-K3 was opened simultaneously.

In addition to the weights, Moonshot also released part of the training infrastructure code, including FlashKDA (previously open-sourced), MoonEP (expert parallel training), and AgentEnv (agent training sandbox, in collaboration with KVCache.ai). The vLLM community will also receive implementations related to KDA prefix caching to improve long-context serving efficiency.

Kimi K3 License¶

Both the weights and code follow the Kimi K3 License, rather than standard open-source licenses such as Apache or MIT. Moonshot used the term “open weight” in its release materials, and the community also reminded developers to carefully read the license terms before deployment — especially when involving commercial MaaS services, an additional commercial agreement may be required.

Self-Hosting Threshold: What 1.56 TB Means¶

Open weights do not equal “anyone can run it”. The scale of K3 determines that it is targeted at teams with multi-node GPU clusters, rather than individual developers using personal laptops.

The official Moonshot team recommends deploying on a supernode configuration with 64+ accelerators to achieve optimal inference efficiency; the official vLLM deployment guide points to the NVIDIA Blackwell platform (such as 8× B300 nodes, GB300 NVL72, or 16× B200). Third-party practical test articles stated that the 96 attention heads and 7168 hidden dimension impose strict constraints on tensor parallelism splitting — common configurations require multi-card collaboration, and a single 80 GB GPU cannot fully load the model.

If you just want to experience its capabilities, calling the API is a more practical path. The official Kimi API pricing (as of July 2026) is:
- Cache-hit input: $0.30 / MTok
- Cache-missed input: $3.00 / MTok
- Output: $15.00 / MTok

Platforms such as OpenRouter have also integrated Kimi K3, with input pricing at approximately $3 / M token. For most development teams, the cost of API calls is far lower than the CapEx of building a 1.56 TB weight cluster from scratch.

How to Access Kimi K3¶

1. Call via Kimi API¶

The official API is compatible with the OpenAI / Anthropic format, just select kimi-k3 as the model name. K3 enables thinking mode by default, returning the reasoning_content field; for multi-turn conversations, you must pass the complete assistant message (including reasoning_content and tool_calls) back as-is, otherwise the generation quality may be unstable.

import openai

client = openai.OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.moonshot.ai/v1"  # Refer to official documentation for updates
)

response = client.chat.completions.create(
    model="kimi-k3",
    messages=[
        {"role": "user", "content": "Write a quick sort in Python"}
    ],
    max_tokens=4096,
    reasoning_effort="max",  # Optional: low / high / max
)

print(response.choices[0].message.content)

reasoning_effort controls the inference depth: max is the default, and future versions will support low and high to balance latency and cost.

2. Agent Programming via Kimi Code CLI¶

The official team recommends using it in conjunction with the Kimi Code CLI. After installing the terminal tool, use the /model command to switch to Kimi K3, and you can perform long-range code editing, terminal tool calling and other agent tasks in the local project directory. The official blog demonstrated cases of K3 on long-duration tasks such as GPU kernel optimization, compiler development (MiniTriton), and chip design.

3. Self-Hosted Inference¶

If you already have a multi-node GPU cluster, you can pull the moonshotai/Kimi-K3 weights from Hugging Face and deploy them with inference engines such as vLLM and SGLang. Before deployment, confirm:
1. Storage space ≥ 1.6 TB (including vision tower and indexing overhead);
2. The inference framework version supports MXFP4 and KDA prefix caching;
3. The tensor parallelism degree can evenly divide 96 heads and 7168 hidden dimensions.

Please refer to the official Kimi K3 adaptation documentation of each engine for specific startup parameters. Moonshot stated that it is aligning technical details with inference partners, and ecological support is still improving rapidly.

Capability Boundaries and Usage Notes¶

The model card lists several restrictions that should be noted when self-hosting or integrating with agent frameworks:
1. Complete thinking history must be passed back: K3 was trained in preserved thinking history mode. If the agent harness discards the historical reasoning_content or switches from another model to K3 midway, the output may deteriorate significantly. It is recommended to use verified compatible frameworks such as Kimi Code.
2. Overly proactive: When faced with ambiguous instructions, K3 may make decisions that exceed expectations. If the business requires strict boundaries, you should clearly define constraints in the system prompt or AGENTS.md.
3. There is still a gap in experience compared to closed-source flagships: Although multiple benchmarks are close to the state of the art, the daily interactive experience still has a noticeable gap compared to Claude Fable 5 and GPT-5.6 Sol. You should conduct actual tests based on specific scenarios when selecting models.

Final Thoughts¶

The significance of Kimi K3’s open source does not lie in letting everyone download the 1.56 TB weights and run them at home, but in placing 3T-class frontier capabilities into the public domain in the form of open weights for the first time. Researchers can examine designs such as Stable LatentMoE, KDA, and MXFP4 quantization-aware training; teams with computing power can self-host agent pipelines; more developers can access frontier-class models at a low cost via APIs priced at $3/M token.

For the domestic AI ecosystem, K3 continues the Kimi series’ route of “continuously pushing up the parameter ceiling of open models” — in the past 12 months, Kimi models have occupied the upper bound of open model scale for 9 months. As the prices of closed-source models continue to decline and the scale of open weights continues to rise, “the way of obtaining capabilities” is being restructured: computing power, licenses, and agent frameworks will become as important variables as model parameters.

References
- Kimi K3 Tech Blog
- MoonshotAI/Kimi-K3 (GitHub)
- moonshotai/Kimi-K3 (Hugging Face)