Kimi k1.5: Scaling Reinforcement Learning with LLMs

arXiv:2501.12599v4 [cs.AI] 3 Jun 2025. Kimi k1.5: Scaling Reinforcement Learning with LLMs. Technical Report of Kimi k1.5. Kimi Team.

Pretraining language models with next-token prediction has been an effective way to scale compute, but it is bottlenecked by the amount of available high-quality training data. Scaling reinforcement learning (RL) unlocks a new axis for continued improvement: an LLM can extend its training data by learning to explore with rewards. Yet prior published work in this direction has not produced competitive results. Against this background, we report the training practice of Kimi k1.5—our latest multi-modal LLM trained with RL—covering RL techniques, multi-modal data recipes and infrastructure.

The two key ingredients of our approach are long context scaling and improved policy optimization. Together they form a simple, effective RL framework that does not rely on Monte Carlo tree search, value functions, or process reward models. Notably, our system achieves state-of-the-art reasoning across modalities—77.5 on AIME, 96.2 on MATH-500, 94-th percentile on Codeforces, 74.9 on MathVista—matching OpenAI o1. We further present effective long2short methods that transfer long-CoT priors to short-CoT models, yielding state-of-the-art short-CoT results—60.8 on AIME, 94.6 on MATH-500, 47.3 on LiveCodeBench—outperforming existing short-CoT models such as GPT-4o and Claude 3.5 Sonnet by up to +550%.

Next-token-prediction pretraining is governed by scaling laws: with proportional scaling of parameters and data, intelligence keeps improving. But this paradigm is fundamentally bounded by the supply of high-quality data. We report the training recipe of Kimi k1.5, our latest multi-modal LLM trained with RL—aimed at exploring a new axis of scaling: with rewards in the loop, the model is no longer chained to a static pre-existing dataset and can learn to explore.

Four design pillars of k1.5:

• Long context scaling. We scale the RL context window to 128k and observe continued performance gains as context grows. The key idea is partial rollouts: sample new trajectories by reusing a large chunk of previous trajectories, avoiding the cost of regenerating from scratch. Context length emerges as a key dimension for the continued scaling of RL with LLMs.
• Improved policy optimization. We formulate RL with long CoT and use a variant of online mirror descent for robust policy optimization, further sharpened by an effective sampling strategy, length penalty, and data-recipe optimization.
• Simplistic framework. Long-context scaling + improved policy optimization gives a minimal RL framework. Because we can scale context, the learned CoT spontaneously exhibits planning / reflection / correction—longer context behaves like more search steps. Hence we achieve strong performance without MCTS, value functions, or process reward models.
• Multimodality. Joint training on text + vision yields cross-modal reasoning.

We also present long2short methods that distil long-CoT priors into short-CoT models via length-penalty activation and model merging. The long-CoT version matches o1 (AIME 77.5, MATH-500 96.2, Codeforces 94 pct, MathVista 74.9); the short-CoT version is SOTA among short-CoT models (AIME 60.8, MATH-500 94.6, LiveCodeBench 47.3), beating GPT-4o / Claude 3.5 Sonnet by up to +550%.

Development pipeline of k1.5 = pretraining → vanilla SFT → long-CoT SFT → RL. This report focuses on RL. §2.1 covers RL prompt-set curation; §2.2 long-CoT SFT; §2.3 RL training strategies; §2.5 pretraining and vanilla SFT.

RL prompt-set curation. A high-quality RL prompt set has three desiderata: diverse coverage across STEM / coding / general reasoning; balanced difficulty spanning easy / moderate / hard; accurate evaluability by verifiers (objective and reliable). We use automatic filters to keep questions that demand rich reasoning and are easy to evaluate, plus a tagging system to balance disciplines.

For difficulty estimation, we use a model-based approach: for every prompt, the SFT model generates 10 answers at a relatively high temperature; pass rate becomes the difficulty proxy (lower pass rate = harder). This aligns difficulty with the model's own capability and lets us pre-filter trivial cases plus drive sampling strategies during RL.

To avoid reward hacking, the reasoning process and the final answer must both be accurately verifiable. We drop multiple-choice / true-false / proof problems (which can be "guessed" with a wrong reasoning chain). For general QA we add an easy-to-hack filter: prompt a model to guess answers without CoT; if it gets it right within $N=8$ attempts, the prompt is deemed too hackable and removed.

Long-CoT SFT. Over the curated RL prompt set, we use prompt engineering to build a small but high-quality long-CoT warm-up dataset with verified reasoning paths for both text and image inputs (resembling rejection sampling, but the focus is on prompt-engineered long CoT). The warm-up data deliberately encodes four cognitive primitives—planning (lay out steps before execution), evaluation (critique intermediate steps), reflection (reconsider and refine), exploration (consider alternatives). A lightweight SFT on this data primes the model with these reasoning strategies and produces more detailed, logically coherent responses.

Problem setting. Given training data $\mathcal{D}=\{(x_i, y_i^*)\}_{i=1}^n$, the goal is to train policy $\pi_\theta$ to solve test problems. CoT inserts intermediate thoughts $z=(z_1,\dots,z_m)$ between $x$ and final answer $y$: thoughts are sampled auto-regressively $z_t\sim\pi_\theta(\cdot|x,z_{1:t-1})$, then $y\sim\pi_\theta(\cdot|x,z)$. We write $y,z\sim\pi_\theta$ for the joint sampling.

Planning algorithms over thoughts (Tree-of-Thoughts etc.) explicitly build a search tree of partial solutions $s=(x,z_{1:|s|})$ with a critic $v$. Algorithmically a planner is a mapping $A(\cdot|z_1,z_2,\dots)$ acting on a sequence of reasoning steps; thoughts and feedbacks alike are just language tokens. This invites a clean perspective: instead of building a search tree + planner, train a model to approximate this process. Number of thoughts = compute budget; long context enables both training-time and test-time scalability. The model thus runs an implicit search via auto-regressive prediction.

We train CoT generation with RL. The reward $r(x,y,y^*)\in\{0,1\}$ checks correctness against ground truth $y^*$: rule-based for verifiable tasks (e.g. code test cases), learned for free-form answers. The objective:

The model still autoregressively samples at inference (no parallel planning needed), but learns critical planning skills—error identification, backtracking, solution refinement—by leveraging the entire explored thought set as context.

Policy optimization. We apply a variant of online policy mirror descent. At the $i$-th iteration, with $\pi_{\theta_i}$ as reference, solve the relative-entropy-regularized policy optimization:

where $\tau>0$ controls the regularization strength. The closed-form solution is

with $Z=\sum_{y',z'}\pi_{\theta_i}(y',z'|x)\exp(r(x,y',y^*)/\tau)$. Taking logs, for any $(y,z)$ the following holds—this is what enables off-policy data:

This motivates the squared surrogate loss

We approximate $\tau\log Z$ by samples $(y_1,z_1),\dots,(y_k,z_k)\sim\pi_{\theta_i}$: $\tau\log Z \approx \tau\log\frac{1}{k}\sum_{j=1}^k\exp(r(x,y_j,y^*)/\tau)$. In practice the empirical mean $\bar r=\mathrm{mean}(r(x,y_1,y^*),\dots,r(x,y_k,y^*))$ works just as well (it equals the expected reward under $\pi_{\theta_i}$ as $\tau\to\infty$). The final gradient, with $k$ responses sampled from $\pi_{\theta_i}$:

To readers familiar with policy gradient: this looks like the policy gradient of (2) with the mean of sampled rewards as the baseline, except (i) responses come from $\pi_{\theta_i}$ rather than on-policy, and (ii) an $\ell_2$ regularization is added. So this is the natural off-policy extension of regularized policy gradient. After each iteration we update $\theta\to\theta_{i+1}$, which becomes the next reference; we also reset the optimizer at each iteration since the regularization target changes.

No value network. We deliberately exclude a value network. Beyond efficiency, we argue classical credit assignment hurts long-CoT learning: imagine a partial CoT $(z_1,\dots,z_t)$ with two candidates $z_{t+1}$ (leads to correct answer) and $z_{t+1}'$ (contains errors). An oracle value would penalize $z_{t+1}'$ as low-advantage, but exploring $z_{t+1}'$ is valuable—as long as the model recovers and reaches the right answer, it learns the trial-and-error pattern. The final-answer-based reward is enough; we want to encourage diverse reasoning paths, not punish "mistakes" mid-stream.

We observe an overthinking phenomenon: response length blows up during RL training. Although longer often = better accuracy, excessive chains are expensive at train/inference time and humans don't enjoy reading them. We introduce a length reward to curb this growth.

For each problem $x$ with true answer $y^*$, draw $k$ responses $(y_1,z_1),\dots,(y_k,z_k)$. Let $\mathrm{len}(i) = $ length of $(y_i,z_i)$, $\mathrm{min\_len}=\min_i \mathrm{len}(i)$, $\mathrm{max\_len}=\max_i \mathrm{len}(i)$. If $\mathrm{max\_len}=\mathrm{min\_len}$, set the length reward to 0 for all (they're identical in length). Otherwise:

In essence: among correct responses, reward the short ones, punish the long ones; among incorrect responses, only the long ones get punished. This length reward is added to the original reward with a weighting parameter.

Warm-up. In pilots, applying length penalty too early slows training. So we ramp it gradually: do standard policy optimization first without length penalty, then switch on a constant length penalty for the rest of training.

Curriculum Sampling. RL self-naturally puts more gradient on hard problems, but training efficiency is still bottlenecked. We start on easier tasks and gradually move to harder ones: early RL models can hardly solve hard problems, so spending compute on them yields few correct samples. Our data already comes with grade / difficulty labels, making this trivial to set up.

Prioritized Sampling. On top of curriculum, we track per-problem success rate $s_i$ during training and sample problem $i$ with probability $\propto (1-s_i)$. The model gets more practice where it's weakest, accelerating learning.

Test-case generation for coding. Many web coding problems have no public test cases. We auto-generate them using CYaRon: feed CYaRon's usage spec + problem statement into our base Kimi k1.5 to produce 50 test cases per problem; sample 10 ground-truth submissions; a test case is valid if $\geq 7/10$ submissions agree on its output; a problem enters the training set if $\geq 9/10$ submissions pass all selected test cases. Out of 1,000 contest problems, ~614 need no special judge, we built 463 generators producing $\geq 40$ valid cases each, finally including 323 problems.

Reward modelling for math. Math answers have many equivalent forms (e.g. $a^2-4 = (a+2)(a-2)$). Two RMs:

• Classic RM: InstructGPT-style value-head RM, ~800k training pairs; input = (question, reference answer, response), output = scalar.
• Chain-of-Thought RM: ~800k CoT-labelled examples; the RM generates a step-by-step rationale and a final JSON correctness verdict.

Spot-check accuracy: Classic RM ≈ 84.4%, CoT RM ≈ 98.5%. We use the CoT RM in RL training—much cleaner feedback.

Vision data. Vision-RL data has three sources: ① real-world (graded science questions, location-guessing, chart analysis); ② synthetic (procedurally generated images, e.g. spatial / geometric / object-interaction); ③ text-rendered (text documents / code / structured data rendered as images, so the model is consistent across pure-text and image-rendered inputs).

Long-CoT models burn more test-time tokens than vanilla short-CoT LLMs. But the thinking priors learned in a long-CoT model are transferable: a short-CoT model can be improved even under a limited token budget. We present four approaches:

• Model Merging. Average the weights of a long-CoT model and a short-CoT model—no training. Empirically this preserves generalization and improves token efficiency.
• Shortest Rejection Sampling. For each prompt, sample $n=8$ responses and keep the shortest correct one for SFT. Leverages the large length variance of our model.
• DPO. Same setup as above—shortest correct = positive; longer responses = negative (both wrong-and-longer, and correct-but-$1.5\times$-longer-than-the-chosen-positive). These pairs form the preference data for DPO training.
• Long2Short RL. After standard RL, pick the model with best performance / token-efficiency trade-off as base, then run a separate long2short RL phase—apply the §2.3.3 length penalty and cut max rollout length significantly to additionally punish over-long but possibly correct responses.

Pretraining. The Kimi k1.5 base model is trained on a diverse, high-quality multimodal corpus. Language data covers five domains—English / Chinese / Code / Mathematics Reasoning / Knowledge. Multimodal data spans captioning, image-text interleaving, OCR, knowledge, QA. Three-stage pretraining: ① vision-language pretraining—establish a strong language foundation, then gradually integrate multimodal data; ② cooldown—consolidate via curated + synthetic data (especially reasoning / knowledge); ③ long-context activation—extend sequence processing to 131,072 tokens. Details in Appendix B.

Vanilla SFT. For non-reasoning tasks (QA, writing, text processing) we build a seed dataset via human annotation, train a seed model, sample multiple responses per prompt, then have annotators rank and refine the top one. For reasoning (math, coding), where rule-based or RM-based verification beats human judgment, we use rejection sampling to scale up SFT data.

Vanilla SFT corpus ≈ 1M text (500k general QA, 200k coding, 200k math/science, 5k creative writing, 20k long-context summarization/doc-QA/translation/writing) + 1M text-vision (chart, OCR, image-grounded dialogue, visual coding, visual reasoning, vision-aided math/science). Training: 1 epoch at seq-len 32k (LR $2\!\times\!10^{-5}\to 2\!\times\!10^{-6}$), then 1 epoch at seq-len 128k (re-warm-up to $1\!\times\!10^{-5}$, decay to $1\!\times\!10^{-6}$). Examples are packed into single training sequences for efficiency.

Iterative synchronous RL system. Inspired by AlphaGo / AlphaStar / OpenAI Dota Five, k1.5's RL training is an iterative synchronous loop: each iteration = rollout phase + training phase. A central master coordinates rollout workers (generate trajectories), trainer workers (gradient updates), reward models (Code, Math, K-12, Vision domains) and the replay buffer. A dedicated code-execution service validates code outputs in real environments. Figure 3a shows the topology.

Partial Rollouts—the core trick for long-CoT RL. We set a fixed output-token budget per rollout. If a trajectory exceeds the cap, the unfinished portion is saved to the replay buffer and continued in the next iteration. Three benefits:

• No single mega-trajectory monopolizes the system's compute.
• Rollout workers operate asynchronously—while some chew on long trajectories, others process new, short tasks; everyone stays busy.
• Only the current segment (iter $n$) needs on-policy compute; previous segments (iter $n{-}m$ to $n{-}1$) are reused straight from the buffer. During training, some segments can even be excluded from the loss to further reduce off-policy bias.

Partial rollouts also include repeat detection: identify and early-terminate repeated sequences; detected repetitions get extra penalties to discourage redundant generation in the prompt set.

Hybrid deployment of training & inference. The training process has three phases:

• Training phase: Megatron and vLLM run in separate containers wrapped by a shim checkpoint-engine. Megatron trains; when done, it offloads GPU memory and prepares to ship weights to vLLM.
• Inference phase: vLLM starts with dummy weights, then pulls the latest weights from Megatron via Mooncake. After rollout, checkpoint-engine halts vLLM.
• Next training phase: vLLM's memory released; Megatron onloads and trains again.

We use Kubernetes Sidecar containers to share all available GPUs and co-locate training + inference in one pod. Benefits: no train-side idling while waiting for inference nodes; train/infer images iterate independently; framework-agnostic (not tied to vLLM). End-to-end transition: <1 min train→infer, ~10 s infer→train.

Checkpoint Engine. Manages vLLM's lifecycle via HTTP APIs; consistency is broadcast through an etcd-managed global metadata system. Fully releasing GPU memory via vLLM offload is hard (CUDA graphs, NCCL buffers, NVIDIA drivers), so we just kill and restart vLLM when needed. Megatron converts owned checkpoints to HuggingFace format in shared memory (collapsing PP/EP into TP-only), then shards and registers them in the global metadata; Mooncake transfers checkpoints between peer nodes over RDMA.

Code Sandbox. Secure environment for executing user-submitted code; supports MultiPL-E, DMOJ Judge Server, Lean, Jupyter Notebook etc. by dynamic image switching. Optimizations: ① crun as container runtime (faster startup vs Docker); ② cgroup reuse—pre-create cgroups to avoid per-container creation cost under high concurrency; ③ tmpfs-backed overlay filesystem for ephemeral workloads. Benchmarks: container startup 0.04s (sandbox) vs 0.12s (Docker); max containers/sec on a 16-core machine 120 (sandbox) vs 27 (Docker).

Evaluation setup. k1.5 is multimodal, so benchmarks span three families: Text—MMLU, IF-Eval, CLUEWSC, C-EVAL; Reasoning—HumanEval-Mul, LiveCodeBench, Codeforces, AIME 2024, MATH-500; Vision—MMMU, MATH-Vision, MathVista. Detailed setup in Appendix C.

Long-CoT main results (Table 2). Through long-CoT SFT (§2.2) + vision-text joint RL (§2.3), the model's long-horizon reasoning improves dramatically. At test time, scaling compute via longer CoT further lifts performance to SOTA across modalities. Headline numbers: MATH-500 96.2, AIME 77.5, Codeforces 94 pct, MathVista 74.9—all matching or surpassing OpenAI o1.

Short-CoT main results (Table 3). Combining vanilla SFT (§2.5.2) + RL (§2.3) + long2short distillation (§2.4) gives a short-CoT model that is competitive with or superior to the leading open / closed-source models. Headline numbers: MMLU 87.4, IF-Eval 87.2, CLUEWSC 91.7, C-Eval 88.3, MATH-500 94.6, AIME 60.8, LiveCodeBench 47.3, MathVista 70.1.

§3.3 Long-context scaling (Figure 5, 6). A mid-sized model is used to study RL scaling. As training iterations grow on math prompts, both response length and accuracy rise concurrently; harder benchmarks (AIME, OMNI-MATH500) show steeper length growth—the model "learns to think longer on harder problems." Figure 6 plots accuracy vs mean token length: strong positive trend (slopes $\sim 1.4\!\times\!10^{-5}$ to $4.2\!\times\!10^{-5}$). Our final k1.5 run scales to 128k context and still gains on hard benchmarks.

§3.4 Long2short (Figure 7). Compared methods: k1.5-long, k1.5-short w/ RL (long2short RL), k1.5-short w/ DPO, k1.5-short w/ merge, k1.5-short w/ merge + RS, k1.5-shortest. On AIME 2024 and MATH-500 (token-length vs accuracy Pareto), all k1.5 variants (orange) dominate other models (blue). k1.5-short w/ RL: AIME Pass@1 = 60.8 with only ~3,272 tokens on average. k1.5-shortest: MATH-500 Pass@1 = 88.2 at a token budget similar to other short models. Conclusion: long2short RL has the highest token efficiency among DPO / model-merge / shortest-RS / RL.

§3.5 Ablations. ① Model size vs context length (Figure 8): a larger model starts ahead, but a smaller one catches up by training longer CoT; larger models still have better token efficiency overall. If you target peak performance, scale a larger model's context; if you're test-time-compute-constrained, train a smaller model with longer context. ② Negative gradients matter (Figure 10): ReST (which only refines on best-of-N positive samples, no negative gradients) has worse sample complexity than our method, especially when generating long CoT—negative gradients are crucial for this regime. ③ Curriculum sampling (Figure 9): warm up on the full uniform mix, then switch to hard-only at iter 24—significantly beats the uniform-sampling baseline; the model develops more robust reasoning by being progressively challenged.

We presented the training recipe and system design of k1.5, our latest multi-modal LLM trained with RL. The central lesson from our practice: scaling context length is critical for continued improvement of LLMs. We achieved efficient long-context RL training via optimized learning algorithms plus infrastructure tricks like partial rollouts. Improving the efficiency and scalability of long-context RL further remains an open question.

Our second contribution is a combination of techniques for improved policy optimization: a long-CoT RL formulation, a variant of online mirror descent for robust optimization, sampling strategies, length penalty, and data-recipe optimization. We show that long context scaling + better policy optimization alone—no MCTS, no value functions, no process reward models—is enough for strong performance. Open directions: better credit assignment and less overthinking, without crippling exploration.

We also see promise in long2short methods, which substantially boost short-CoT model performance. Iteratively combining long2short with long-CoT RL is a way to squeeze even more token efficiency out of a given context budget.

References omitted from this bilingual reading-notes view. Full reference list is in the original PDF (e.g., Kaplan et al. 2020 on scaling laws; Hoffmann et al. 2022 Chinchilla; Ouyang et al. 2022 InstructGPT; Rafailov et al. 2024 DPO; Yang et al. 2024 model merging; Shoeybi et al. 2020 Megatron; Kwon et al. 2023 vLLM; Qin et al. 2024 Mooncake; Gulcehre et al. 2023 ReST; Jaech et al. 2024 OpenAI o1 system card; etc.).

A Contributions. Research & Development: Angang Du, Bofei Gao, Bowei Xing, Changjiu Jiang, Cheng Chen, Cheng Li, Chenjun Xiao, Chenzhuang Du, Chonghua Liao*, Congcong Wang, Dehao Zhang, Enming Yuan, Enzhe Lu, Flood Sung, Guokun Lai, Haiqing Guo, Han Zhu, Hao Ding, Hao Hu, Hao Yang, Hao Zhang, Haotian Yao, Haotian Zhao, Haoyu Lu, Hongcheng Gao, Huan Yuan, Huabin Zheng, Jingyuan Liu, Jianlin Su, Jianzhou Wang, Jin Zhang, Junjie Yan, Lidong Shi, Longhui Yu, Mengnan Dong, Neo Zhang, Ningchen Ma*, Qiwei Pan, Qucheng Gong, Shaowei Liu, Shupeng Wei, Sihan Cao, Tao Jiang, Weimin Xiong, Weiran He, Weihao Gao*, Weixiao Huang, Weixin Xu, Wenhao Wu, Wenyang He, Xianqing Jia, Xingzhe Wu, Xinran Xu, Xinyu Zhou, Xinxing Zu, Xuehai Pan, Yang Li, Yangyang Hu, Yangyang Liu, Yanru Chen, Yejie Wang, Yidao Qin, Yibo Liu, Yiping Bao, Yifeng Liu*, Yulun Du, Yuzhi Wang, Yuxin Wu, Y. Charles, Zaida Zhou, Zhaoji Wang, Zhaowei Li, Zheng Zhang, Zhexu Wang, Zhiqi Huang, Zhilin Yang, Zihao Huang, Ziyao Xu, Zonghan Yang, Zongyu Lin. Data Annotation: Chuning Tang, Fengxiang Tang, Guangda Wei, Haoze Li, Haozhen Yu, Jia Chen, Jianhang Guo, Jie Zhao, Junyan Wu, Ling Ye, Shengling Ma, Siying Huang, Xianghui Wei, Yangyang Liu, Ying Yang, Zhen Zhu. The listing of authors is in alphabetical order based on their first names. Names marked with an asterisk (*) indicate people who are no longer part of our team.

B Pretraining. Reinforcement learning (RL) efficiency is closely tied to the performance of the underlying base model. Frontier models such as Gemini (Team et al. 2024) and Llama (Grattafiori et al. 2024) highlight the importance of pretraining data quality in achieving high performance. However, many recent open-source models lack full transparency regarding their data processing pipelines and recipes, creating challenges for broader community understanding. While we are not open-sourcing our proprietary model at this time, we are committed to providing a comprehensive disclosure of our data pipeline and methodologies. In this section, we focus primarily on the multimodal pretraining data recipe, followed by a brief discussion of the model architecture and training stages.

B.1 Language Data. Our pretrain corpus is designed to provide comprehensive and high-quality data for training large language models (LLMs). It encompasses five domains: English, Chinese, Code, Mathematics & Reasoning, and Knowledge. We employ sophisticated filtering and quality control mechanisms for each domain to ensure the highest quality training data. For all pretrain data, we conducted rigorous individual validation for each data source to assess its specific contribution to the overall training recipe. This systematic evaluation ensures the quality and effectiveness of our diverse data composition.

English and Chinese textual data: we developed a multi-dimensional quality filtering framework that combines multiple scoring methods to reduce individual biases and ensure comprehensive quality assessment. Our framework incorporates: (1) Rule-based filtering: domain-specific heuristics to remove duplicates, machine-translated text, and low-quality web scrapes; we also filter documents with excessive special characters, unusual formatting, or spam patterns. (2) FastText-based classification: we trained specialized FastText (Joulin et al. 2016; J. Li et al. 2024) models to identify content quality based on linguistic features and semantic coherence. (3) Embedding-based similarity analysis: using document embeddings (Jianlv Chen et al. 2024) we compute document-level similarity to remove near-duplicates while preserving semantically valuable variations. (4) LLM-based quality assessment: following (Penedo et al. 2024), we leverage LLMs to score documents on coherence, informativeness, and educational value. The final quality score is a combination of these individual scores; based on extensive empirical analysis we apply dynamic sampling rates—high-quality documents upsampled, low-quality downsampled.

Code data: two categories. For pure code from code files we follow BigCode (R. Li et al. 2023; Lozhkov et al. 2024)—eliminate miscellaneous languages, rule-based cleaning, then rebalance via sampling: markup languages (JSON, YAML, YACC) downsampled; 32 major programming languages (Python, C, C++, Java, Go, …) upsampled. For text-code interleaved data from various sources, we use an embedding-based recall method to keep diversity and high quality.

Math & Reasoning data: mainly retrieved from web text and PDFs collected from public internet (Paster et al. 2023). Our general-domain text extraction and OCR had high false-negative rates on math content, so we built dedicated cleaning & OCR models to maximise math recall, then a two-stage cleaning pipeline: (1) FastText for initial cleaning to drop most irrelevant data; (2) a fine-tuned LM to further clean the remainder, yielding high-quality math data.

Knowledge data: meticulously curated to cover academic disciplines—academic exercises, textbooks, research papers, and general educational literature. A large portion is digitised through OCR processing, for which we have developed proprietary OCR models optimised for academic content (math formulas, special symbols). We annotate documents with multi-dimensional labels: (1) OCR quality metrics, (2) educational-value indicators, (3) document-type classification (exercises / theoretical materials / …). Documents are filtered by OCR quality thresholds (our framework specifically detects repetitive-text artefacts that indicate OCR failure); high educational-value documents are prioritised. Sampling strategy across document types is empirically determined; high-value subsets are upsampled, but other types are preserved at appropriate ratios to maintain diversity and generalisation.

B.2 Multimodal Data. Our multi-modal pretraining corpus is designed to provide high-quality data that enables models to process and understand information from multiple modalities, including text, images, and videos. We curate high-quality data from five categories—captioning, interleaving, OCR, knowledge, and general question answering—to form the corpus. We developed several multi-modal data processing pipelines covering filtering, synthesis, and deduplication. Establishing an effective multi-modal data strategy is crucial during joint vision-language training, as it both preserves the LM's capabilities and facilitates alignment of knowledge across modalities.

Caption data: provides fundamental modality alignment and broad world knowledge. We integrate open-source Chinese/English caption datasets (Schuhmann et al. 2022; S. Y. Gadre et al. 2024) plus substantial in-house caption data. Throughout training we strictly limit synthetic caption proportion to mitigate hallucination risk from insufficient real-world knowledge. We follow a rigorous QC pipeline that avoids duplication and maintains high image-text correlation; image resolution is varied during pretraining so the vision tower remains effective on both high- and low-resolution images.

Image-text interleaving data: benefits multi-image comprehension, provides detailed knowledge for given images, enables longer multi-modal context learning, and helps maintain the LM's language abilities. We use open interleave datasets (Zhu et al. 2024; Laurençon et al. 2024) and constructed large-scale in-house data from textbooks, webpages, and tutorials. We further find synthesising interleaving data benefits multi-modal LLM performance while keeping text knowledge. Beyond standard filtering/dedup/QC, we apply a data reordering procedure to keep all images and text in the correct order.

OCR data: diverse open-source + in-house datasets, both clean and augmented images. We built substantial in-house OCR datasets covering multilingual text, dense layouts, web-based content, handwritten samples. Following OCR 2.0 (H. Wei et al. 2024), we also handle figures, tables, geometry diagrams, mermaid plots, and natural scene text. Extensive data augmentation (rotation, distortion, colour adjustments, noise) is applied for robustness; the model achieves high OCR proficiency as a result.

Knowledge data: analogous to text pretraining—assemble multi-modal knowledge from diverse sources. Carefully curated geometry data is vital for visual reasoning (interpreting abstract human-drawn diagrams). We adhere to a standardised taxonomy to balance categories and ensure source diversity. Multi-modal knowledge processing combines a layout parser and an OCR model; we also include filtered internet/external data. Because much of the corpus is internet-sourced, infographics can cause the model to focus only on OCR; we developed an additional pipeline to better capture pure textual information embedded in images.

General QA data: we found that a substantial volume of high-quality QA datasets in pretraining offers significant benefits. We included rigorous academic datasets on grounding, table/chart QA, web agents, and general QA, plus a large in-house QA corpus. To balance difficulty and diversity we applied scoring models and meticulous manual categorisation.

B.3 Model Architecture. Kimi k-series models employ a variant of the Transformer decoder (Vaswani et al. 2017) that integrates multimodal capabilities alongside improvements in architecture and optimisation strategies, illustrated in Figure 11. These advancements collectively support stable large-scale training and efficient inference, tailored specifically to large-scale reinforcement learning and the operational requirements of Kimi users. Extensive scaling experiments indicate that most of the base model performance comes from improvements in the quality and diversity of the pretraining data. Specific details regarding model architecture scaling experiments lie beyond the scope of this report and will be addressed in future publications.

Figure 11: Kimi k1.5 supports interleaved images and text as input, leveraging large-scale reinforcement learning to enhance the model's reasoning capabilities.

B.4 Training Stages. The Kimi k1.5 model is trained in three stages: the vision-language pretraining stage, the vision-language cooldown stage, and the long-context activation stage. Each stage focuses on a particular capability enhancement.

Vision-language pretraining stage: the model is first trained solely on language data to establish a robust LM foundation, then gradually introduced to interleaved vision-language data to acquire multimodal capabilities. The visual tower is initially trained in isolation without updating LM parameters; then we unfreeze the LM layers and ultimately raise vision-text data proportion to 30%. Final mixtures and weights were determined through ablations on smaller models.

Vision-language cooldown stage: the model is continued-trained with high-quality language and vision-language datasets. Empirically, incorporating synthetic data during cooldown yields significant gains, particularly in math reasoning, knowledge-based tasks, and code. English/Chinese cooldown sets are curated from high-fidelity subsets of the pretraining corpus. For math / knowledge / code, we adopt a hybrid: selected pretraining subsets augmented with synthetic content—generating QA pairs from existing math/knowledge/code corpora via a proprietary LM, with rejection sampling for quality (Yue, Qu, et al. 2023; D. Su et al. 2024). These synthesised QA pairs undergo comprehensive validation before being added.

Long-context activation stage: k1.5 is trained with upsampled long-context cooldown data to handle extended sequences. We use 40% full-attention data + 60% partial-attention data; full-attention data is part high-quality natural + part synthetic long-context Q&A and summary; partial-attention data is uniform-sampled cooldown data. RoPE frequency (J. Su et al. 2024) is set to 1,000,000. We gradually extend max sequence length from 4,096 → 32,768 → 131,072.

C Evaluation Details — C.1 Text Benchmark.

MMLU (Hendrycks et al. 2020) covers 57 subjects in STEM, humanities, social sciences, and more, ranging from elementary to advanced professional difficulty; tests both world knowledge and problem-solving ability.

IF-Eval (J. Zhou et al. 2023) evaluates LLMs' ability to follow verifiable instructions—500+ prompts like "write an article with more than 800 words". Note: due to a version shift, the IF-Eval number in Table 3 came from an intermediate model; we will update with final-model scores.

CLUEWSC (L. Xu et al. 2020) is a coreference resolution task in the CLUE benchmark—determine whether a pronoun and a noun phrase in a sentence co-refer, data drawn from Chinese fiction books.

C-EVAL (Y. Huang et al. 2023) is a comprehensive Chinese evaluation suite for assessing advanced knowledge and reasoning abilities of foundation models—13,948 multiple-choice questions across 52 disciplines and four difficulty levels.

C.2 Reasoning Benchmark.

HumanEval-Mul is a subset of Multipl-E (Cassano et al. 2022). MultiPL-E extends HumanEval and MBPP to 18 languages; we choose HumanEval translations in 8 mainstream languages (Python, Java, C++, C#, JavaScript, TypeScript, PHP, Bash).

LiveCodeBench (Jain et al. 2024) is a comprehensive contamination-free coding benchmark with live updates. We test short-CoT models on 2408-2411 (release v4) and long-CoT models on 2412-2502 (release v5).

AIME 2024: the 2024 American Invitational Mathematics Examination competition—a prestigious, invitation-only contest for top US high-school students; tests advanced math skill and rigorous logical thinking.

MATH-500 (Lightman et al. 2023) is a comprehensive math benchmark with 500 problems across algebra, calculus, probability, etc.—tests computation + reasoning. Higher score = stronger math problem-solving.

Codeforces is a well-known online judge platform; a popular testbed for long-CoT coding models. To achieve higher ranks in Div2/Div3 contests, we apply majority voting on code snippets generated by k1.5 long-CoT, using test cases also generated by the same model. The Codeforces ELO percentile was extracted from OpenAI Day 12 talk.

C.3 Image Benchmark.

MMMU (Yue, Ni, et al. 2024) encompasses 11.5K multimodal questions from college exams/quizzes/textbooks, spanning Art & Design, Business, Science, Health & Medicine, Humanities & Social Science, Tech & Engineering.

MATH-Vision (MATH-V) (K. Wang et al. 2024) is a curated collection of 3,040 high-quality math problems with visual contexts sourced from real math competitions—16 disciplines, 5 difficulty levels.

MathVista (Lu et al. 2023) integrates challenges from a variety of math and visual tasks, requiring fine-grained, deep visual understanding plus compositional reasoning.