Kimi K3.1 Pro Open Weights Are Out: 1.56TB and a $20M License Catch

Kimi K3.1 Pro Open Weights Are Out: 1.56TB and a $20M License Catch

Kimi K3.1 Pro open weights landed on Hugging Face this week, and Hacker News noticed fast. The weights are out thread climbed past 160 points within about two hours on November 4.

The model isn't new. Moonshot shipped Kimi K3.1 Pro and its API on October 23, and its own blog promised the weights by Nov 4. They kept the promise.

What's new is that you can now download a 2.8-trillion-parameter model. Before you clear a disk for it, there are two numbers to know. One is 1,561 GB. The other is $20 million.

We read the model card, the license file and the vLLM deployment recipe line by line. We haven't run the weights ourselves, so every benchmark below is Moonshot's, and the hardware math is ours.

What Actually Shipped With Kimi K3.1 Pro Open Weights

Here's what the Kimi K3.1 Pro Hugging Face model card confirms:

• Size: a mixture-of-experts model with 2.8T total parameters and 104B active per token.
• Context: 1,048,576 tokens.
• Inputs: text and images, through a 401M-parameter MoonViT-V2 vision encoder.
• Format: MXFP4 weights with MXFP8 activations, trained quantization-aware rather than squeezed down after the fact.
• Files: 112 safetensors shards, 1,561.3 GB in total.

Quantization-aware training matters here. MXFP4 is the format Moonshot trained for, not a lossy community conversion. You're getting the model as Moonshot intended it to run.

If you'd rather not host it, the API is unchanged. On OpenRouter it costs $2 per million input tokens, $10 per million output tokens, and $0.20 per million cached input tokens. Moonshot's launch post also lists a kimi-k3.1-pro-highspeed variant at 2-3x the speed.

Kimi K3.1 Pro Hardware Requirements: Bring a Data Center

This isn't a Mac Studio model. It isn't even a one-node H200 model.

Here's our math on the weights alone, using standard HBM sizes. Eight H200s give you 1,128 GB of HBM, which is about 430 GB short.

Eight B200s give you 1,536 GB. That still leaves you roughly 25 GB short, before a single token of KV cache.

One 8x B300 node, with about 2.3 TB of memory, clears it. That lines up with the vLLM recipe:

• Use vLLM 0.34.0 or newer.
• The default setup is two GB300 trays (4x GB300 NVL4) at tensor-parallel 8, or one B300 node.
• A single B300 node also works with tensor plus expert parallelism.
• On AMD, a single MI355X node at TP8 runs through the vllm/vllm-openai-rocm:kimi-k31 image.

The default serve command looks like this:

vllm serve moonshotai/Kimi-K3.1-Pro \
  --trust-remote-code \
  --tensor-parallel-size 8 --nnodes 2 \
  --tool-call-parser kimi_k3 \
  --reasoning-parser kimi_k3

The model card also recommends SGLang, which has its own cookbook entry, and TokenSpeed. Note the --trust-remote-code flag. You're running Moonshot's model code, so review it before it goes anywhere near production.

The Kimi K3.1 Pro License Isn't MIT

People will call this open source. It's open weights under a custom Kimi K3.1-Pro License. The base grant reads like MIT, and then come the conditions.

Commercial use is allowed. Most teams can ship with it.

The $20M line. If your company and its affiliates make more than $20 million in any 12-month period, you need a separate agreement with Moonshot before using it commercially.

The branding rule. If a product built on it passes 100 million monthly active users or $20 million in monthly revenue, Kimi K3.1-Pro has to be displayed prominently.

Internal use is exempt. The license also doesn't restrict training other models on its outputs, which matters if you're distilling.

For most startups, none of this bites. For a mid-size SaaS company with $25M in annual revenue, it does. You'd be self-hosting a model you still need to negotiate for, and legal should see this before engineering buys GPUs.

Benchmarks: Strong on Agents, Weak on Science

Every number below is Moonshot's own, run at max effort. We haven't seen independent reproductions yet.

The top half is why people are excited. On long-horizon software tasks and tool-heavy research, an open-weights model is level with, or ahead of, the closed frontier.

The bottom half is the part to read twice. On Program Bench, Kimi scores less than half of Opus 5.5. On Terminal-Bench-Science, it's 25 points behind.

One more detail from the card: Moonshot ran its own Terminal-Bench 4.0 score using the Claude Code harness. That means the agent scaffold is a known quantity, but your own harness may score differently.

Real-World Use Cases

Teams with GPUs already racked. If you want to self-host Kimi K3.1 Pro and you're already running an 8x B300 or MI355X node for other work, this is a top-tier coding agent with no per-token bill.

Data that can't leave your network. The 1M-token context and agentic coding scores make it a real option for on-prem code review and repo-wide refactors where a hosted API isn't allowed.

Distillation. There's no license clause against training on outputs. You can generate agentic traces from it to train a smaller in-house model.

Everyone else: the API. At $2 in and $10 out, most teams will spend far less on tokens than on renting a B300 node.

Hard Limitations and Flaws

The hardware floor is brutal. About 1.56 TB of weights means a top-end node or a multi-node cluster. There's no realistic local or hobbyist setup.

The hardware details live in the vLLM recipe. The model card points you to engines, and the VR200 path is marked as a preview, not tuned or verified.

The benchmarks are self-reported. The scores on Program Bench and Terminal-Bench-Science suggest it isn't the right pick for science-heavy or Program Bench-style work.

The license has teeth for growing companies. The $20M threshold covers your company and its affiliates over any 12-month period, not just revenue from the product.

Remote code is required. --trust-remote-code is in the default command. That makes it a supply-chain review step, not a formality.

Verdict: Your Developer Action Plan

Kimi K3.1 Pro's open weights are a real release, not a teaser. On Moonshot's own numbers, it trades blows with closed frontier models on agentic coding, if you can run 1.56 TB of it.

1. Check the license first. If your company and affiliates earned over $20M in any 12-month period, talk to Moonshot before anyone deploys.
2. Size the hardware honestly. One 8x B300 node, one MI355X node, or two GB300 trays. An 8x B200 node doesn't fit the weights.
3. Start on the API. Run your real tasks through kimi-k3.1-pro at $2/$10 before committing to hardware.
4. Test against your workload, not the chart. It's strong on agentic coding and weak on science and Program Bench. Know which one you are.
5. Review the remote code. Read what --trust-remote-code pulls in before it runs on your cluster.

The weights are free. Running them isn't, and for bigger companies, neither is the permission.