Overview
Cursor announces Composer 1.5, a significantly improved agentic coding model built by scaling reinforcement learning 20x beyond Composer 1. The model is a thinking model that balances speed and intelligence for daily use, featuring adaptive thinking depth and self-summarization capabilities to handle longer tasks while maintaining accuracy across varying context lengths.
What You'll Learn
1
How Cursor's Composer 1.5 improves on Composer 1 through scaled reinforcement learning
2
Why thinking tokens and adaptive reasoning depth matter for agentic coding models
3
How self-summarization allows AI coding models to maintain accuracy across long contexts
4
Why scaling RL post-training beyond pretraining compute produces predictable intelligence improvements
Prerequisites & Requirements
- Basic understanding of AI coding assistants and agentic coding workflows
- Familiarity with Cursor IDE and its Composer feature
- Understanding of reinforcement learning concepts and model training(optional)
Key Questions Answered
What is Cursor Composer 1.5 and how does it improve on Composer 1?
Composer 1.5 is Cursor's latest agentic coding model, built by scaling reinforcement learning 20x further on the same pretrained model as Composer 1. The post-training compute surpasses the amount used to pretrain the base model itself. It delivers significantly stronger coding ability, with the most notable improvements on challenging tasks, while maintaining speed for interactive daily use.
How does Composer 1.5 balance speed and intelligence for daily coding use?
Composer 1.5 is trained to adaptively adjust its thinking depth based on problem difficulty. On easy problems, the model responds quickly with minimal thinking tokens, keeping interactions fast and interactive. On hard problems, it generates more thinking tokens to reason deeply about the codebase and plan next steps until it finds a satisfying answer. This adaptive approach avoids the overhead of deep reasoning when it's unnecessary.
What is self-summarization in Composer 1.5 and why does it matter?
Self-summarization is a capability trained into Composer 1.5 via reinforcement learning that allows the model to produce a useful summary of its work when it runs out of available context. This enables the model to continue exploring for a solution on longer-running tasks without losing critical information. The process can trigger multiple times recursively on hard examples, and it allows the model to maintain its original accuracy as context length varies.
How much reinforcement learning scaling was used to train Composer 1.5?
Composer 1.5 was built by scaling reinforcement learning 20x further compared to Composer 1, using the same pretrained base model. Notably, the compute used in the post-training phase of Composer 1.5 surpasses the total amount of compute used to pretrain the base model, demonstrating a significant investment in RL-based fine-tuning for coding ability.
Does scaling reinforcement learning for coding produce predictable improvements?
Yes, Cursor's internal benchmarks of real-world coding problems show that Composer 1.5 quickly surpasses Composer 1 and continues to climb in performance as RL is scaled. The improvements are most significant on challenging tasks. This demonstrates that RL for coding can be continually scaled with predictable intelligence improvements, suggesting further gains are achievable with additional compute.
Is Composer 1.5 a thinking model and how does it use reasoning tokens?
Yes, Composer 1.5 is a thinking model that generates thinking tokens during its response process. These tokens allow the model to reason about the user's codebase and plan next steps before producing output. The thinking stages are described as critical to the model's intelligence, and the model is trained to use them adaptively—minimally for easy problems and extensively for hard problems.
Key Statistics & Figures
Reinforcement learning scaling factor over Composer 1
20x
RL was scaled 20x further on the same pretrained model to produce Composer 1.5
Post-training compute vs pretraining compute
Post-training surpasses pretraining
The compute used in post-training of Composer 1.5 exceeds the amount used to pretrain the base model
Technologies & Tools
AI Model
Composer 1.5
Cursor's latest agentic coding model with adaptive thinking and self-summarization
AI/ML Training
Reinforcement Learning
Primary training methodology scaled 20x to improve coding ability
IDE
Cursor
AI-native code editor that hosts the Composer model
Key Actionable Insights
1Consider switching to Composer 1.5 for interactive coding tasks, as it is described as significantly stronger than Composer 1 and specifically recommended for interactive use. The adaptive thinking depth means you get fast responses for simple tasks without sacrificing quality on complex problems.Cursor explicitly recommends Composer 1.5 over Composer 1 for interactive daily use, suggesting it should replace Composer 1 as the default model choice.
2Expect Composer 1.5 to perform best on challenging coding tasks, where the improvements over Composer 1 are most significant. Routine or simple coding tasks will still benefit from the model's speed, but the intelligence gains are most pronounced on harder problems.Internal benchmarks show the performance gap between Composer 1 and 1.5 widens on more difficult tasks, making it especially valuable for complex refactoring, debugging, or multi-file changes.
3Leverage Composer 1.5's self-summarization capability for longer-running coding tasks that may exceed context limits. The model can recursively summarize its progress and continue working, so you don't need to manually break up large tasks as aggressively.Self-summarization is trained directly into the model via RL, maintaining accuracy across varying context lengths, which is particularly useful for large codebase exploration and multi-step refactoring.
4The 20x RL scaling approach with predictable improvements suggests that future Composer versions will continue to improve coding ability. Teams evaluating AI coding tools should factor in this trajectory of improvement when making adoption decisions.The demonstrated scaling relationship between RL compute and coding performance indicates this is a repeatable methodology, not a one-time gain.
Common Pitfalls
1
Assuming Composer 1.5 will think deeply on every task. The model is specifically trained to minimize thinking on easy problems for speed, so simple queries will get fast responses with minimal reasoning. Don't interpret quick responses as the model not trying—it's an intentional design choice.
The adaptive thinking depth is a core feature, not a limitation. For tasks requiring deep reasoning, the model will automatically allocate more thinking tokens.
2
Not leveraging the self-summarization feature for longer tasks. If you've been manually breaking up complex coding tasks into smaller chunks to avoid context limits, Composer 1.5 can handle longer exploration through recursive self-summarization without losing accuracy.
Self-summarization maintains original accuracy as context length varies, so the model can work through extended multi-step problems without degradation.
Related Concepts
Reinforcement Learning For Code Generation
Chain-of-thought Reasoning In AI Models
Thinking Tokens And Adaptive Reasoning
Context Window Management And Self-summarization
Agentic Coding Assistants
Post-training Compute Scaling
Ai-assisted Software Development
Model Distillation And Fine-tuning