How to Download and Run Kimi K3 Open Weights (2.8T Params) | Comfyfile Blog | Comfyfile Blog

Moonshot AI shipped the full Kimi K3 weights on July 27, 2026 : 2.8 trillion parameters, a one million token context window, and a 1.4 TB download.

This guide covers what matters before you start that transfer. Where to get the weights, how much disk and VRAM you actually need, working vLLM and SGLang commands, what the license permits, and an honest answer to whether you should self-host at all. For most people that answer is no, and there's a better option further down.

TL;DR

Question<br>Answer

Official repo<br>huggingface.co/moonshotai/Kimi-K3

Release date<br>July 27, 2026

Download size<br>~1.4 TB (native MXFP4 safetensors)

License<br>Custom "Kimi K3 License", MIT-like with two commercial trip-wires

Parameters<br>2.8T total / 104B active (16 of 896 experts)

Context<br>1,048,576 tokens

Minimum realistic hardware<br>8× NVIDIA B300 or 8× AMD MI355X. 16× B200/GB200 on that generation.

Runs on Ollama / LM Studio?<br>No. llama.cpp cannot load the architecture.

Tech report<br>github.com/MoonshotAI/Kimi-K3 → k3_tech_report.pdf

What Kimi K3 actually is

Worth understanding before you commit a terabyte of bandwidth, because the architecture is why the deployment is awkward.

Spec<br>Value

Architecture<br>Mixture-of-Experts (Stable LatentMoE)

Total / activated params<br>2.8T / 104B

Layers<br>93 (1 dense)

Attention composition<br>69 KDA + 24 Gated MLA

Experts<br>896 total, 16 selected per token, 2 shared

Attention heads<br>96

Vocabulary<br>160K

Context length<br>1,048,576

Activation<br>SiTU-GLU

Vision encoder<br>MoonViT-V2 (401M params)

Quantization<br>MXFP4 weights / MXFP8 activations, quantization-aware from the SFT stage onward

Modality<br>Text + image

Three things here are unusual enough to break tooling that works fine on other models.

Kimi Delta Attention (KDA). Most layers are linear-attention with a fixed-size recurrent state instead of a growing KV cache, interleaved with periodic full-attention layers that preserve exact recall. That's what makes a 1M-token window affordable. It's also why prefix caching had to be redesigned from scratch in vLLM, since you can't cache a recurrent state the way you cache paged KV blocks.

Attention Residuals (AttnRes). Instead of ordinary residual accumulation, each sublayer uses a learned pseudo-query to weight normalized residual states from preceding blocks. The residual stream becomes persistent cross-layer state with its own memory footprint.

Native MXFP4. The model was trained to be 4-bit, not squeezed into it afterward. Self-hosted quality should match the hosted API, since it's the same quantization. The flip side: you can't quantize your way down to consumer hardware, because you're already there.

Where to download Kimi K3

https://huggingface.co/moonshotai/Kimi-K3

That's the canonical path. The MXFP4 quantization is native to this repo rather than living in a separate quantized fork, so there's nothing else to hunt down. Moonshot also maintains a ModelScope organization, typically the faster mirror if you're in mainland China. Check there for a K3 entry rather than assuming the path.

A word on mirrors, because a release this big attracts them. Within hours of any major weight drop, dozens of reuploads appear with plausible names. Some are honest re-hosts. Some are stale. At least a few will be neither, and a 1.4 TB blob is not something you want to eyeball for tampering. Pull from moonshotai or a mirror you have an actual reason to trust, and pin a commit hash . Day-0 repos get amended, and "it worked yesterday" is not a reproducible build.

Downloading it, step by step

1. Check you have the disk

df -h /data

You need ~1.4 TB for the weights themselves. Give yourself 2 TB of real headroom, because the Hugging Face cache stages files before linking them into place, and you'll want room for logs, configs, and a second revision when Moonshot pushes a fix.

2. Install the CLI and turn on fast transfers

pip install -U "huggingface_hub[cli,hf_transfer]"<br>export HF_HUB_ENABLE_HF_TRANSFER=1<br>hf auth login

hf_transfer is a Rust-backed downloader that will saturate a fast link in a way the default Python path won't. On a terabyte-scale pull, this is the difference between hours and most of a day. Authenticating isn't strictly required for public repos, but it raises your rate limits and saves you from mysterious throttling halfway through.

3. Pull the weights

hf download moonshotai/Kimi-K3 \<br>--revision main \<br>--local-dir /data/models/kimi-k3

Real talk on timing: at a genuine 1 Gbps you're looking at roughly 3.5 hours of continuous transfer, and that assumes you get full line rate. On a 10 Gbps link, closer to 20 or 25 minutes. Anything slower than gigabit and you should start this before you go to bed.

Modern huggingface_hub resumes interrupted downloads automatically, so a dropped connection isn't fatal. Just re-run the same command. If you're following an older guide telling you to pass --resume-download, that...