Authors: Cursor Research, :, Aaron Chan, Ahmed Shalaby, Alexander Wettig, Aman Sanger, Andrew Zhai, Anurag Ajay, Ashvin Nair, Charlie Snell, Chen Lu, Chen Shen, Emily Jia, Federico Cassano, Hanpeng Liu, Haoyu Chen, Henry Wildermuth, Jacob Jackson, Janet Li, Jediah Katz, Jiajun Yao, Joey Hejna, Josh Warner, Julius Vering, Kevin Frans, Lee Danilek, Less Wright, Lujing Cen, Luke Melas-Kyriazi, Michael Truell, Michiel de Jong, Naman Jain, Nate Schmidt, Nathan Wang, Niklas Muennighoff, Oleg Rybkin, Paul Loh, Phillip Kravtsov, Rishabh Yadav, Sahil Shah, Sam Kottler, Alexander M Rush, Shengtong Zhang, Shomil Jain, Sriram Sankar, Stefan Heule, Stuart H. Sul, Sualeh Asif, Victor Rong, Wanqi Zhu, William Lin, Yuchen Wu, Yuri Volkov, Yury Zemlyanskiy, Zack Holbrook, Zhiyuan Zhang
Composer 2 is a specialized model designed for agentic software engineering. The model demonstrates strong long-term planning and coding intelligence while maintaining the ability to efficiently solve problems for interactive use. The model is trained in two phases: first, continued pretraining to improve the model's knowledge and latent coding ability, followed by large-scale reinforcement learning to improve end-to-end coding performance through stronger reasoning, accurate multi-step execution, and coherence on long-horizon realistic coding problems. We develop infrastructure to support training in the same Cursor harness that is used by the deployed model, with equivalent tools and structure, and use environments that match real problems closely. To measure the ability of the model on increasingly difficult tasks, we introduce a benchmark derived from real software engineering problems in large codebases including our own. Composer 2 is a frontier-level coding model and demonstrates a process for training strong domain-specialized models. On our CursorBench evaluations the model achieves a major improvement in accuracy compared to previous Composer models (61.3). On public benchmarks the model scores 61.7 on Terminal-Bench and 73.7 on SWE-bench Multilingual in our harness, comparable to state-of-the-art systems.
Figures & tables
Figure 1: Composer 2 improves greatly from previous Composer models, achieving performance competitive with state-of-the-art models. By specializing entirely on coding ability, Composer attains such performance while being lower cost to serve than state-of-the-art model API pricing. See Section 5 for detailed evaluations.
Figure 3: RL training tasks.
Figure 4: Comparison of estimators of KL(p∥q) for two synthetic Gaussian distributions with unit variance and different means.
Figure 5: Both average and best-of-K performance increase over the RL training period. The above curves are reported on a held-out evaluation set, along with CursorBench tasks. Performance steadily improves throughout RL training. Importantly, we do not observe a tradeoff between average performance and best-of-K performance.
Figure 6: Nonlinear penalties push the model to be quick on easy tasks and think more on hard tasks.
Figure 7: Compared to public benchmarks, CursorBench tasks have less-specified task prompts, and require an order of magnitude more code changes. We find this better represents the complexity and ambiguity of real-world software engineering requests.
Figure 8: Example CursorBench task (truncated and obfuscated from our evaluation pipeline). The agent receives a terse bug report and must cross-reference the source code with production observability logs to diagnose the failure. The logs also contain unrelated production service warnings which are a red herring: the true root cause is an esbuild 0.20.2 downleveling bug for using . The transpiled output lowers the highlighted declaration into var -scoped error state that is not reset between retry iterations, causing stale failure state to be re-thrown from the generated finally block even after later attempts succeed.
Figure 9: Evolution of CursorBench across iterations. Each version incorporates more complex requests. CursorBench-3 more than doubles the median task size from the initial version, shown as the relative percent change in the bottom bar.
Figure 10: Overview of a single grouped GEMM training flow in our Mixture-of-Experts layer. Each colored block represents a single kernel launch.
Figure 11: On CursorBench, Composer 2 achieves a superior Pareto frontier in cost while remaining highly competitive in token efficiency. For GPT-5.4, Codex-5.3, Opus 4.6, and Sonnet 4.6, we plot the high (circle), medium (triangle), and low (square) effort variants.
Model
CursorBench
SWE-bench Multi.
Terminal-Bench
Composer 2
61.3
73.7
61.7
Composer 1.5
44.2
65.9
47.9
Composer 1
38.0
56.9
40.0
Opus 4.6 High
58.2
75.8 / 77.8
58.0 / 65.4
Opus 4.5 High
48.4
73.8 / 76.2
52.1 / 59.8
GPT-5.4
63.9
76.8 / -
66.5 † / 75.1
Table 1: Benchmark results across public and internal evaluation suites. For third-party models, we present results in an (our harness / self-reported) format where both are available. For Anthropic models on Terminal-Bench, we report the Claude Code scores from the official leaderboard in place of our harness evaluation. Overall, Composer 2 achieves accuracy competitive with the strongest frontier models.
Appendix figures & tables2 assets
Supplementary material from the paper’s appendix.
Appendix
Model
FreshBench ↑
State Tracking ↓
Negative Log-Likelihood ↓
DeepSeek V3.2
68.9%
66
11.75M
Kimi K2.5
83.2%
86
13.81M
GLM-5
79.2%
92
14.11M
GPT-5.4
92.5 %
103
-
Claude 4.6 Opus
88.9%
65
-
Gemini 3 Flash
84.5%
27
-
Appendix
Table 2: Base models evaluated on our internal benchmarks. Negative log-likelihood is measured over our internal codebase.
Figure 12: Example CursorBench task. The agent must infer the failure mode from a partial symptom report, write a heuristic detection algorithm over 954 heterogeneous chat responses, and carefully tune that heuristic to recover an exact count of malformed prefix-streaming cases without overcounting normal incremental output. Additionally, a variant of the bug produces an “interleave stutter” where the initial prefix chain is only two lines long before stabilizing into a repeating line with incrementing repetitions and agent must carefully examine chat responses to discover this.
We present KAT-Coder-V2.5, a coding-focused agentic model trained to act autonomously inside real, executable repositories rather than as a single-turn code generator. Its capability is bottlenecked less by model scale than by the scarcity of reproducible environments, verifiable rewards, and high-value trajectories, which we address with an end-to-end agentic post-training framework. AutoBuilder reconstructs multilingual repositories into sandboxed environments with fail-to-pass and pass-to-pass verification at scale, from which we regenerate self-contained task specifications, recover near-miss trajectories, and distill supervision through process-aware filtering, while KwaiClawEnv synthesizes large-scale tool-use trajectories from executable services and real task seeds. We further scale reinforcement learning with harness randomization, a reliability-hardened sandbox, an asymmetric actor--critic PPO with hindsight-augmented value estimation, and a harness-oriented reward framework, and unify SWE, Agent-Claw, and WebCoding experts via Multi-Teacher On-Policy Distillation. Across six software-engineering and agentic benchmarks, KAT-Coder-V2.5 delivers the best agentic tool-use result on PinchBench and ranks second only to the frontier Opus 4.8 on repository-level software engineering. Our service is available at https://streamlake.com/product/kat-coder.
Turning ideas into full software projects from scratch has become a popular use case for language models. Agents are being deployed to seed, maintain, and grow codebases over extended periods with minimal human oversight. Such settings require models to make high-level software architecture decisions. However, existing benchmarks measure focused, limited tasks such as fixing a single bug or developing a single, specified feature. We therefore introduce ProgramBench to measure the ability of software engineering agents to develop software holisitically. In ProgramBench, given only a program and its documentation, agents must architect and implement a codebase that matches the reference executable's behavior. End-to-end behavioral tests are generated via agent-driven fuzzing, enabling evaluation without prescribing implementation structure. Our 200 tasks range from compact CLI tools to widely used software such as FFmpeg, SQLite, and the PHP interpreter. We evaluate 9 LMs and find that none fully resolve any task, with the best model passing 95% of tests on only 3% of tasks. Models favor monolithic, single-file implementations that diverge sharply from human-written code.
DeepSWE is a benchmark of 113 original, long-horizon software engineering tasks for evaluating coding agents. Most public agentic coding benchmarks follow SWE-bench in mining merged fixes from public GitHub repositories, which creates two problems: the fixes and their discussion were likely seen during pretraining, so a high score can reflect recall rather than problem-solving; and each task is graded by the tests that shipped with its merged fix, which were written to confirm one specific fix rather than grade an arbitrary solution, so they can fail a correct alternative or pass an incomplete one. DeepSWE avoids both. Its tasks are written from scratch across 91 active open-source repositories and five languages and are never contributed back upstream, so their reference solutions stay out of the public record that model training scrapes; and each task is graded by a hand-written verifier that checks the requested functionality and accepts any implementation that provides it. When an independent LLM judge re-reviews graded runs, it disagrees with DeepSWE's verifier about an order of magnitude less often than with SWE-Bench Pro's inherited tests (1.4% versus 32.4%). Despite being about half the length of SWE-Bench Pro's prompts, DeepSWE's prompts describe tasks whose reference solutions touch 5.5x more code, and the benchmark separates frontier agents across a wider score band than the leaderboards on which they otherwise cluster. We release the benchmark, its verifiers, and the full record of evaluation trajectories.