Kimi K2: Open Agentic Intelligence

KIMI K2: OPEN AGENTIC INTELLIGENCE.

TECHNICAL REPORT OF KIMI K2.

Kimi Team.

(Published as a technical report; arXiv:2507.20534; July 2025.)

(Open weights and post-trained checkpoints released to facilitate future research and applications of agentic intelligence.)

We introduce Kimi K2, a Mixture-of-Experts (MoE) large language model with 32 billion activated parameters and 1 trillion total parameters. We propose the MuonClip optimizer, which improves upon Muon with a novel QK-clip technique to address training instability while enjoying the advanced token efficiency of Muon. Based on MuonClip, K2 was pre-trained on 15.5 trillion tokens with zero loss spike. During post-training, K2 undergoes a multi-stage post-training process, highlighted by a large-scale agentic data synthesis pipeline and a joint reinforcement learning (RL) stage, where the model improves its capabilities through interactions with real and synthetic environments.

Kimi K2 achieves state-of-the-art performance among open-source non-thinking models, with strengths in agentic capabilities. Notably, K2 obtains 66.1 on Tau2-Bench, 76.5 on ACEBench (En), 65.8 on SWE-Bench Verified, and 47.3 on SWE-Bench Multilingual — surpassing most open and closed-sourced baselines in non-thinking settings. It also exhibits strong capabilities in coding, mathematics, and reasoning tasks, with a score of 53.7 on LiveCodeBench v6, 49.5 on AIME 2025, 75.1 on GPQA-Diamond, and 27.1 on OJBench, all without extended thinking. These results position Kimi K2 as one of the most capable open-source large language models to date, particularly in software engineering and agentic tasks. We release our base and post-trained model checkpoints to facilitate future research and applications of agentic intelligence.

The development of Large Language Models (LLMs) is undergoing a profound paradigm shift towards Agentic Intelligence — the capabilities for models to autonomously perceive, plan, reason, and act within complex and dynamic environments. This transition marks a departure from static imitation learning towards models that actively learn through interactions, acquire new skills beyond their training distribution, and adapt behavior through experiences. It is believed that this approach allows an AI agent to go beyond the limitation of static human-generated data, and acquire superhuman capabilities through its own exploration and exploitation. Agentic intelligence is thus rapidly emerging as a defining capability for the next generation of foundation models, with wide-ranging implications across tool use, software development, and real-world autonomy.

Achieving agentic intelligence introduces challenges in both pre-training and post-training. Pre-training must endow models with broad general-purpose priors under constraints of limited high-quality data, elevating token efficiency — learning signal per token — as a critical scaling coefficient. Post-training must transform those priors into actionable behaviors, yet agentic capabilities such as multi-step reasoning, long-term planning, and tool use are rare in natural data and costly to scale. Scalable synthesis of structured, high-quality agentic trajectories, combined with general reinforcement learning (RL) techniques that incorporate preferences and self-critique, are essential to bridge this gap.

In this work, we introduce Kimi K2, a 1.04 trillion-parameter Mixture-of-Experts (MoE) LLM with 32 billion activated parameters, purposefully designed to address the core challenges and push the boundaries of agentic capability. Our contributions span both the pre-training and post-training frontiers: (i) We present MuonClip, a novel optimizer that integrates the token-efficient Muon algorithm with a stability-enhancing mechanism called QK-Clip. Using MuonClip, we successfully pre-trained Kimi K2 on 15.5 trillion tokens without a single loss spike. (ii) We introduce a large-scale agentic data synthesis pipeline that systematically generates tool-use demonstrations via simulated and real-world environments. This system constructs diverse tools, agents, tasks, and trajectories to create high-fidelity, verifiably correct agentic interactions at scale. (iii) We design a general reinforcement learning framework that combines verifiable rewards (RLVR) with a self-critique rubric reward mechanism. The model learns not only from externally defined tasks but also from evaluating its own outputs, extending alignment from static into open-ended domains.

Kimi K2 demonstrates strong performance across a broad spectrum of agentic and frontier benchmarks. It achieves scores of 66.1 on Tau2-bench, 76.5 on ACEBench (en), 65.8 on SWE-bench Verified, and 47.3 on SWE-bench Multilingual, outperforming most open- and closed-weight baselines under non-thinking evaluation settings, closing the gap with Claude 4 Opus and Sonnet. In coding, mathematics, and broader STEM domains, Kimi K2 achieves 53.7 on LiveCodeBench v6, 27.1 on OJBench, 49.5 on AIME 2025, and 75.1 on GPQA-Diamond. On the LMSYS Arena leaderboard (July 17, 2025), Kimi K2 ranks as the top-1 open-source model and 5th overall based on over 3,000 user votes.

We train Kimi K2 using the token-efficient Muon optimizer, incorporating weight decay and consistent update RMS scaling. Experiments in our previous work Moonlight show that, under the same compute budget and model size — and therefore the same amount of training data — Muon substantially outperforms AdamW, making it an effective choice for improving token efficiency in large language model training. Despite its efficiency, scaling up Muon training reveals a challenge: training instability due to exploding attention logits, an issue that occurs more frequently with Muon but less with AdamW in our experiments. Existing mitigation strategies are insufficient: logit soft-cap directly clips the attention logits, but the dot products between queries and keys can still grow excessively before capping; Query-Key Normalization (QK-Norm) is not applicable to multi-head latent attention (MLA), because its Key matrices are not fully materialized during inference.

The Muon update for a 2D weight matrix $W \in \mathbb{R}^{n\times m}$ at step $t$ can be written as:

where $G_t$ is the gradient of $W_t$, $\mu$ is momentum, $\eta$ is learning rate, and $\lambda$ is weight decay. The Newton–Schulz step orthogonalizes the momentum matrix, and the factor $\sqrt{\max(n,m)}\cdot 0.2$ rescales the update so that its RMS matches the Adam-style update.

Taming Muon with QK-Clip. To address attention-logit explosion, we propose QK-Clip, a weight-clipping mechanism that explicitly constrains attention logits by rescaling the query and key projection weights post-update. For each head $h$ in attention layer, let $Q^h = X W_q^h, K^h = X W_k^h, V^h = X W_v^h$ and $O^h = \mathrm{softmax}\bigl(\tfrac{1}{\sqrt d} Q^h {K^h}^\top\bigr) V^h$. We define the per-head max logit on the current batch $\mathcal{B}$ as $S^h_{\max} = \tfrac{1}{\sqrt d}\max_{X\in\mathcal{B}}\max_{i,j} Q^h_i {K^h_j}^\top$. The core idea of QK-Clip is to rescale $W_q^h$ and $W_k^h$ whenever $S^h_{\max}$ exceeds a target threshold $\tau$; this operation does not alter the current step's forward/backward computation, merely uses the max logit as a signal to control weight growth.

Naively this can be applied with a global $\gamma = \min(1,\tau/S_{\max})$, but in practice only a small subset of heads exhibit exploding logits, so we apply per-head clipping to minimize intervention. For MLA we clip only the unshared components: $q^C, k^C$ each scaled by $\sqrt{\gamma^h}$; the head-specific rotary $q^R$ scaled by $\gamma^h$; the shared rotary $k^R$ left untouched to avoid cross-head effects.

We integrate Muon (with weight decay, consistent RMS matching) and QK-Clip into a single optimizer called MuonClip (Algorithm 1). In a 9B-activated / 53B-total MoE control run, vanilla Muon's max attention logits quickly exceed 1000 (Figure 2 left), causing instability. For Kimi K2 trained with MuonClip and $\tau=100$, max logits are capped at 100, gradually decay back to a typical operating range after about 30% of steps, and the training loss is smooth and spike-free across the entire 15.5T-token run (Figure 3).

Token efficiency in pre-training refers to how much performance improvement is achieved for each token consumed during training. Increasing token utility — the effective learning signal each token contributes — enhances the per-token impact on model updates, thereby directly improving token efficiency. This is particularly important when the supply of high-quality tokens is limited and must be maximally leveraged. A naive approach is repeated exposure to the same tokens, which can lead to overfitting and reduced generalization. A key advancement of Kimi K2's pre-training data over Kimi K1.5 is the introduction of a synthetic data generation strategy to increase token utility: a carefully designed rephrasing pipeline amplifies the volume of high-quality tokens without inducing significant overfitting. We describe two domain-specialized rephrasing techniques for the Knowledge and Mathematics domains.

Knowledge Data Rephrasing. Pre-training on natural, knowledge-intensive text presents a trade-off: a single epoch is insufficient for comprehensive knowledge absorption, while multi-epoch repetition yields diminishing returns and increases the risk of overfitting. To improve token utility, we propose a synthetic rephrasing framework with three components: (i) style- and perspective-diverse prompting, inspired by WRAP, that uses carefully engineered prompts to guide an LLM to faithfully rephrase original texts in varied styles and perspectives; (ii) chunk-wise autoregressive generation, where long documents are split into segments, rephrased individually, then stitched back, mitigating implicit output-length limits of LLMs; (iii) fidelity verification, comparing semantic alignment between rephrased and source passages.

We compare data rephrasing with multi-epoch repetition on SimpleQA using an early checkpoint of K2: (1) repeating raw data for 10 epochs gives 23.76% accuracy; (2) rephrasing once then training for 10 epochs gives 27.39%; (3) rephrasing 10 times with a single pass gives 28.94%. We extend this method to other large knowledge corpora; each corpus is rephrased at most twice. For mathematics, we rewrite high-quality math documents into a "learning-note" style following SwallowMath, and translate non-English high-quality math materials into English to diversify.

Pre-training Data Overall. The Kimi K2 corpus comprises 15.5 trillion tokens of curated, high-quality data spanning four primary domains: Web Text, Code, Mathematics, and Knowledge. Most data processing pipelines follow the methodologies outlined in Kimi K1.5; for each domain we performed rigorous correctness and quality validation and designed targeted data experiments to ensure both diversity and effectiveness.

Kimi K2 is a 1.04 trillion-parameter Mixture-of-Experts (MoE) transformer with 32 billion activated parameters. The architecture follows DeepSeek-V3, employing Multi-head Latent Attention (MLA) with hidden dimension 7168 and MoE expert hidden dimension 2048. Our scaling law analysis reveals that increasing sparsity yields substantial gains, motivating us to use 384 experts (up from 256 in DeepSeek-V3). To reduce inference overhead we cut attention heads to 64 (down from 128 in DeepSeek-V3). Compared with DeepSeek-V3: layers 61 (=), total params 1.04T (+54%), activated params 32.6B (−13%), experts total 384 (+50%), experts active per token 8 (=), shared experts 1 (=), attention heads 64 (−50%), dense layers 1 (−67%), no expert grouping.

Sparsity Scaling Law. We develop a sparsity scaling law for the MoE family using Muon, where sparsity is the ratio of total to activated experts. Under a fixed number of activated parameters (constant FLOPs), increasing the total experts (i.e., increasing sparsity) consistently lowers both training and validation loss. Concretely, to reach validation loss 1.5, sparsity 48 reduces FLOPs by $1.69\times, 1.39\times, 1.15\times$ over sparsities 8, 16, 32 respectively. Increasing sparsity, however, raises infrastructure complexity. To balance performance and cost we choose sparsity 48 for K2 — activating 8 of 384 experts per forward pass.

Number of Attention Heads. DeepSeek-V3 sets attention heads to roughly twice the number of layers to better utilize memory bandwidth. But as context length grows, doubled attention heads incur significant inference overhead — at 128k sequence length, going from 64 to 128 heads (with 384 total experts) increases inference FLOPs by 83%. This is a major limitation for agentic applications where efficient long-context processing is essential. Controlled experiments show doubling heads gives only 0.5%–1.2% validation-loss improvement across compute budgets. Given sparsity 48 already delivers strong performance, the marginal gain does not justify the inference cost, so we choose 64 attention heads.

Compute Cluster & Parallelism. Kimi K2 was trained on a cluster of NVIDIA H800 GPUs; each node has 2 TB RAM and 8 GPUs connected via NVLink/NVSwitch, and 8×400 Gbps RoCE between nodes. Rather than optimizing one parallelism strategy tied to a specific node count, we pursue a flexible strategy allowing K2 to be trained on any multiple of 32 nodes. We combine 16-way Pipeline Parallelism (PP) with virtual stages, 16-way Expert Parallelism (EP), and ZeRO-1 Data Parallelism. Storing BF16 parameters and FP32 gradient accumulation needs ~6 TB of GPU memory, distributed over a model-parallel group of 256 GPUs; each GPU holds ~30 GB of all states, leaving the rest for activations.

EP overlap with interleaved 1F1B; smaller EP size. By increasing warm-up micro-batches, we overlap EP all-to-all with computation under standard interleaved 1F1B. We did not adopt DualPipe because it doubles parameter/gradient memory, prohibitive at trillion scale. Interleaved 1F1B introduces PP-communication overhead; we mitigate this by decoupling weight-gradient computation from each micro-batch's backward and running it in parallel with the corresponding PP communication. To ensure full computation-communication overlap during 1F1B given K2's reduced attention compute (64 heads vs V3's 128), we use the smallest feasible EP (=16), which also relaxes expert-balance constraints.

Activation Reduction. Selective recomputation is applied to inexpensive, high-footprint stages (LayerNorm, SwiGLU, MLA up-projections, MoE down-projections). MoE up-projection and SwiGLU inputs are stored as FP8-E4M3 in $1\times 128$ tiles with FP32 scales — small-scale experiments show no measurable loss increase, though we do not apply FP8 in compute. All remaining activations are offloaded to CPU RAM via a copy engine that overlaps with compute/communication kernels: during 1F1B we offload the previous micro-batch's forward activations while prefetching the next backward, with EP communication remaining fully overlapped.

Training Recipe. We pre-trained K2 with a 4096-token context window using MuonClip and the WSD learning rate schedule, processing 15.5T tokens total. The first 10T tokens used constant LR 2e-4 after a 500-step warm-up; the remaining 5.5T tokens used cosine decay from 2e-4 to 2e-5. Weight decay was 0.1; global batch size 67M tokens. An annealing phase followed: at 67M batch size LR decayed from 2e-5 to 7e-6 across 400B tokens at 4k seq-len, then 60B tokens at 32k seq-len. Context window was extended to 128k via YaRN.

Supervised Fine-Tuning. We employ the Muon optimizer in post-training and recommend it for fine-tuning with K2: a Muon-pre-trained checkpoint yields the best performance when fine-tuned with Muon. We construct a large-scale instruction-tuning dataset across diverse domains under two principles: maximizing prompt diversity and ensuring response quality. We build a suite of data-generation pipelines per task domain, combining human annotation, prompt engineering, and verification. K1.5 and other in-house domain-specialized expert models generate candidate responses; LLM- or human-based judges perform automated quality evaluation and filtering. For agentic data, we create a dedicated data-synthesis pipeline to teach tool-use through multi-step, interactive reasoning.

Large-Scale Agentic Data Synthesis for Tool Use. A critical LLM-agent capability is autonomously using unfamiliar tools, interacting with external environments, and iteratively refining actions through reasoning, execution, and error correction. Real environments provide rich signals but are hard to scale due to cost, complexity, privacy, and accessibility. Inspired by ACEBench's data-synthesis framework, we build a pipeline that simulates real tool-use scenarios at scale, generating tens of thousands of diverse, high-quality training examples. The pipeline has three stages: (i) Tool spec generation: construct a large repository of tool specs from real-world tools and LLM-synthetic tools; (ii) Agent and task generation: for each toolset sampled from the repository, generate an agent that uses the toolset and corresponding tasks; (iii) Trajectory generation: for each agent+task, generate trajectories where the agent completes the task by invoking tools.

Domain Evolution and Tool Generation. We build the tool repository two ways. First, we directly fetch 3000+ real MCP (Model Context Protocol) tools from GitHub. Second, we systematically evolve synthetic tools through a hierarchical domain process: start from key categories (e.g., financial trading, software apps, robot control), evolve specific application domains within each, then synthesize specialized tools per domain with clear interfaces, descriptions, and semantics — over 20,000 synthetic tools in total. t-SNE shows MCP and synthetic tools cover complementary regions of the tool space.

Agent Diversification & Rubric Tasks. We synthesize thousands of agents by combining various system prompts with different tool combinations, ensuring broad capability/expertise/behavior coverage. For each agent we generate tasks ranging from simple to complex, each paired with an explicit rubric specifying success criteria, expected tool-use patterns, and evaluation checkpoints — enabling consistent, objective evaluation.

Multi-turn Trajectories & Filtering. We simulate realistic scenarios with (i) user simulation — LLM-generated personas with distinct styles engaging in multi-turn dialogue with agents; (ii) a tool execution environment (functionally a world model) that executes calls, maintains state, and injects controlled stochasticity for varied outcomes including partial failures and edge cases. An LLM-based judge evaluates each trajectory against rubrics; only trajectories meeting success criteria are kept.

Hybrid with Real Sandboxes. Simulation provides scale; for authenticity (coding/SWE), we complement with real execution sandboxes — running real code, using genuine dev environments, returning ground-truth feedback via test pass rates. The hybrid pipeline implements large-scale rejection sampling through quality filtering, and the resulting synthetic data, used in SFT, substantially improves tool-use across real-world applications.

Reinforcement learning (RL) is believed to have better token efficiency and generalization than SFT. Building on K1.5, we continue to scale RL in both task diversity and training FLOPs. We develop a Gym-like extensible framework facilitating RL across a wide range of scenarios, extending it with many verifiable-reward tasks. For tasks that rely on subjective preferences (creative writing, open-ended QA), we introduce a self-critic reward in which the model performs pairwise comparisons of its own outputs. This allows tasks from all domains to benefit from the RL paradigm.

Verifiable Rewards Gym. For math/STEM/logical reasoning, we follow two principles: diverse coverage (expert annotations + internal QA extraction + open datasets; a tagging system intentionally raises coverage of under-covered domains; logic tasks include multi-hop tabular reasoning, cross-table aggregation, the 24-game, Sudoku, cryptarithms, Morse-code decoding) and moderate difficulty (assess each problem's difficulty via the SFT model's pass@k; keep only moderate-difficulty problems). For complex instruction following, we combine code-interpreter-based deterministic evaluation (length/style constraints) with LLM-as-judge, and a hack-check layer that detects deceptive claims of fulfillment. Instructions come from expert-crafted prompts/rubrics, AutoIF-style agentic augmentation, and a fine-tuned model specialized in probing failure modes. For faithfulness, we train a sentence-level faithfulness judge model (FACTS-Grounding-style) that flags claims lacking in-context evidence, serving as a reward model. For coding/SWE, we use open-source datasets, synthetic problems with human-written unit tests, and a Kubernetes-powered sandbox supporting 10k+ concurrent instances. For safety, an attack model iteratively generates adversarial prompts, a target model responds, and a judge model decides bypass success.

Beyond Verification: Self-Critique Rubric Reward. To align beyond verifiable-reward tasks, we introduce general RL from self-critic feedback. The K2 actor generates responses for general prompts; the K2 critic ranks them via pairwise evaluation against a mix of core rubrics (fundamental values), prescriptive rubrics (anti-reward-hacking), and human-annotated rubrics. Some rubrics can be designated mandatory, while K2 retains flexibility to weigh them against internal priors — enabling dynamic, continuous alignment with evolving on-policy behavior. Critically, during RL training the critic is continuously refined using verifiable signals: on-policy rollouts from verifiable-reward prompts update the critic, distilling objective performance gains from RLVR into the evaluator, and grounding subjective judgment in verifiable data.

RL Algorithm. We adopt the K1.5 policy optimization algorithm. For each problem $x$ we sample $K$ responses $\{y_1,\dots,y_K\}$ from the previous policy $\pi_{\mathrm{old}}$ and optimize $\pi_\theta$ against the following objective:

Like SFT we use Muon to minimize it. We add three components: (i) Budget Control — per-sample max-token budget by task type; over-budget responses are truncated and penalized, encouraging concise solutions. (ii) PTX Loss — to prevent forgetting, integrate a hand-curated high-quality dataset via an auxiliary PTX loss. (iii) Temperature Decay — start with high temperature to encourage exploration, decay over training to favor exploitation; ensures stable, reliable final outputs.

Colocated Architecture. Like K1.5, we adopt a hybrid colocated architecture for synchronized RL: training and inference engines live on the same workers, and when one is active the other releases/offloads GPU resources. Each iteration: a centralized controller calls inference engine to generate new data, then trains on it, then sends updated parameters to inference for the next iteration. Each engine is heavily throughput-optimized; at K2's scale, engine-switching latency and failure recovery become significant — we describe our system design for both.

Efficient Engine Switching. During rollout, training-engine parameters are offloaded to DRAM, so bringing it up is just an H2D transfer. Bringing up the inference engine is harder: it must obtain updated parameters from the training engine with a different sharding paradigm. At K2's scale, using a network file system for resharding/broadcast is impractical (aggregate bandwidth needed reaches several PB/s). We built a distributed checkpoint engine co-located on training nodes: each worker obtains a local copy of parameters from training, broadcasts the full parameter set across all checkpoint workers, then inference retrieves only the shard it needs. For a 1T model, updates are pipelined parameter-by-parameter to minimize memory footprint. We broadcast the full parameter set rather than transfer-what-you-need, trading minor overhead for fully decoupled engines. The system completes a full K2 parameter update in <30s — negligible for typical RL iteration. The checkpoint-engine source is on GitHub.

Efficient System Startup & Agentic Rollout. To minimize disk IO at startup, each training worker selectively reads part of the parameters and broadcasts to peers — collectively reading the checkpoint exactly once. Inference replicas reuse the checkpoint engine for startup, avoiding cross-replica sync barriers and making the system robust to single-point failures. For long-horizon multi-turn agentic rollouts: (i) heavy environments are deployed as dedicated scalable services; (ii) we use many concurrent rollouts to amortize expensive interaction latency. Individual trajectories can be extremely long; to prevent long-tails blocking the rollout, we use partial rollout — pause long-tail unfinished tasks and resume in the next RL iteration. A unified Gym-inspired interface streamlines new-environment integration.

Evaluation Settings. We assess Kimi-K2-Instruct across many areas. Coding: LiveCodeBench v6 (Aug 2024 – May 2025), OJBench, MultiPL-E, SWE-bench Verified, TerminalBench, Multi-SWE-bench, SWE-Lancer, PaperBench, Aider-Polyglot. Tool use: τ2-Bench, AceBench (emphasize multi-turn tool calling). Reasoning: AIME 2024/2025, MATH-500, HMMT 2025, CNMO 2024, PolyMath-en, ZebraLogic, AutoLogi, GPQA-Diamond, SuperGPQA, Humanity's Last Exam (Text-Only). Long context: MRCR, DROP, FRAMES, LongBench v2. Factuality: FACTS Grounding, Vectara Hallucination Leaderboard, FaithJudge. General: MMLU, MMLU-Redux, MMLU-Pro, IFEval, Multi-Challenge, SimpleQA, LiveBench. Baselines (all in non-thinking mode): DeepSeek-V3-0324, Qwen3-235B-A22B (vendor-recommended no-thinking), Claude Sonnet 4, Claude Opus 4, GPT-4.1, Gemini 2.5 Flash Preview (2025-05-20). Output cap 8192 tokens (16384 for SWE-bench Verified Agentless); 128k context for long-context tasks; SWE-bench Verified is evaluated agentless (single patch w/o test) and agentic (single attempt + multi-attempt best-of-N with internal verifier); SWE-bench Multilingual: single-attempt agentic only.

Key Post-training Results. Agentic and competitive coding: Kimi-K2-Instruct is open-source SOTA on real SWE: SWE-bench Verified 65.8% (71.6% multi-attempt), SWE-bench Multilingual 47.3%, SWE-lancer 39.1% — significantly closing the gap to Claude 4 Opus/Sonnet. On competitive coding: LiveCodeBench v6 53.7%, OJBench 27.1% — leading across all models. Agentic tool use: K2 sets new SOTA at τ2-Bench 66.1 Pass@1 and ACEBench 76.5, substantially outperforming all baselines. General: strong, balanced — SimpleQA 31.0%, MMLU 89.5%, MMLU-Redux 92.7%, IFEval 89.8%, Multi-Challenge 54.1%, AIME 2024 69.6%, GPQA-Diamond 75.1%, DROP 93.5%, MRCR 55.0%. Open-ended: LMSYS Arena (July 17, 2025) — top-1 open-source, 5th overall (3000+ votes).

Pre-training Evaluations (Kimi-K2-Base). Against DeepSeek-V3-Base, Qwen2.5-72B-Base, Llama 4-Maverick. Kimi-K2-Base achieves SOTA on 10/12 English benchmarks: MMLU 87.79%, MMLU-Pro 69.17%, MMLU-Redux 90.17%, SuperGPQA 44.67%, SimpleQA 35.25%. Coding SOTA across all metrics: CRUXEval-I-cot 74.00%, CRUXEval-O-cot 83.50%, LiveCodeBench v6 26.29%, EvalPlus 80.33%. Math leads 3/4: MATH 70.22%, GSM8K 92.12%, GSM8K-Platinum 94.21%, narrowly behind on CMATH (90.26% vs V3 90.53%). Chinese SOTA across the board: C-Eval 92.50%, CMMLU 90.90%, CSimpleQA 77.57%.

Safety Evaluation. Red-team with Promptfoo across Harmful/Criminal/Misinformation/Privacy/Security plugins paired with Basic/Prompt Injection/Iterative Jailbreak/Crescendo strategies, vs DeepSeek-V3/R1 and Qwen3. Without targeted optimization, K2 holds its own on most basic and Base64 cases (≥90% passing), while complex strategies like Crescendo lower pass rates across all models (effective adversarial). Base64 transformation has minimal impact, suggesting basic robustness to encoding shifts.

Limitations. In internal tests we identified several limitations. On hard reasoning tasks or with unclear tool definitions, K2 may generate excessive tokens, occasionally leading to truncated outputs or incomplete tool calls. Performance can decline on some tasks if tool use is unnecessarily enabled. For building complete software projects, the one-shot prompting success rate is lower than using K2 within an agentic coding framework. We are working to address these in future releases and welcome feedback.

Conclusions. We introduced Kimi K2, a 1T-parameter open-weight MoE model built for agentic intelligence. Leveraging the token-efficient MuonClip optimizer and a 15.5T-token high-quality dataset, Kimi K2 achieves stable, scalable pre-training. Post-training combines large-scale synthetic tool-use data with a unified RL framework using both verifiable rewards and self-critic feedbacks. Kimi K2 sets new state-of-the-art on agentic and reasoning benchmarks, establishing itself as the most capable open-weight LLM to date.

Appendix A — Contributions: the listing of authors is in alphabetical order based on their last names.

Appendix D — MuonClip ablation experiments: comparisons of vanilla Muon vs. Muon + QK-Clip across multiple control runs, including max-logit trajectories and per-head clipping ratios over training.

Appendix F — Self-Critique core and prescriptive rubrics: the full lists of rubrics used for the Self-Critique Rubric Reward, including the values-grounded "core" rubrics and the anti-reward-hacking "prescriptive" rubrics.

Appendix G — RL parameter-update pipeline: detailed diagrams of the checkpoint engine's pipelined per-parameter broadcast, including the <30s end-to-end 1T-parameter sync timeline.

(References / Appendix content omitted from this offline view — please refer to the original PDF on arXiv:2507.20534 for the full bibliography, evaluation tables, ablation curves, and pipeline diagrams.)