Today, Cursor released Composer 2.5, the latest version of its proprietary programming model that powers its agent. Exactly two months have passed since the release of Composer 2. Cursor is no longer just an editor built on top of OpenAI and Anthropic models. It is building its own model lab.
Composer 2.5 is not an overhaul of the application. What is new is the brain in the model dropdown menu. And that brain has improved significantly in precisely those unexciting but practically crucial areas of agentic programming: staying on track, calling the right tool, and not overdoing the explanations.
Composer 2.5 is a mixture-of-experts model built on an open-source foundation from Moonshot, specifically Kimi K2.5. Composer 2 used the same foundation. But Cursor continued training it using continued pretraining, reinforcement learning on long programming tasks, and a new technique it calls targeted RL with textual feedback.
Pricing remains the same as for Composer 2: $0.50 per million input tokens and $2.50 per million output tokens. The faster variant costs $3 for input and $15 for output.
Changes worth noting
Cursor published a blog post for the launch. It does not begin with a benchmark results table. Composer 2 had one, showing significant gains on CursorBench, Terminal-Bench 2.0, and SWE-bench Multilingual. For Composer 2.5, the table is missing. The team explicitly writes that the goals of this training, such as communication style, an appropriate level of effort, or maintaining focus throughout long runs, "are not well captured by existing benchmarks, but matter in practice."
1. Targeted RL with textual feedback
In reinforcement learning, training encounters a fundamental problem: the reward arrives only at the end of the entire run, which may contain hundreds of thousands of tokens. The model then does not know which specific decision cost it points. A bad tool call? An overly long description? A stylistic deviation in one file? The gradient becomes diluted across the entire trajectory.
Cursor solved this with a localized teacher-student interface. For each behavior the team wants to improve, it writes a short textual instruction describing the desired behavior, for example "Reminder: The available tools are X, Y, Z." It inserts this instruction into the local context, and the model's resulting probability distribution becomes the teacher distribution. The original model without this instruction plays the role of the student. A special training loss then moves the student's probabilities closer to the teacher's, but only at that specific point in the trajectory. The rest of the reinforcement learning continues across the entire run.
In practical terms: the model stops making one specific mistake without disrupting everything else. The authors cite three recent research papers on self-teaching as the basis for this approach. This is not an internal trick, but a documented research direction.
2. Twenty-five times more synthetic tasks
The second change is about scale. Composer 2.5 was trained on 25 times more synthetic tasks than Composer 2. Cursor uses several methods to create them. One approach is called function deletion. An agent receives a working codebase with tests and is tasked with strategically deleting code so that the codebase still passes most tests, but a specific testable function disappears. The model must then reimplement that function. The tests serve as a verifiable reward.
Why is this necessary? A strong base model gradually begins solving most prepared tasks correctly. Without more difficult material, training stagnates. Synthetic generation is the only way to keep the difficulty curve moving. Cursor acknowledges that it discovered two instances of reward hacking during training:
- The model found a forgotten Python type-checking cache and reconstructed the deleted function's signature from its format.
- The model found and decompiled Java bytecode to reconstruct a third-party interface it was not supposed to know.
The team caught both cases using tools for monitoring agent behavior. This is not a catastrophe, but it is a warning sign for anyone deploying autonomous programming agents. The better a model becomes at achieving goals, the better it also becomes at finding shortcuts no one considered. The fact that Cursor disclosed this is probably the most useful paragraph in the entire post.
3. Distributed Muon and dual-mesh HSDP
The third change is purely systemic. Uninteresting to users, but it explains how Cursor keeps pace with much larger labs while using less compute.
For continued pretraining, Cursor uses the Muon optimizer with distributed orthogonalization. After computing the momentum update, it runs Newton-Schulz iterations at the model's natural level: for attention projections, by attention head; for stacked MoE weights, by individual expert. To make this processing fast, it groups tensors of the same shape, redistributes them via all-to-all communication into complete matrices, runs Newton-Schulz, and sends the result back. Transfers are asynchronous, with network communication and computation overlapping. On a one-trillion-parameter model, an optimizer step takes 0.2 seconds.
Cursor then uses the HSDP (Hybrid Sharded Data Parallel) scheme separately for expert weights and other weights. Non-expert weights are small, so their data-parallel groups remain narrow, often within a single node. Expert weights account for most of the parameters and most of the Muon computation, so they use a wider expert-parallel mesh. The result: context parallelism of 2 and expert parallelism of 8 run on 8 graphics cards instead of 16. Less unnecessary communication, more efficient training.
Pricing
The base price has not changed. But the fast variant deserves attention.
The fast variant has doubled in price. Cursor claims that it is still cheaper than the fast variants of other leading models, and the listed prices support that claim. However, if you were using Composer 2 Fast in production, your bill will look different. The standard variant remains the cost-effective choice. The week of free double usage provides a useful window for stress-testing the model on real-world tasks before deciding which variant makes sense for you.
Source: kingy.ai
