KAT-Coder-V2 Technical Report

1. Problem Statement

The paper addresses the transition of Large Language Models (LLMs) from single-turn code generation to Agentic Coding, where models must autonomously plan, execute, and verify multi-step software engineering tasks in real-world environments. The authors identify three fundamental challenges hindering this progress:

1. Capability Fragmentation: Different coding domains (e.g., Software Engineering repair, Web UI aesthetics, Terminal CLI reasoning, Web Search) require conflicting training signals. A monolithic training pipeline struggles to optimize for all simultaneously without compromising performance in specific areas.
2. Infrastructure Coupling: Existing systems tightly couple datasets, sandbox environments, agent scaffolds (e.g., Claude Code, OpenClaw), and verifiers. This makes integrating new benchmarks or agent frameworks costly and slow, preventing rapid iteration.
3. Scaling Agentic RL: Training coding agents requires scaling across task complexity, prompt diversity, and scaffold generalization. However, this is hindered by instability in Mixture-of-Experts (MoE) models during Reinforcement Learning (RL) and computational redundancy caused by tree-structured trajectories in multi-turn agent interactions.

2. Methodology

KAT-Coder-V2 adopts a "Specialize-then-Unify" paradigm to address these challenges, supported by a novel infrastructure and algorithmic innovations.

A. Infrastructure: KwaiEnv

To solve infrastructure coupling, the team developed KwaiEnv, a modular system that decouples datasets, sandboxes, scaffolds, and verifiers.

• Architecture: It supports tens of thousands of concurrent sandbox instances.
• Modules:
  • Dataset: Unified interface for diverse benchmarks (SWE-bench, LiveCodeBench, etc.).
  • Verifier: Supports deterministic scoring, LLM-as-Judge, and SWE-specific test suite execution.
  • Scaffold: "Black-box" integration of various agent frameworks via network-level proxying.
  • Sandbox: Isolated container environments for reproducible execution.
  • Trajectory Manager: Handles data collection and formatting for RL engines.

B. Training Pipeline: Specialize-then-Unify

The model is built upon KAT-Coder-V1 through a three-stage process:

1. Supervised Fine-Tuning (SFT) - Specialization:
   The capability spectrum is decomposed into five orthogonal expert domains, each trained independently:

   • SWE Expert: Focuses on issue resolution using Issue-PR pairing (2M+ samples), AutoBuilder (30k verified synthetic tasks), and Code Comprehension trajectories.
   • WebCoding Expert: Focuses on aesthetic UI generation. Introduces a Tri-Perspective Label System (User Perception $\to$ Design Rationale $\to$ Technical Implementation) and a Prompt Rewriting strategy to handle sparse user inputs.
   • Terminal Expert: Focuses on CLI reasoning using expert-annotated data, multi-agent synthesis, and cross-format adaptation.
   • WebSearch Expert: Trains on agentic search using Knowledge Graph construction from search trajectories and rejection sampling (Pass@8 filtering).
   • General Expert: Maintains core instruction following, QA, and code-math reasoning capabilities.

2. Reinforcement Learning (RL) - Scaling:

   • Agentic Scaling: Uses an "Agentic Scaling" paradigm to generate 100k+ high-difficulty samples by varying Task Complexity, Intent Alignment (rewriting prompts from expert to colloquial), and Scaffold Generalization (training across multiple agent frameworks).
   • Algorithmic Innovations:
     • Modified Turn-level Policy Optimization: Adapts Group Sequence-level Policy Optimization (GSPO) to the turn level to balance stability with precise credit assignment in multi-turn interactions.
     • MCLA (Monte-Carlo Log-probability Averaging): Reduces log-probability variance in MoE models by averaging forward passes ($K=8$), stabilizing MoE RL training.
     • Tree Training: Eliminates redundant computation in tree-structured agent trajectories by serializing them into a single DFS sequence with per-token loss weighting, achieving up to 6.2× speedup.
   • KRL Framework: A high-throughput RL framework integrating Cache-Aware scheduling and Dynamic Streaming to reduce unit sample cost by 2.8×.

3. On-Policy Distillation (OPD) - Unification:
   To fuse the five experts into a single model without catastrophic forgetting:

   • The unified "Student" model generates trajectories on-policy.
   • For each task, the best-performing "Teacher" expert provides dense, step-level supervision via log-probabilities.
   • This combines the sparse environmental rewards of RL with the dense guidance of distillation, avoiding the exposure bias of offline imitation.

3. Key Contributions

• KAT-Coder-V2 Model: A state-of-the-art agentic coding model that rivals proprietary leaders across diverse domains.
• KwaiEnv: A scalable, decoupled infrastructure enabling high-throughput RL training with tens of thousands of concurrent sandboxes.
• Specialize-then-Unify Paradigm: A systematic approach to handling capability fragmentation by training domain experts separately before fusing them via On-Policy Distillation.
• Algorithmic Breakthroughs:
  • MCLA: Stabilizes MoE RL training by reducing log-probability variance.
  • Tree Training: Solves the computational bottleneck of tree-structured agent trajectories, offering up to 6.2× training acceleration.
  • Agentic Scaling: A data synthesis strategy that scales RL along complexity, intent, and scaffold dimensions.
• Aesthetic Evaluation Benchmark: A reference-free, multi-dimensional benchmark for evaluating frontend generation quality based on professional designer feedback.

4. Results

KAT-Coder-V2 demonstrates competitive or superior performance across multiple benchmarks:

• Software Engineering (SWE):
  • SWE-bench Verified: 79.6% (vs. Claude Opus 4.6 at 80.8%).
  • Performs consistently across different scaffolds (Claude Code, OpenCode, OpenClaw).
• Agent Task Execution:
  • PinchBench: 88.7 (Surpassing GLM-5 at 86.4 and MiniMax M2.7 at 87.1).
  • Strong performance in long-chain task execution and high-concurrency scenarios.
• Frontend Aesthetics:
  • Ranks first across all three scenarios: Landing Pages (59.8), Slides (57.6), and Data Visualization (67.6).
• General Capabilities:
  • Terminal-Bench Hard: 46.8.
  • $\tau^2$-Bench: 93.9.
  • Maintains strong generalist scores while excelling in specialized domains.

5. Significance

The paper presents a principled path toward building powerful, general-purpose coding agents. By acknowledging that a single monolithic training signal cannot satisfy the diverse requirements of modern software engineering, KAT-Coder-V2 proves that domain specialization followed by unified distillation is a viable strategy.

Furthermore, the work highlights that infrastructure and algorithmic efficiency are as critical as model architecture. The development of KwaiEnv and the introduction of Tree Training and MCLA demonstrate how to overcome the computational and stability bottlenecks inherent in scaling agentic RL. This approach allows the model to achieve near-state-of-the-art performance on complex, multi-step tasks while maintaining robustness across different agent frameworks and user intents.