Kimi K3.1 Pro Weights Released: Licence and Size

Kimi K3.1 Pro is described on its model card as an open-weight, natively multimodal agentic model, post-trained from Kimi K3 and the first model in the K3.1 series. The card does not state a release date, but the Hugging Face API shows the repository was created on 02/11/2026 and last modified on 05/11/2026, inside the window Moonshot had promised.

• Size: 2.8T total and 104B activated parameters, 93 layers (one dense), 896 experts with 16 selected per token and 2 shared.
• Context: 1,048,576 tokens, with attention redesigned relative to K3 for cheaper long-context work.
• Modalities: text and image, through a 401M-parameter MoonViT-V2 vision encoder.
• Precision: trained quantisation-aware for MXFP4 weights and MXFP8 activations.
• Files: 96 safetensors shards, about 2.78 TB in total, plus config, processor and tokenisation code.
• Licence: custom Kimi K3.1-Pro License: permissive, with carve-outs for large Model-as-a-Service businesses and a display requirement for very large products.
• Serving: vLLM, SGLang and TokenSpeed are the recommended engines; an API is available as kimi-k3.1-pro.

All numbers below come from Moonshot's model card, licence file and the public Hugging Face repository metadata. We have not downloaded the 2.78 TB of weights or benchmarked the model ourselves, and benchmark scores are vendor-reported.

At launch, our review flagged three open items: the weights, the licence and independent confirmation. The first two are now answered. The licence turned out to be a bespoke text rather than a reuse of the Kimi K3 licence, which matters because the K3 generation was the one that first brought a 2.8-trillion-parameter model to the open-weight world, as we covered in our Kimi K3 launch article.

Independent confirmation of benchmark claims remains outstanding. With the weights public, that should change: third-party hosts and research groups can now run their own evaluations, and the community will quickly learn whether the model card numbers hold under neutral conditions. Until then, treat the figures as the vendor's.

The timing also fits a busy week for open models. The same news round-up that announced the Kimi weights also covered an open-source computer-use agent, a new image model and a science-focused release, which underlines how much of the frontier conversation in late 2026 is happening in open or semi-open form. Our Mistral Large 4 article tells a parallel story from Europe.

The repository metadata lists 112 files. The important ones are:

• 96 model shards named model-00001-of-000096.safetensors upwards. Hugging Face reports total storage of 2,780,110,363,392 bytes, or about 2.78 TB. The model page lists tensor types F32, BF16 and U8, the last being how packed low-precision weights are stored.
• config.json and generation_config.json describing the architecture and default sampling settings.
• Custom code: configuration_kimi_k3.py, encoding_k3.py, kimi_k3_processor.py, kimi_k3_vision_processing.py and media_utils.py. These handle the architecture definition, chat encoding and image processing, so loading the model through a generic library requires trusting remote code or using an engine with native support.
• LICENSE and a README that doubles as the model card.

The page reported about 11,658 downloads in the last month at the time we checked. Given the file size, that figure is a reminder that most people interacting with the weights will be infrastructure providers and research labs rather than individuals.

The model card publishes a compact specification table. The values below are reproduced from it.

Read quickly, the numbers describe a very sparse model. Only 104 billion of 2.8 trillion parameters, about 3.7%, are used for any single token, and each token is routed to 16 of 896 experts plus 2 shared ones. That ratio is what allows a model this large to be priced competitively through an API, because compute per token tracks the active parameters rather than the total.

Attention and long context

The one structural change the card highlights versus Kimi K3 is attention. Compared with K3, the full-attention Gated MLA layers were replaced with Gated DSA layers for more efficient long-context modelling. The stack is now 69 KDA layers and 24 Gated DSA layers. The DSA settings (index dimension 128, 32 index heads, top-K of 2048) indicate a sparse attention scheme in which each query attends to a limited set of selected tokens rather than the full window.

We should be careful here: the model card gives the configuration but not the research paper detail, so we describe what the numbers imply rather than claiming to know the training recipe. The practical effect Moonshot is aiming for is a one-million-token window that costs less memory and compute to serve than dense attention would. Long-context quality in practice is something independent testers will need to verify.

Quantisation-aware training

The card says the model uses MXFP4 weights and MXFP8 activations through quantisation-aware training. That is important for deployment. A model trained with low precision in mind loses less accuracy when it is served at low precision, and the weights occupy a fraction of the space of a BF16 release. It is a large part of why a 2.8T-parameter checkpoint comes in at about 2.78 TB rather than something closer to 5.6 TB.

The same design choice is part of a wider trend. Labs releasing very large open models are increasingly shipping them in the precision they were trained for, to make real deployments possible on current accelerators. If you are comparing with the other big open release this autumn, our Reflection Beam 501B write-up shows how much smaller a frontier-class open model can be.

This is the section most likely to matter for businesses, and the text is short enough to summarise accurately. The licence is copyright Moonshot AI 2026 and grants permission, free of charge, to use, copy, modify, merge, publish, distribute, sublicense and sell the software, which it defines to include the weights, configuration files, inference and training code and documentation. It also explicitly allows running, deploying and fine-tuning the model and creating derivative works. That is the MIT part. Then come the conditions.

1. Notice and legality. Keep the copyright and permission notice in all copies and comply with applicable laws.
2. Model as a Service threshold. A Model as a Service business gives third parties access to inference or fine-tuning, for example through an API, in a way that lets them exercise meaningful control over inputs, parameters or training data. If you or your affiliates run one and your combined revenue exceeds 20 million US dollars across any consecutive 12 months, you must enter a separate agreement with Moonshot before using the software or derivatives for any commercial purpose. The definition excludes end-user products with the model embedded solely within specific features or harnesses, and mere relaying of requests to models hosted by others.
3. Attribution for very large products. If a commercial product or service using the model or a derivative has more than 100 million monthly active users, or more than 20 million US dollars in monthly revenue, the words Kimi K3.1-Pro must be prominently displayed in its user interface.
4. Exemptions. Sections 2 and 3 do not apply to internal use, meaning any use that does not make the software, its outputs or its capabilities available to third parties, or to use through Moonshot's official products or certified inference partners.
5. No warranty. The standard as-is disclaimer applies.

What that means in practice. A company using the model internally, or embedding it in an application, is free to do so without paying Moonshot. A start-up hosting the model as an API for others is also free, until its combined revenue passes 20 million US dollars (about £15 million at recent rates) in a rolling year, at which point it needs to talk to Moonshot. A hyperscaler selling hosted inference would clearly fall into that second bucket. This is a pragmatic position that keeps the model open for most users whilst protecting Moonshot's commercial position against the largest resellers.

As always, this is a plain-English summary rather than legal advice. Read the licence file in the repository and take advice before building a commercial service on it. If you are weighing licences across open models, our notes on the open-weights policy debate explain why licence details are becoming a policy matter as well as a legal one.

Moonshot reports Kimi K3.1 Pro at reasoning effort max, temperature 1.0 and top-p 0.95 unless noted, and compares it against Claude Fable 5.1, GPT-6 Astra, Claude Opus 5.5, DeepSeek-V4.1-Flash-1017 and GLM-5.3. A selection of the published results:

Other scores reported on the card include Terminal-Bench-Science 38.1, Program Bench 31.5, PostTrain Bench 36.5, CharXiv (reasoning) with Python 93.4, BabyVision with Python 95.4, APEX-Agents 69.4 and Agents' Last Exam 43.2.

How to read it. The pattern is consistent with the launch story: Kimi K3.1 Pro is competitive with the best closed models on agentic coding, browsing and multimodal tasks, close behind on computer use and professional-task Elo, and clearly behind on the hardest reasoning and exploit benchmarks. The two lines where it trails most, HLE-Diamond (39.4 against 65.8) and ExploitBench (74.7 against 100), both involve the strongest Astra results on the card. Our Claude Opus 5.5 against GPT-6 Astra comparison shows how that top tier behaves on neutral tests.

The caveats are standard but real. These are vendor-run results at maximum reasoning effort, which increases token use and cost. Different harnesses and prompts can move agentic scores by several points. And a benchmark table cannot tell you whether the model is pleasant to use for your own tasks. For a head-to-head against a closed model, see our Kimi K3 against Claude Fable 5 scorecard.

The model card recommends three inference engines: vLLM, SGLang and TokenSpeed. It gives two serving examples, vllm serve "moonshotai/Kimi-K3.1-Pro" and a python3 -m sglang.launch_server invocation listening on port 30000, and notes that Docker Model Runner is also supported.

Before you try that, do the arithmetic. The checkpoint alone is about 2.78 TB. Weights have to be held across accelerator memory in the serving cluster, with additional room for the key-value cache that a one-million-token context can demand. That is a multi-node deployment on data-centre GPUs. We do not have a published minimum hardware specification from Moonshot to quote, so any specific GPU count would be our guess, and we will not give one.

What the open weights do make possible, in realistic terms:

• Private deployment for regulated organisations with the budget for a cluster and a requirement that data never leaves their environment.
• Third-party hosting. Inference providers can now offer the model, which tends to create price competition and regional availability, subject to the licence thresholds above.
• Research and interpretability work on a frontier-scale mixture-of-experts model, which until recently required lab access.
• Distillation and fine-tuning into smaller derivatives, which the licence allows. Derivative works fall under the same conditions.

For individuals and small teams, the realistic path remains the hosted API or an inference provider. If you want a feel for what local hardware can handle today, our piece on running local AI on a Mac mini sets expectations for models in the tens of billions of parameters, which is a very different class.

Moonshot's hosted option is available at platform.kimi.ai under the model name kimi-k3.1-pro, with OpenAI-compatible and Anthropic-compatible endpoints. Two operating details from the card are worth knowing:

• Reasoning effort is controlled with a reasoning_effort field that accepts low, high or max. The default is max, which is also the setting used for the published benchmarks. If cost matters, lowering it is the first lever to try.
• Multi-turn and tool use require that the full assistant message, including its reasoning_content and tool_calls, is passed back in the messages on the next turn. Dropping the reasoning content is a common way to degrade an agent loop without realising.

At launch we reported list pricing of $2 and $10 per million input and output tokens (roughly £1.50 and £7.50), which our original review tested against a real agent task. Prices on third-party hosts will now vary, so check the live rates before committing.

One of the more notable disclosures at launch was that Moonshot stripped cyber-related data from training for the planned open-weight release, and that an unfiltered checkpoint scored higher on its internal xdev-bench-hard test. The public model card now lists ExploitBench at 74.7 against 100 for GPT-6 Astra, which is consistent with a model that has been deliberately held back on offensive security capability relative to the very top of the market.

We want to be careful about how far to take this. We have not been able to confirm from the card alone which checkpoint the Hugging Face weights correspond to, or how the filtered and unfiltered versions differ beyond what Moonshot has said. The safest reading is that the open release is the filtered one, as the launch disclosure indicated, and that independent red-team results will tell us more than any vendor statement. Our Kimi K3 sandbox escape coverage is a useful reminder of why those independent results matter for agentic models of this class.

• Enterprises with sovereignty or confidentiality needs that can fund a serious serving cluster, or buy from a provider that has one.
• Inference hosts and cloud providers, who now have a new frontier-adjacent model to offer, within the licence terms.
• AI researchers, for a 2.8T mixture-of-experts model with new sparse attention that can be inspected and fine-tuned.
• Developers using agents, who can try the hosted API now and decide later whether self-hosting ever makes sense.
• Not for: hobbyists expecting to run it on a single machine, or anyone who needs a published safety system card before adopting a model.

• No independent benchmark confirmation yet. Everything on the model card is Moonshot's own measurement at maximum effort.
• Hardware requirements are unpublished. The card names engines but not a minimum cluster size.
• Custom code in the repository. Loading it generically means running the supplied Python files, so review them or use an engine with built-in support.
• Licence thresholds. The 20 million dollar revenue and 100 million user triggers are simple to state but need legal reading for complex groups of companies.
• Safety documentation. The model card is a technical card, not a full system card with third-party red-team results.
• Cyber filtering. The extent of the data filtering for the open checkpoint is only described at a high level.

Moonshot did what it said it would. Kimi K3.1 Pro is a real, downloadable, 2.8-trillion-parameter open-weight model with a permissive-but-conditional licence, a one-million-token context and frontier-adjacent benchmark claims. The caveats are mostly about practicality: it is enormous, the hardware guidance is thin, and the numbers still need outside verification.

Our advice is unchanged in spirit and sharper in detail. Use the hosted API to test it on your own work, read the licence before building a service on top, and wait for independent evaluations before treating the model card as settled. We will update this article when third-party benchmarks and hosting prices appear.

• Hugging Face: moonshotai/Kimi-K3.1-Pro: model card, specification table, benchmarks and deployment notes.
• Kimi K3.1-Pro License: full licence text.
• Hugging Face API: repository metadata: creation and modification dates, file list and total size.
• Matthew Berman on YouTube (05/11/2026): open-source AI news round-up covering the release.

Hero: Kimi K3.1 Pro logo from the Moonshot AI Hugging Face repository, compressed to AVIF.