ApX logoApX logo

Kimi-Dev-72B

Parameters

72B

Context Length

131K

Modality

Text

Architecture

Dense

License

MIT License

Release Date

16 Jun 2025

Knowledge Cutoff

-

System Requirements

VRAM requirements for different quantization methods and context sizes

1,024 tokens

153.05 GB VRAM

Consumer

8x RTX 4090

24GB VRAM

Datacenter

3x NVIDIA A100

80GB VRAM

Apple Silicon

2x Apple M3 Max

128GB VRAM

131,072 tokens

197.80 GB VRAM

Consumer

10x RTX 4090

24GB VRAM

Datacenter

3x NVIDIA A100

80GB VRAM

Apple Silicon

2x Apple M3 Max

128GB VRAM

Architecture Diagram

Input TokensToken EmbeddingPosition: AbsoluteHidden: 8.2k · Context: 131K · Vocab: 152.1kx 80 layersRMSNormPre-AttentionMulti-Head Attention64Q / 8KV headsHead dim: 128+RMSNormPre-FFNFeed-Forward NetworkSwiGLUIntermediate: 29.6k+Final RMSNormOutput Logits

Evaluation Benchmarks

No evaluation benchmarks for Kimi-Dev-72B available.

Rankings

Overall Rank

-

Coding Rank

-

About Kimi-Dev-72B

Kimi-Dev-72B is a specialized large language model developed by Moonshot AI, engineered specifically for autonomous software engineering and complex issue resolution. Built upon the Qwen2.5-72B foundational architecture, the model undergoes a sophisticated multi-stage training process designed to instill structured skill priors for software development tasks. This process includes a large-scale mid-training phase using approximately 150 billion tokens of high-quality, real-world data from GitHub issues and pull request commits, enabling the model to internalize the reasoning patterns and technical workflows employed by human developers. Unlike general-purpose coding assistants, Kimi-Dev-72B is optimized to function as an autonomous agent capable of localized file identification and precise code editing.

The model's core innovation lies in its duo-stage framework, comprising specialized "BugFixer" and "TestWriter" behaviors. This architecture facilitates a two-step operational cycle: first, the model identifies the relevant files within a repository (File Localization), and second, it generates the necessary code modifications or unit tests (Code Edits). The training methodology leverages large-scale reinforcement learning (RL) with outcome-based rewards, where the model receives positive reinforcement only when its proposed patches successfully pass an entire test suite within a containerized Docker environment. This rigorous verification loop ensures that the generated solutions are functionally correct and adhere to production-grade standards.

Kimi-Dev-72B is designed for seamless integration into modern software development lifecycles, supporting tasks such as automated bug fixing, unit test generation, and comprehensive code reviews. By employing a test-time self-play mechanism, the model iteratively refines its outputs, making it highly effective for resolving complex issues in large-scale codebases. Its dense 72-billion-parameter architecture provides a robust balance between reasoning capability and computational efficiency, while its 131,072-token context window allows it to maintain a deep understanding of extensive project structures and cross-file dependencies. The model is released under the MIT license, providing the community with open access to its weights and source code for further research and development.

Technical Specifications

Attention

Attention Structure

Multi-Head Attention

Attention Heads

64

Key-Value Heads

8

Attention Head Dimension

-

Position Embedding

Absolute Position Embedding

RoPE Theta

1,000,000

Sliding Window Attention

No

Sliding Window Size

131,072

Sliding Window Ratio

-

Linear Attention

-

Linear Attention Ratio

-

Normalization

RMS Normalization

Activation Function

SwigLU

Dimensions

Hidden Dimension Size

8,192

Number of Layers

80

FFN Intermediate Size (Dense)

29,568

Multi-Token Prediction Heads

-

Tokenizer

Vocabulary Size

152,064

Model Integrity

Total Score

B

67 / 100

Kimi-Dev-72B Model Integrity Report

Total Score

67

/ 100

B

Audit Note

Kimi-Dev-72B exhibits a strong transparency profile regarding its architectural origins and specialized software engineering framework. While it provides excellent documentation for its model weights and licensing, it remains opaque concerning the specific compute resources and environmental impact of its training. The model's commitment to open weights and reproducible evaluation scripts on SWE-bench is a significant strength, though more granular data composition details would further enhance its transparency.

Upstream

21.5 / 30

Architectural Provenance

8.0 / 10

The model's base architecture is explicitly identified as Qwen2.5-72B. Moonshot AI provides detailed documentation on the architectural modifications, specifically the 'duo-stage' framework consisting of 'BugFixer' and 'TestWriter' behaviors. The training methodology is well-described, involving a multi-stage process: mid-training on 150B tokens followed by large-scale reinforcement learning (RL) using outcome-based rewards in Docker environments. Technical reports and GitHub documentation provide a clear lineage from the base model to the specialized variant.

Dataset Composition

5.0 / 10

Moonshot AI discloses the general composition of the mid-training dataset (~150B tokens) as being sourced from 'millions of GitHub issues and PR commits.' While the total token count and general categories are provided, there is no granular breakdown of the specific proportions of different programming languages or repository types. The filtering and cleaning methodology is mentioned ('strict data decontamination' to exclude SWE-bench repositories), but the exact criteria for 'high-quality' data remain proprietary and lack public verification.

Tokenizer Integrity

8.5 / 10

The model utilizes the standard Qwen2 tokenizer, which is publicly available and well-documented. The vocabulary size (151,936 tokens) and tokenization approach (BPE) are clearly stated in the configuration files on Hugging Face. The tokenizer's alignment with the claimed 131,072-token context window is verified through official vLLM serving instructions and model configuration files.

Model

26.5 / 40

Parameter Density

9.0 / 10

The model is explicitly described as a dense 72-billion-parameter architecture. Unlike MoE models, there is no ambiguity regarding active vs. total parameters. The parameter count is consistent across all official sources (Hugging Face, GitHub, and technical reports). The model configuration files provide a transparent breakdown of the architecture, confirming it is a standard dense transformer model.

Training Compute

2.0 / 10

Information regarding training compute is extremely limited. While the use of a 'highly parallel, robust, and efficient internal agent infrastructure' is mentioned, there are no specific disclosures regarding GPU/TPU hours, hardware specifications used for training, or the total training duration. Furthermore, there is no calculation of the carbon footprint or estimated compute cost, which are key requirements for high transparency in this category.

Benchmark Reproducibility

6.5 / 10

The model's performance on SWE-bench Verified (60.4%) is prominently featured with supporting documentation. Moonshot AI provides evaluation scripts and example result files on GitHub to facilitate reproduction. However, the exact prompts and few-shot examples used for all benchmarks are not fully disclosed in a centralized manner, and third-party verification is currently limited to community-run leaderboards rather than formal audits.

Identity Consistency

9.0 / 10

Kimi-Dev-72B demonstrates high identity consistency, correctly identifying itself and its specialized purpose in software engineering. It does not exhibit confusion with its base model (Qwen) in its primary documentation and maintains a clear versioning distinction from other models in the Kimi family (e.g., Kimi K2). The model's capabilities and limitations regarding autonomous agentic behavior are transparently communicated.

Downstream

19.0 / 30

License Clarity

8.0 / 10

The model is released under the MIT License, which is a clear, permissive open-source license. The documentation explicitly states that the weights and source code are open for research and commercial use. There is a slight complexity noted regarding the upstream Qwen License Agreement, but the terms for Kimi-Dev-72B itself are clearly articulated in the LICENSE.md file on both GitHub and Hugging Face.

Hardware Footprint

7.0 / 10

Moonshot AI and community documentation provide specific VRAM requirements for various deployment scenarios (e.g., ~145GB for FP16, ~65GB for quantized versions). Recommended hardware configurations (e.g., 8x RTX 4090 or 2x A100/H100) are publicly available. While the official documentation provides good baseline requirements, detailed memory scaling charts for the full 128K context length are less comprehensive.

Versioning Drift

4.0 / 10

The model uses a clear naming convention (Kimi-Dev-72B), but there is no evidence of a formal semantic versioning system or a detailed public changelog for weight updates. While the release date is clear, the lack of a structured path for tracking future iterations or documenting silent performance drifts results in a lower score for this criterion.

About Kimi

Moonshot AI's Kimi model family, exemplified by Kimi K2, employs a Mixture-of-Experts architecture with one trillion total parameters. Designed for natural language generation and agentic capabilities, it features a 128K token context window. The models are open-weight and optimized with the Muon optimizer for stable training.


Other Kimi Models
  • No related models available