Kimi K3.1 Pro, explained: what Moonshot shipped, what it costs, and why the thinking you send back adds up

On 23 October 2026 Moonshot's Kimi Code changelog said "K3.1 Pro Series is live". The model is in two places: Moonshot's API, under the name kimi-k3.1-pro, and Kimi Code, Moonshot's coding agent, on the Plus plan and above (the full 1M-token context needs the Pro plan or above). Moonshot's API quickstart calls it "the first model in our new K3.1 series and our most capable 3T-class open-weight model to date" (3T means about 3 trillion parameters).

There is a second model, kimi-k3.1-pro-highspeed. Moonshot says it has the same quality at about 2 to 3 times the writing speed, and it costs twice as much. In Kimi Code it needs the Pro plan or above.

The weights are promised, not delivered. Moonshot's quickstart says "The full model weights will be released by Nov 4". When I checked on 31 October, Hugging Face (the main website for sharing AI models) listed no K3.1 model under Moonshot's account. The earlier Kimi K3, released in June, is there under its own licence, which allows commercial use with two extra rules for larger companies, set out below. Moonshot has not said whether K3.1 will use the same licence.

Moonshot's pricing page also says the older K2 models close to new sign-ups from 31 October 2026 and will be switched off at the end of December. If your code still calls a K2 model (Moonshot's previous generation), plan the move now.

Because K3.1 Pro is a trained-further K3, the K3 files on Hugging Face describe its shape. Three ideas explain most of it.

First, mixture of experts. Each layer except the first has 896 small sub-networks called experts, and for every token a router (a small part of the model that chooses) picks 16 of them, plus 2 shared experts that always run. So only about 104 billion of the 2.8 trillion parameters do work on each token. That keeps each token fast, but every expert must sit in GPU memory, because any of them may be picked next.

Second, two kinds of attention layer. Attention is the step where a token looks back at the earlier tokens. Of K3's 93 layers, 24 use MLA (Multi-head Latent Attention): they keep a small record for every earlier token, so their memory grows as the conversation grows. The other 69 use KDA (Kimi Delta Attention), which keeps a summary of fixed size, however long the conversation is. Moonshot puts an MLA layer every fourth layer, and at the very end.

Third, small numbers. The experts are stored in MXFP4, a format that uses 4 bits (half a byte) per number, and Moonshot trained the model in that format from its fine-tuning stage onward, rather than shrinking it only at the end. That is why 2.8 trillion parameters fit in about 1.56 TB of files.

This is what decides how many conversations one server can hold. The record each token leaves behind is called the KV cache (key-value cache), and it is what limits how many long conversations a server can hold at once. With only 24 of 93 layers keeping one, and each entry squeezed small, I work out 27,648 bytes per token, or about 29 GB for one conversation that fills the full million tokens, plus about 0.43 GB of fixed KDA state.

Read next: Reading a model name: what 27B, FP8, A3B and Instruct mean

Open weights are why a company would pick this model over a closed one: you can run it on your own servers, keep your data there, and change it. The K3.1 weights are not out, so these numbers use K3's files, which Moonshot says K3.1 is built from.

K3's files on Hugging Face are 1,561 GB. A server with eight NVIDIA H200 cards has 1,128 GB of GPU memory, not enough to hold them. Sixteen H200s (2,256 GB) or eight B300s (288 GB each, 2,304 GB in all) leave about 700 GB for conversations. The vLLM project (free software for serving models) has a recipe for K3 whose default is one server with eight B300 cards, and it recommends more than one server for production traffic.

That leftover memory goes on the attention memory from the section above: about 29.4 GB for one conversation that fills the whole million tokens (29.0 GB of MLA cache plus 0.43 GB of KDA state). On paper eight B300s hold about 25 such conversations at once, and far more short ones. Real numbers are lower, because the serving software needs working memory too.

If you do not want a server like that, use Moonshot's API, or wait for other companies to host the weights once they are out. Moonshot's K3 licence lets anyone use the model commercially, with two extra rules: a company with more than $20 million a year in revenue that sells the model itself as an API needs a separate agreement with Moonshot, and a product with more than 100 million monthly users or $20 million a month in revenue must show "Kimi K3" in its interface. Neither rule applies to internal use, or to use through Moonshot's own products and certified partners. Check whether K3.1's licence says the same when it is published.

Read next: Scaling and GPU infrastructure: serving models without burning money

The facts about the model come from Moonshot's K3.1 Pro quickstart in English and Chinese, both of its pricing pages, the Kimi Code changelog, and the Kimi-K3 model card, config file, licence and code on Hugging Face, all read on 31 October 2026 and linked below. The hardware default is from the vLLM recipe for K3.

I did not send a prompt to K3.1 Pro: this project has no Moonshot key and the weights are not out. So I cannot tell you how good its answers are, how long its thinking really runs, or how fast it writes. Press reports also describe other claims about the release; I left out anything I could not find on Moonshot's own pages.

What I did run is real: the API and Hugging Face checks, the prompt format and token counts with Moonshot's own code and tokenizer, and the cost and memory arithmetic. The thinking text in my test is a stand-in I wrote, and the agent task sizes are assumptions, both stated where they are used.