# Kimi K3

> Source: https://aiwiki.ai/wiki/kimi_k3
> Updated: 2026-07-31
> Fact-checked: 2026-07-28
> Categories: AI Models, Chinese AI, Large Language Models, Mixture of Experts, Open Source AI
> License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/) - attribute to "AI Wiki (aiwiki.ai)"
> Cite as: AI Wiki. "Kimi K3." aiwiki.ai, 31 Jul 2026. https://aiwiki.ai/wiki/kimi_k3
> From AI Wiki (https://aiwiki.ai), the free encyclopedia of artificial intelligence. Reuse freely with attribution.

**Kimi K3** is an open-weight multimodal [reasoning model](https://aiwiki.ai/wiki/reasoning_model) developed by [Moonshot AI](https://aiwiki.ai/wiki/moonshot_ai). Moonshot made the model available through its hosted products on July 16, 2026 and published the weights, code, configuration, custom license, and a 47-page technical report on July 27.[1][2][3][4] K3 succeeds the [Kimi K2](https://aiwiki.ai/wiki/kimi_k2) family and powers the [Kimi](https://aiwiki.ai/wiki/kimi) assistant, Kimi Work, Kimi Code, and Moonshot's API.[1][2]

K3 is a sparse [mixture-of-experts](https://aiwiki.ai/wiki/mixture_of_experts) model with 2.78 trillion total parameters and 104.2 billion parameters activated for each token. It contains 896 routed experts, selects 16 of them per token, and also uses two shared experts.[4] Its 93-layer backbone combines Kimi Delta Attention, a form of [linear attention](https://aiwiki.ai/wiki/linear_attention), with gated multi-head latent attention. The model has a 1,048,576-token [context window](https://aiwiki.ai/wiki/context_window) and a 401-million-parameter MoonViT-V2 visual encoder.[4][5]

Moonshot describes K3 as an open-source model, but the released checkpoint uses a custom Kimi K3 License with commercial conditions. This article uses the narrower term "open-weight" to distinguish public access to the trained parameters from an unrestricted or Open Source Initiative-approved license.[12][13] The public checkpoint is quantized, and the official deployment guidance targets server inference engines even though the files and code are downloadable.[5]

## Release

Moonshot, led by co-founder [Yang Zhilin](https://aiwiki.ai/wiki/yang_zhilin), announced K3 on July 16, 2026.[14] The hosted model was immediately available on kimi.com, in Kimi Work and Kimi Code, and through the Kimi API. The announcement promised full weights by July 27 rather than presenting the launch-day service as a downloadable release.[1] Moonshot met that date: the official GitHub and Hugging Face repositories now contain the model card, configuration, custom modeling code, checkpoint files, license, and technical report.[3][5]

The release drew attention partly because of the gap between total and active parameter counts. Headlines commonly shortened the specification to a "2.8-trillion-parameter model," but sparse routing means only part of the network is used for a token. The technical report gives more precise figures of 2.78 trillion total parameters and 104.2 billion activated parameters.[4] Selecting 16 of 896 routed experts is not itself enough to derive the active count because the model also contains shared experts, attention modules, embeddings, and other dense components.

K3 was released during a period of rapid model development in China. Independent coverage compared its reception with earlier releases from [DeepSeek V4](https://aiwiki.ai/wiki/deepseek_v4) and [Zhipu AI](https://aiwiki.ai/wiki/zhipu_ai), including the [GLM-5](https://aiwiki.ai/wiki/glm_5) family.[14] Those comparisons describe industry context, not a common evaluation of the models.

Hosted demand exceeded Moonshot's planned capacity during the first weekend. The company temporarily paused new subscriptions while prioritizing existing subscribers and adding capacity.[15] The episode is evidence about rollout demand and service capacity. It does not establish model accuracy, minimum self-hosting hardware, or general market leadership.

## Architecture

### Model configuration

The published technical report and checkpoint configuration agree on the main architecture.[4][6]

| Field | Published value |
| --- | --- |
| Architecture | Sparse mixture of experts |
| Transformer layers | 93, including one dense layer |
| Total parameters | 2.78 trillion |
| Activated parameters | 104.2 billion per token |
| Hidden dimension | 7,168 |
| Attention heads | 96 |
| Routed experts | 896 |
| Experts selected per token | 16 |
| Shared experts | 2 |
| Latent MoE dimension | 3,584 |
| Expert hidden dimension | 3,072 |
| Attention composition | 69 KDA layers and 24 gated MLA layers |
| Vocabulary size | 163,840 |
| Training context length | 1,048,576 tokens |
| Vision encoder | MoonViT-V2, 27 layers, about 401 million parameters |
| Released expert-weight format | MXFP4, with MXFP8 expert-input activations |

The 69-to-24 attention split follows a repeated pattern of three Kimi Delta Attention layers followed by one gated multi-head latent attention layer. The checkpoint configuration identifies full-attention layers at every fourth layer through layer 92 and again at layer 93.[4][6] This hybrid design retains periodic global attention instead of replacing every attention layer with a recurrent mechanism.

The technical report also lists one multi-token-prediction layer in its training architecture. The released inference configuration sets `num_nextn_predict_layers` to zero.[4][6] This difference indicates that the distributed checkpoint omits that auxiliary prediction head from inference; it does not imply that the report's training architecture is incorrect.

### Kimi Delta Attention

Kimi Delta Attention, or KDA, was introduced in the 2025 Kimi Linear paper. KDA extends Gated DeltaNet with finer-grained, channel-wise gating over a finite recurrent state.[7] In contrast with conventional causal attention, whose [KV cache](https://aiwiki.ai/wiki/kv_cache) grows with sequence length, the recurrent part maintains a fixed-size state. K3 combines this mechanism with periodic global attention so that long-range processing does not depend on KDA alone.

K3 carries no explicit positional embedding. The report states that positional information is encoded implicitly through KDA's recurrent gating and decay, and that no positional encoding (NoPE) is applied to the queries and keys of every MLA layer, so the model extrapolates without a rotary scheme.[4]

The Kimi Linear paper evaluated a smaller research model with 48 billion total and 3 billion activated parameters. Under that paper's matched setup, the authors reported up to 75 percent less KV-cache use and up to six times the decoding throughput of a full-attention baseline at a one-million-token context.[7] Those measurements are evidence for the precursor architecture, not direct performance measurements of the much larger K3 checkpoint. Moonshot's K3 report describes additional kernels, context parallelism, and state-aware prefix caching designed for the hybrid KDA and MLA stack.[4]

### Attention Residuals

Attention Residuals, or AttnRes, changes information flow across model depth. A conventional pre-normalized transformer adds each layer's output to a single residual stream with a fixed weight. Full AttnRes instead lets a layer attend to representations from earlier depths using learned, input-dependent weights.[8]

Keeping every earlier representation would add memory and communication costs. Block AttnRes groups layers and attends over block-level representations, retaining ordinary residual accumulation within each block. The precursor paper tested the method in a 48-billion-parameter Kimi Linear model trained on 1.4 trillion tokens and reported improvements across its evaluated tasks.[8] K3 applies Block AttnRes at much larger scale, but the precursor results should not be treated as an independent K3 benchmark.

### Mixture-of-experts routing

K3 increases [sparsity](https://aiwiki.ai/wiki/sparsity) relative to K2. The technical report compares K3's 896 routed experts, 16 selected experts, and two shared experts with K2's 384 routed experts, eight selected experts, and one shared expert.[4] Moonshot calls the K3 routing framework Stable LatentMoE and reports an approximate 2.5-fold gain in scaling efficiency over K2 when architecture, data, and training changes are considered together.[1][4] That efficiency figure is a developer-reported scaling-law result rather than an independently replicated deployment measurement.

## Multimodal processing

MoonViT-V2 is a 27-layer vision transformer with about 401 million parameters. The technical report says Moonshot trained it from scratch and jointly optimized language and visual tokens from the beginning of K3 pretraining, rather than attaching a separately pretrained vision encoder after language-model training.[4] Images and video frames are projected into the same token stream used by the language backbone.

There are two different but compatible descriptions of modality in the release materials. The official model-summary table labels the checkpoint "Text, Image," and the public self-hosting examples demonstrate image-and-text requests.[5] The technical report states that MoonViT-V2 processes images and videos, and Moonshot's hosted API accepts video files through its Files API.[4][9] Video should therefore be described as a documented model and hosted-API capability, while direct video ingestion still depends on the inference runtime and preprocessing interface.

The one-million-token limit is shared by text and encoded visual inputs. A large context can hold more material, but long-context research has found that models may use information differently depending on its position.[24] It also does not make visual or long-document answers automatically reliable.

## Training and numerical format

The report describes native multimodal pretraining, large-scale reinforcement learning, and post-training for coding, knowledge work, tool use, and visual tasks.[4] It does not publish the complete training corpus or enough information to reproduce the full training run. Results about data quality, scaling efficiency, and post-training gains therefore remain developer findings.

Moonshot applied [quantization-aware training](https://aiwiki.ai/wiki/quantization_aware_training) during post-training. The released checkpoint uses MXFP4 for the routed expert weights and MXFP8 for their input activations.[4][5] The configuration excludes attention modules, shared experts, the dense multilayer perceptron, output head, vision tower, and multimodal projector from that four-bit weight scheme; those components remain in bfloat16.[6] It is therefore inaccurate to describe every parameter in the released checkpoint as a four-bit weight.

The official model card documents deployment through [vLLM](https://aiwiki.ai/wiki/vllm), [SGLang](https://aiwiki.ai/wiki/sglang), and TokenSpeed.[5] These instructions establish software support but do not specify a consumer-hardware minimum. Moonshot's launch post separately recommends running K3 on supernode configurations with 64 or more accelerators, on the reasoning that inference efficiency benefits from larger high-bandwidth communication domains.[1] Community quantizations are derivative releases and should not be confused with Moonshot's official checkpoint.

## Open-sourced infrastructure

Around the July 27 weight release, Moonshot pointed developers at three infrastructure repositories that sit under the model: FlashKDA, MoonEP, and AgentENV. All three carry the [MIT license](https://aiwiki.ai/wiki/mit_license) rather than the custom Kimi K3 License that covers the weights.[25][27][28] The technical report footnotes the MoonEP and AgentENV repositories directly and cites FlashKDA as the kernel behind K3's chunkwise KDA path.[4]

| Project | Purpose | Repository | License | First published |
| --- | --- | --- | --- | --- |
| FlashKDA | CUTLASS chunkwise kernels for Kimi Delta Attention, used for training and inference prefill | MoonshotAI/FlashKDA | MIT | April 2026 |
| MoonEP | [Expert-parallel](https://aiwiki.ai/wiki/expert_parallelism) communication library using dynamic redundant experts | MoonshotAI/MoonEP | MIT | July 2026 |
| AgentENV | Firecracker microVM platform for running agent environments at scale | kvcache-ai/AgentENV | MIT | July 2026 |

Only one of the three was published by Moonshot in July. FlashKDA is a pre-existing component that the K3 stack builds on: its repository has been public since April 20, 2026, with a design deep-dive and H20 benchmark file dated April 22, and it was re-announced rather than introduced at the K3 launch.[25][26][29] AgentENV is published under the kvcache-ai organization, not MoonshotAI, and the report describes it as developed in collaboration with partners; Moonshot released no agent-environment repository under its own GitHub organization in July 2026.[4][28] MoonEP is the one genuinely new Moonshot repository of the three, created on July 24, 2026.[27]

### FlashKDA

FlashKDA is a [CUTLASS](https://aiwiki.ai/wiki/cutlass)-based chunkwise kernel that overlaps intra-chunk computation with cross-chunk state propagation, the serial step that otherwise leaves streaming multiprocessors idle while the recurrent state advances. The report says the kernel decomposes work into token-parallel stages and a head-parallel recurrence, tuned independently, substantially outperforms the Triton reference implementation, serves both training and inference prefill, and is auto-dispatched as a backend of flash-linear-attention.[4] The repository requires SM90 or newer, [CUDA](https://aiwiki.ai/wiki/cuda) 12.9 or newer, and PyTorch 2.4 or newer; it supports variable-length batching through a `cu_seqlens` argument so sequences of different lengths pack into one kernel call, and it constrains key and value head dimensions to 128.[25]

Moonshot's launch announcement reported a 1.72-fold to 2.22-fold prefill speedup over the flash-linear-attention baseline on [H20](https://aiwiki.ai/wiki/nvidia_h20) GPUs.[29] The benchmark file in the repository, generated on April 22, 2026, reports a slightly different range for the configurations it lists: 1.85-fold to 2.31-fold against the `fla_chunk_kda` reference, and 1.17-fold to 1.43-fold against a gated DeltaNet reference, at 8,192 tokens with 64 or 96 heads.[26] Either way these are developer measurements on one accelerator type, not general figures.

vLLM adopted the kernel for K3's KDA prefill path and described the follow-on work as a loop rather than a handoff: an independent contributor, Shikhar Mishra, optimized the kernels for [H100](https://aiwiki.ai/wiki/nvidia_h100) and published Flash-Flash-KDA, and vLLM then validated those improvements on [GB300 NVL72](https://aiwiki.ai/wiki/nvidia_gb300_nvl72) hardware and folded them into its own FlashKDA integration.[31]

### MoonEP

MoonEP is an expert-parallel communication library whose stated guarantee is that every rank receives exactly S x K tokens, where S is the number of input tokens per rank and K is the routed top-k per token, no matter how skewed routing becomes.[27] It reaches that balance by planning a bounded set of redundant experts online from the current router outputs and prefetching them before expert computation, then reducing their gradients back to their home ranks in the backward pass. Section 5.2.1 and Appendix E of the technical report carry the formal argument: at most E/R redundant experts per rank always suffice, where E is the number of experts and R the expert-parallel size, and the bound is essentially tight, since router outputs exist that force ceil(E(R-1)/R^2) redundant experts.[4] Reserving that many slots means the planner never fails and training is never interrupted, in contrast with schemes that preset a redundancy count or impose a per-rank token cap.[4] A fused permute and unpermute operator writes tokens straight into their expert-grouped positions on remote ranks, so a fixed S x K communication buffer suffices where [DeepEP](https://aiwiki.ai/wiki/deepep) would need S x K x R for the same copy-free path, and the resulting static shapes remove the per-layer host-device synchronization that conventional MoE implementations require.[4][27]

Moonshot's own benchmarks run on H20 at an expert-parallel size of 8 while sweeping router imbalance. They report that MoonEP's communication time stays nearly flat as imbalance grows while DeepEP v2, whose latency is set by the hottest rank, degrades steadily, and that end-to-end training time is unaffected while DeepEP eventually fragments memory and runs out of it. The repository publishes these comparisons as plots with no numeric tables, so no speedup figure should be quoted from them, and they are in any case vendor measurements at a single parallel size on a single GPU type.[27] The report frames MoonEP as a [distributed training](https://aiwiki.ai/wiki/distributed_training) scheme, the recipes vLLM published for K3 still select DeepEP v2 for RDMA or a FlashInfer [NVLink](https://aiwiki.ai/wiki/nvlink) backend for all-to-all rather than MoonEP, and no independent benchmark of the library had appeared as of July 31, 2026.[4][32] Supported devices are NVIDIA GPUs, with a "Zhenwu PPU" listed as under review. A separate article covers the library in more detail: see [MoonEP](https://aiwiki.ai/wiki/moonep).

### AgentENV

AgentENV runs the sandboxes used for K3's agentic [reinforcement learning](https://aiwiki.ai/wiki/reinforcement_learning) and evaluation.[4][28] Moonshot replaced container-based sandboxes with Firecracker microVMs after observing kernel panics and deadlocks caused by unintended agent operations in container runtimes, and because harder tasks need environments in which an agent can mount disks, run containers, or start virtual machines without breaking the host.[4]

The system supports incremental checkpointing that saves only the memory pages dirtied since the last checkpoint. The technical report gives checkpoint and resume latencies as low as 133 ms and 49 ms; the repository states that snapshot-backed environments boot or resume in under 50 ms, pause in under 100 ms, and complete incremental snapshots in under 100 ms even under heavy disk modification.[4][28] Three higher-level operations sit on top. Pause and resume frees a sandbox's memory and CPU while it waits, which matters because waiting for model inference can account for as much as 98 percent of a sandbox's lifetime. Fork clones a running sandbox so a reward can be judged without side effects. Periodic snapshots cover error recovery.[4] Images load on demand through the OverlayBD format with a custom ublk driver, storage-layer sharing, and peer-to-peer transport, and copy-on-write memory plus page-cache optimization produced a memory overcommit ratio of up to 6.5 times in Moonshot's workloads.[4][28] Across K3's training and evaluation, Moonshot reports creating 51,219,741 sandboxes from 1,505,678 distinct images.[4]

The server exposes an E2B-compatible HTTP API, so existing agent code can point at it by changing the endpoint URL. It needs Linux kernel 6.8 or newer and access to `/dev/kvm`, and installs from a script on Ubuntu 24.04, from Docker, or onto a Kubernetes cluster. The repository warns that AgentENV has no authorization support and should not be exposed to a public network.[28]

## Reasoning and context handling

K3 always uses a reasoning mode in Moonshot's hosted API. Current documentation supports `low`, `high`, and `max` reasoning effort, with `max` as the default.[9] This differs from the July 16 announcement, which said only maximum effort was available at launch and that lower settings would follow.[1] The current API behavior reflects a post-launch service update, not three separate checkpoints.

Streaming responses separate `reasoning_content` from final-answer `content`. For multi-turn conversations and tool loops, Moonshot instructs clients to return the complete prior assistant message, including reasoning content and tool calls, rather than keeping only the visible answer.[9] The requirement is part of the hosted conversation protocol and does not mean that a user must display the reasoning trace.

The documented context limit is 1,048,576 tokens. The API defaults `max_completion_tokens` to 131,072 and permits a value up to the model's context limit, but input and generated output share the available context budget.[9][10] Automatic [context caching](https://aiwiki.ai/wiki/context_caching) can reuse an unchanged prefix after an eligible preceding prompt exceeds 256 tokens. No explicit cache identifier or time-to-live parameter is required for ordinary requests.[9]

K3's API also supports image and video input, structured JSON-schema output, tool-choice constraints, dynamically loaded tool definitions, partial completion, and tool calls.[9] These are properties of Moonshot's hosted interface. Third-party providers may expose a different subset even when they use an OpenAI-compatible request format.

## Evaluation

### Developer-reported results

Moonshot's model card and report publish results across reasoning, coding, agent, knowledge-work, and visual benchmarks.[3][4] Representative K3 results are summarized below without using competitor scores as proof of overall rank.

| Evaluation | K3 result reported by Moonshot | Material setup note |
| --- | --- | --- |
| GPQA Diamond | 93.5 percent | Maximum reasoning effort, temperature 1.0 |
| HLE-Full | 43.5 percent without tools; 56.0 percent with tools | Tool-assisted and unassisted values are separate |
| DeepSWE v1.1 | 67.5 percent | Kimi Code harness; official mini-SWE-agent result reported as 67.3 |
| Terminal-Bench 2.1 | 88.3 percent | Best scores across different harnesses were used for comparison models |
| [BrowseComp](https://aiwiki.ai/wiki/browsecomp) | 91.2 percent | Context compaction at 300,000 tokens; 90.4 percent without compaction |
| Video-MME with subtitles | 90.0 percent | Developer-run multimodal evaluation |

All K3 results in the main comparison table used maximum reasoning effort and temperature 1.0. Agentic rows used different harnesses across model families, including Kimi Code, Claude Code, and Codex. Some comparison values came from third-party leaderboards, some were Moonshot reruns, and several tasks used tools or modified infrastructure.[3][4] For example, Moonshot's SWE-Marathon run used an H20-calibrated task branch instead of the benchmark's official H100 setting. These conditions make a statement such as "K3 beat every closed model" unsupported.

The comparison table included [Claude Opus 4.8](https://aiwiki.ai/wiki/claude_opus_4_8), [GPT-5.5](https://aiwiki.ai/wiki/gpt-5.5), [Claude Fable 5](https://aiwiki.ai/wiki/claude_fable_5), [GPT-5.6 Sol](https://aiwiki.ai/wiki/gpt_5_6), and [GLM-5.2](https://aiwiki.ai/wiki/glm_5_2).[3][4] Moonshot itself said K3's overall performance still trailed the strongest proprietary systems in its comparison.[1] Individual benchmark values should be cited with their harness and date rather than converted into a permanent model ranking.

### Independent evaluation

[Artificial Analysis](https://aiwiki.ai/wiki/artificial_analysis) reported a score of about 57 on its Intelligence Index v4.1 after the hosted launch.[16] That was an independent API evaluation, but it remained a dated score for a particular endpoint, model revision, and test suite. Live rank, latency, throughput, token use, and price measurements change as providers and leaderboards update, so the article does not preserve launch-hour rank positions or service-speed snapshots.

The United Kingdom AI Security Institute and the United States Center for AI Standards and Innovation conducted a preliminary joint cyber assessment. K3 scored 32 percent on their 41-task ExploitBench evaluation, compared with 24 percent for GLM-5.2, but achieved arbitrary code execution on none of the 41 tasks. In a 32-step simulated enterprise attack path, it reached step 17 on average and completed the full path once in ten attempts.[17] The leading closed models tested by the evaluators progressed further.

The evaluators also found that K3's hosted safeguards did not consistently prevent attempts at exploit development or offensive cyber operations.[17] Their assessment was selective, the overall K3 capability estimate relied on fewer tasks than the comparison estimates, and system safeguards were disabled for the closed US models. The results are therefore useful evidence of both capability and safety limitations, not a complete certification.

## Access and pricing

Moonshot exposes `kimi-k3` through an OpenAI-compatible chat-completions API and provides hosted access through the Kimi product family.[2][9] The official model repository documents self-hosting with multiple inference engines.[5] Aggregators such as [OpenRouter](https://aiwiki.ai/wiki/openrouter) also list K3, but provider availability, rate limits, and feature parity can change independently of the model release.[18]

As of July 28, 2026, Moonshot listed the following API rates per one million tokens, excluding taxes:[11]

| Token category | Listed price |
| --- | --- |
| Cached input | US$0.30 |
| Uncached input | US$3.00 |
| Output, including reasoning tokens | US$15.00 |

Moonshot lists one flat rate at all context lengths and applies the discounted input price when automatic prefix caching hits.[9][11] Prices are service terms, not model specifications, and should be checked on the live pricing page before budgeting a deployment.

## Self-hosting and deployment economics

The public checkpoint is large enough that hardware, not the license, decides who can run it. The Hugging Face repository holds about 1.561 TB across 118 files.[34] AMD's independent accounting, derived from the safetensors headers of 497,220 tensors, gives 1,560.86 GB.[30] Both figures describe the mixed MXFP4 and bfloat16 representation rather than a four-bit copy of every parameter.

### Published configurations

| Publisher | Configuration | What was actually shown |
| --- | --- | --- |
| [AMD](https://aiwiki.ai/wiki/amd), July 27, 2026 | 8 x [Instinct MI355X](https://aiwiki.ai/wiki/amd_instinct_mi355x) at [tensor-parallel](https://aiwiki.ai/wiki/tensor_parallelism) size 8 | Loaded and functionally validated with AMD's ATOM engine at a 16,384-token maximum model length[30] |
| vLLM, July 27, 2026 | 8 x B300 or 8 x MI355X | Described as the easiest way to run K3; the recipe page asks for at least 8 x GB300 on CUDA and at least 8 x MI355X or MI350X on ROCm, with multiple nodes advised for production traffic[31][32] |
| vLLM | 16 x [B200](https://aiwiki.ai/wiki/nvidia_b200) or GB200 | Stated minimum to serve on that hardware generation, since by vLLM's account the model can barely fit in a single NVIDIA [DGX B300](https://aiwiki.ai/wiki/nvidia_dgx_b300)[31] |
| SGLang | B300 1x8, GB300 2x4, B200 2x8, GB200 4x4, [H200](https://aiwiki.ai/wiki/nvidia_h200) 2x8, H100 4x8, MI350X or MI355X 1x8 | Node counts follow the hardware recipe rather than being chosen separately; the 32-GPU H100 recipe is flagged as having the least headroom after weights load[33] |
| Moonshot AI, July 16, 2026 | Supernode with 64 or more accelerators | Recommended for inference efficiency because it enlarges the high-bandwidth communication domain, not stated as a minimum[1] |

AMD's post is the most detailed public single-node accounting. Under ATOM's tensor-by-tensor placement rules, every rank keeps all 896 expert IDs and shards each expert's matrices, so each of the eight MI355X GPUs holds about 190.974 GiB of weights. Adding the known runtime state for one 1M-token sequence with an FP8 latent KV cache brings the total to about 205.401 GiB, or 71.3 percent of the 288 GiB of HBM3E on each card, leaving roughly 82.6 GiB per GPU before kernel workspaces, communication buffers, allocator fragmentation, and CUDA graphs are counted.[30] Most of that runtime state is MLA latent KV, about 14.5 GB per GPU across the 24 MLA layers; the 69 KDA layers contribute under a tenth of a gigabyte because their recurrent and convolution states do not grow with sequence length.[30]

### Loading a model is not serving it

AMD validated correctness, not speed. Its run completed the full 1,319-sample GSM8K 5-shot evaluation at a 16,384-token maximum model length, and the post states plainly that it "does not make claims about throughput, time to first token (TTFT), time per output token (TPOT), or kernel efficiency."[30] An eight-GPU node that loads the checkpoint therefore establishes nothing about whether it can serve a million-token context at a useful rate or at any level of concurrency.

Published speed figures come from larger systems and from the serving projects themselves. vLLM measured 111 output tokens per second per user at tensor-parallel size 8 and 118 at size 16, both at batch size 1 on GB300 NVL72 hardware, rising to 331 and 370 tokens per second with the DSpark [speculative decoder](https://aiwiki.ai/wiki/speculative_decoding), about a 3.14-fold gain on its SPEED Bench harness.[31] vLLM also validated accuracy through a served OpenAI-compatible endpoint at maximum reasoning effort, reporting 0.976 on GSM8K, 0.939 on GPQA-Diamond, 0.889 on OCRBench, and 0.818 on MMMU Pro Vision, and warned that low scores on this model usually indicate truncated generations rather than wrong answers.[31]

### Engines and precision options

Moonshot's model card recommends three [inference engines](https://aiwiki.ai/wiki/inference_engine): vLLM, SGLang, and TokenSpeed.[5] KTransformers, a hybrid CPU and GPU engine from the same kvcache-ai organization that publishes AgentENV, is sometimes named in community discussion, but its repository does not document Kimi K3 support and Moonshot's model card does not list it.

Precision choices move the memory bill more than the hardware list does. SGLang exposes an FP8 E4M3 KV cache that halves KV memory and a bfloat16 or float16 KDA state that halves state memory, and it offers W4A8 or W4A4 MoE execution with its MegaMoE backend; on Blackwell it runs the MXFP4 weights through FlashInfer W4A8 kernels and falls back to Marlin W4A16 on H100 and H200.[33] A single sizing flag, `--mamba-full-memory-ratio`, divides static memory between a worst-case KDA state pool that sets the concurrency ceiling and a paged MLA KV pool.[33] vLLM supports an FP8 KV cache, selects `deepep_v2` for RDMA fabrics and a FlashInfer NVLink one-sided backend otherwise, and recommends `deep_gemm_mega_moe` for disaggregated expert-parallel setups; on AMD it chooses between AITER a16w4 and a8w4 MoE paths.[31][32] Both projects support prefill and decode disaggregation, which runs the two phases on separately sized replicas.[31][33]

### Cost estimates

No vendor in this chain publishes list prices for the servers involved, so the circulating cost figures are estimates rather than quotes. An analysis by the Zhihu contributor 平凡, summarized in English on July 28, 2026, put an 8 x MI355X server at US$250,000 to US$350,000, which the author converted to roughly RMB 1.7 million to 2.4 million, and gave RMB 4.35 million to 5.7 million for 16 x H200, RMB 5.4 million to 6.8 million for 16 x B200, and, for a 64-GPU MI355X deployment across eight servers, RMB 13.6 million to 19 million in hardware, RMB 4.09 million to 9.86 million a year in cloud rental, close to 100 kW of power draw, and close to RMB 1 million a year in electricity.[35]

Those numbers are one analyst's estimates. They are not vendor prices, no primary source corroborates them, the currency conversions are the author's own, and the original Zhihu answer returned an access-restricted error when this article was checked on July 31, 2026. One detail does not survive comparison with the published recipes: the analysis described a 24-GPU H100 configuration with limited memory headroom, whereas SGLang's H100 recipe uses 32 GPUs across four nodes and describes that shape, not a 24-GPU one, as the tightest fit after weights load.[33][35]

The structural argument is easier to check than the prices. K3 activates 16 of 896 routed experts per token, so the full expert pool has to stay resident across the parallel domain and tokens move between devices continuously, which makes interconnect bandwidth the limiting factor rather than raw compute.[30] That is the same reasoning Moonshot gives for recommending 64 or more accelerators in one high-bandwidth domain, and why vLLM's production recipes assume several nodes joined by RDMA or NVLink.[1][31]

### Reception of the open-weight release

The argument the release provoked was less about capability than about what publishing weights actually buys. vLLM's engineers wrote that the model "can barely fit in a single NVIDIA DGX B300" and requires at least 16 B200 or GB200 GPUs to serve on that generation.[31] The Zhihu analysis concluded that "the model is open" while "the infrastructure required to use it is now the real barrier," and argued that models at K3's scale resemble national infrastructure more than personal software, with API calls remaining the cheaper option for most companies.[35]

Sebastian Raschka, writing on July 28, 2026, described K3 as "essentially a scaled-up production version" of Kimi Linear, scaled from 48 billion to 2.8 trillion parameters, and "by far the biggest open-weight model right now." He read the architecture as a set of inference-efficiency substitutions, singled out Attention Residuals as the one change that is not an efficiency tweak, and called K3 the first frontier-level model he knew of to use no positional embeddings throughout.[36] Uptake was not merely theoretical: the Hugging Face repository recorded roughly 493,000 downloads and 9,100 likes on July 31, 2026, four days after the weights appeared, though the Hub's download counter covers a rolling window and does not indicate how many of those copies were ever served.[34]

## Weights and license

The official weights were absent at the hosted launch and became public on July 27.[1][3][5] The release contains a quantized inference checkpoint rather than the unquantized training master. Its model card labels the model open-weight and the Hugging Face metadata identifies the license as `kimi-k3`, not MIT or Apache.[5]

The Kimi K3 License grants rights to use, copy, modify, distribute, sublicense, sell, deploy, and fine-tune the software, subject to its conditions.[12] The term "Software" includes weights, parameters, configuration, inference and training code, and documentation.

Two scale-related provisions are especially important:

- A licensee or affiliate operating a model-as-a-service business with more than US$20 million in aggregate revenue over any consecutive 12 months must enter a separate agreement with Moonshot before commercial use.
- A commercial product or service with more than 100 million monthly active users or more than US$20 million in monthly revenue must display "Kimi K3" prominently in its interface.

The license exempts defined internal use and access through Moonshot's official products or certified inference partners from those two provisions.[12] Its model-as-a-service definition also excludes certain embedded end-user features and mere relaying to models hosted by others. Anyone planning deployment must read the complete license rather than rely on this summary.

These use-based commercial conditions distinguish K3's license from the Modified MIT terms used for [Kimi K2.6](https://aiwiki.ai/wiki/kimi_k2_6).[12][19] They also explain why public weights alone do not settle whether a model meets a particular definition of open-source AI.[13] The three infrastructure repositories released around K3 are governed separately and permissively: FlashKDA, MoonEP, and AgentENV are all MIT licensed, so the restrictive terms apply to the model, not to the tooling built around it.[25][27][28]

## Place in the Kimi family

K3 follows several stages in Moonshot's model development:

- [Kimi K1.5](https://aiwiki.ai/wiki/kimi_k1_5) introduced a multimodal long-context reinforcement-learning approach in January 2025.[23]
- Kimi K2 adopted a 1.04-trillion-parameter sparse architecture with about 32.6 billion activated parameters.[4][20]
- [Kimi K2 Thinking](https://aiwiki.ai/wiki/kimi_k2_thinking) added extended reasoning and tool use to the K2 family.[21]
- [Kimi K2.5](https://aiwiki.ai/wiki/kimi_k2_5) added native visual input and Moonshot's Agent Swarm approach.[22]
- Kimi K2.6 focused on long-horizon coding and larger orchestrated agent workflows while retaining the K2-scale backbone.[19]
- Kimi K3 increased total and active scale, replaced most full-attention layers with KDA, added AttnRes, extended training context from 128,000 to about one million tokens, and introduced a new custom license.[4][12]

K3 is therefore not simply a larger K2 checkpoint. It changes the attention stack, depth-wise residual path, expert routing, visual encoder, context length, quantization strategy, and license.

## See also

- [Moonshot AI](https://aiwiki.ai/wiki/moonshot_ai)
- [Kimi](https://aiwiki.ai/wiki/kimi)
- [Kimi K2](https://aiwiki.ai/wiki/kimi_k2)
- [MoonEP](https://aiwiki.ai/wiki/moonep)
- [Mixture of experts](https://aiwiki.ai/wiki/mixture_of_experts)
- [Linear attention](https://aiwiki.ai/wiki/linear_attention)
- [Context window](https://aiwiki.ai/wiki/context_window)
- [OpenRouter](https://aiwiki.ai/wiki/openrouter)

## References

1. Moonshot AI, "Kimi K3: Open Frontier Intelligence" (July 16, 2026). https://www.kimi.com/blog/kimi-k3
2. Kimi Help Center, "Kimi Agent overview," accessed July 28, 2026. https://www.kimi.com/help/agent/agent-overview
3. Moonshot AI, "Kimi K3" official source repository and model card, accessed July 28, 2026. https://github.com/MoonshotAI/Kimi-K3
4. Kimi Team, "Kimi K3: Open Frontier Intelligence," technical report (July 2026). https://github.com/MoonshotAI/Kimi-K3/blob/main/k3_tech_report.pdf
5. Moonshot AI, "moonshotai/Kimi-K3" model repository, accessed July 28, 2026. https://huggingface.co/moonshotai/Kimi-K3
6. Moonshot AI, "Kimi K3 config.json," accessed July 28, 2026. https://huggingface.co/moonshotai/Kimi-K3/blob/main/config.json
7. Kimi Team et al., "Kimi Linear: An Expressive, Efficient Attention Architecture," arXiv:2510.26692 (2025). https://arxiv.org/abs/2510.26692
8. Chen, Guangyu, et al. (Kimi Team), "Attention Residuals," arXiv:2603.15031 (March 16, 2026). https://arxiv.org/abs/2603.15031
9. Kimi API Platform, "Kimi K3," accessed July 28, 2026. https://platform.kimi.ai/docs/guide/kimi-k3-quickstart
10. Kimi Help Center, "Kimi API troubleshooting," accessed July 28, 2026. https://www.kimi.com/help/kimi-api/api-troubleshooting
11. Kimi, "Kimi K3 Pricing Explained: Plans and API Costs," July 18, 2026. https://www.kimi.com/resources/kimi-k3-pricing
12. Moonshot AI, "Kimi K3 License," accessed July 28, 2026. https://github.com/MoonshotAI/Kimi-K3/blob/main/LICENSE
13. Open Source Initiative, "The Open Source AI Definition," accessed July 28, 2026. https://opensource.org/ai/open-source-ai-definition
14. Associated Press, "Chinese AI model takes US tech industry by surprise with abilities rivaling Claude and ChatGPT" (July 17, 2026). https://apnews.com/article/0d8a5e268deb11a673f4d444fc597cc5
15. Associated Press, "China's new AI model halts new subscriptions as demand swamps capacity" (July 20, 2026). https://apnews.com/article/4c66a2e0f557ce79d3cc2d769c9a6226
16. Artificial Analysis, "Kimi K3 achieves #3 in the Artificial Analysis Intelligence Index, comparable to Opus 4.8 and GPT-5.5" (July 17, 2026). https://artificialanalysis.ai/articles/kimi-k3-achieves-3-in-the-artificial-analysis-intelligence-index-comparable-to-opus-4-8-and-gpt-5-5
17. UK AI Security Institute, "UK AISI / CAISI Preliminary Assessment of Kimi K3's Cyber Capabilities" (July 2026). https://www.aisi.gov.uk/blog/preliminary-assessment-of-kimi-k3s-cyber-capabilities
18. OpenRouter, "Kimi K3," accessed July 28, 2026. https://openrouter.ai/moonshotai/kimi-k3
19. Moonshot AI, "Kimi K2.6" model card, accessed July 28, 2026. https://huggingface.co/moonshotai/Kimi-K2.6
20. Kimi Team et al., "Kimi K2: Open Agentic Intelligence," arXiv:2507.20534 (2025). https://arxiv.org/abs/2507.20534
21. Moonshot AI, "Kimi K2 Thinking," November 2025. https://www.kimi.com/blog/kimi-k2-thinking
22. Kimi Team et al., "Kimi K2.5: Visual Agentic Intelligence," arXiv:2602.02276 (2026). https://arxiv.org/abs/2602.02276
23. Kimi Team et al., "Kimi k1.5: Scaling Reinforcement Learning with LLMs," arXiv:2501.12599 (2025). https://arxiv.org/abs/2501.12599
24. Liu et al., "Lost in the Middle: How Language Models Use Long Contexts," *Transactions of the Association for Computational Linguistics* 12 (2024). https://aclanthology.org/2024.tacl-1.9/
25. Moonshot AI, "FlashKDA: high-performance Kimi Delta Attention kernels," GitHub, accessed July 31, 2026. https://github.com/MoonshotAI/FlashKDA
26. Moonshot AI, "FlashKDA KDA forward benchmark (Hopper / H20)," generated April 22, 2026. https://github.com/MoonshotAI/FlashKDA/blob/master/BENCHMARK_H20.md
27. Moonshot AI, "MoonEP: A Perfectly Balanced Expert Parallelism Library via Dynamic Redundant Experts," GitHub, accessed July 31, 2026. https://github.com/MoonshotAI/MoonEP
28. kvcache-ai, "AgentENV (AENV): a platform for running agent environments at scale," GitHub, accessed July 31, 2026. https://github.com/kvcache-ai/AgentENV
29. MarkTechPost, "Moonshot AI Open-Sources FlashKDA: CUTLASS Kernels for Kimi Delta Attention with Variable-Length Batching and H20 Benchmarks" (April 30, 2026). https://www.marktechpost.com/2026/04/30/moonshot-ai-open-sources-flashkda-cutlass-kernels-for-kimi-delta-attention-with-variable-length-batching-and-h20-benchmarks/
30. AMD, "Day 0 Kimi-K3 Inference Deployment with ATOM on AMD Instinct MI355X GPUs" (July 27, 2026). https://www.amd.com/en/developer/resources/technical-articles/2026/kimi-k3-on-amd-instinct-gpus.html
31. vLLM Team and Inferact, "Kimi K3 Is Here: Efficient Day-0 Support on vLLM" (July 27, 2026). https://vllm.ai/blog/2026-07-27-k3
32. vLLM Recipes, "moonshotai/Kimi-K3," accessed July 31, 2026. https://recipes.vllm.ai/moonshotai/Kimi-K3
33. SGLang Documentation, "Kimi-K3" cookbook, accessed July 31, 2026. https://docs.sglang.io/cookbook/autoregressive/Moonshotai/Kimi-K3
34. Hugging Face Hub API, "moonshotai/Kimi-K3" model metadata and file listing, retrieved July 31, 2026. https://huggingface.co/api/models/moonshotai/Kimi-K3?blobs=true
35. Zhihu Frontier (@ZhihuFrontier), English summary of a Kimi K3 deployment-cost analysis by Zhihu contributor 平凡, July 28, 2026. https://x.com/ZhihuFrontier/status/2082013716770664595
36. Sebastian Raschka (@rasbt), commentary on the Kimi K3 architecture, July 28, 2026. https://x.com/rasbt/status/2082098201247600765