Overview
Cursor Composer 2, released March 19, 2026, is the second major generational upgrade to Cursor's proprietary coding model. Built specifically for autonomous software engineering inside the Cursor IDE, Composer 2 represents a significant step up from Composer 1.5 across every major benchmark: CursorBench 61.3 (up from 44.2), Terminal-Bench 2.0 61.7 (up from 47.9), and SWE-bench Multilingual 73.7 (up from 65.9).
The release introduces two speed variants — a standard model at $0.50/M input tokens and a fast model at $1.50/M input tokens (now the default in Cursor) — and adds stronger continued pretraining plus long-horizon RL training for tasks spanning hundreds of sequential actions. For developers already using Cursor Composer or evaluating AI agent tools for coding, Composer 2 establishes a new ceiling for IDE-native autonomous coding.
What's New
Frontier Benchmark Performance
Composer 2 achieves three major benchmark improvements over Composer 1.5:
- CursorBench: 61.3 (up from 44.2 in v1.5, 38.0 in v1) — Cursor's internal benchmark for realistic, complex engineering tasks
- Terminal-Bench 2.0: 61.7 (up from 47.9 in v1.5) — measures autonomous bug identification, fix writing, and verification in CLI environments without human intervention
- SWE-bench Multilingual: 73.7 (up from 65.9 in v1.5) — reflects performance across polyglot codebases in multiple programming languages
These gains reflect a fundamentally upgraded training process rather than incremental fine-tuning.
Self-Summarization for Long-Horizon Tasks
The model is trained with self-summarization, allowing it to compress and retain context beyond standard context window limits. This enables Composer 2 to complete tasks requiring hundreds of sequential actions — multi-file refactoring, iterative debugging, and extended agentic workflows — without losing coherence mid-task.
In earlier versions, very long sessions could lose track of prior steps or repeat work. Composer 2 continues Cursor's work on self-summarization and broader long-horizon training for real-world coding tasks.
Continued Pretraining and RL Optimization
Composer 2 was built using continued pretraining on high-quality code combined with reinforcement learning specifically optimized for long-horizon tasks. Unlike simply fine-tuning a general-purpose model, this training approach is designed to develop step-level consistency — the ability to execute hundreds of discrete coding, debugging, and verification steps while maintaining accuracy throughout.
Cursor attributes Composer 2's gains to continued pretraining plus long-horizon RL training, rather than framing this as a categorical industry distinction.
Two Speed Variants
Composer 2 ships in two variants:
- Standard: $0.50/M input, $2.50/M output — optimized for cost efficiency on prototyping and routine tasks
- Fast (default): $1.50/M input, $7.50/M output — optimized for real-time IDE latency; now the default in Cursor
The fast variant is the recommended option for interactive development sessions where latency matters. Both variants share the same underlying model capability — the difference is response speed.
How It Compares to Composer 1.5
| Metric | Composer 1.5 | Composer 2 | Change |
|---|---|---|---|
| CursorBench | 44.2 | 61.3 | +38.7% |
| Terminal-Bench 2.0 | 47.9 | 61.7 | +28.8% |
| SWE-bench Multilingual | 65.9 | 73.7 | +11.8% |
| Standard input price | — | $0.50/M | New pricing tier |
| Fast input price | — | $1.50/M | New pricing tier |
| Self-summarization | Yes | Yes | Already present in v1.5 |
The most notable jump is in CursorBench, Cursor's own benchmark for realistic engineering tasks, where Composer 2 scores 38.7% higher than v1.5.
Pricing & Plans
Composer 2 is accessed through Cursor. Cursor offers the following subscription plans:
| Plan | Price | Composer 2 access |
|---|---|---|
| Hobby | Free | Limited Agent requests |
| Pro | $20/month | Extended Agent limits, frontier model access |
| Pro+ | $60/month | 3× usage on all OpenAI, Claude, Gemini models |
| Ultra | $200/month | 20× usage on all models, priority access |
| Teams | $40/user/month | Everything in Pro + centralized billing, SSO |
| Enterprise | Custom | Pooled usage, SCIM, AI code tracking API |
For usage beyond included plan usage, Composer 2 is priced at the model level; on individual plans, Composer usage is part of a standalone usage pool:
| Variant | Input | Output |
|---|---|---|
| Standard | $0.50 / M tokens | $2.50 / M tokens |
| Fast (default) | $1.50 / M tokens | $7.50 / M tokens |
Cursor positions Composer 2 as cost-competitive with leading fast coding models. Cursor says Composer 2 is also available in the early alpha of its new interface.
Best For
- Engineers on Cursor Pro or Teams plans who need the most capable native coding model for multi-file and terminal-integrated tasks
- Teams doing repository-wide refactoring across polyglot codebases who need consistent behavior across language boundaries
- Developers evaluating AI code review and analysis tools who also want autonomous fix-and-verify capability in the same workflow
- Growth-stage engineering teams that want to maximize agentic coding throughput without external API overhead
- Users upgrading from Composer 1.5 who hit context limits or accuracy issues on long multi-step sessions
- Developers comparing Claude Code and IDE-native agents who want a direct performance benchmark to inform the decision
FAQ
What changed between Composer 1.5 and Composer 2?
Composer 2 scores 61.3 on CursorBench (up from 44.2), 61.7 on Terminal-Bench 2.0 (up from 47.9), and 73.7 on SWE-bench Multilingual (up from 65.9). The training approach was upgraded to include continued pretraining on high-quality code and RL optimized for long-horizon tasks, plus stronger continued pretraining and long-horizon RL training for tasks requiring hundreds of sequential actions.
What is self-summarization and why does it matter?
Self-summarization is a training technique that enables Composer 2 to compress prior context and continue working accurately beyond the limits of its context window. Without it, very long coding sessions — extended refactoring, multi-round debugging — can cause the model to lose track of earlier state. Self-summarization specifically targets this failure mode.
What is the difference between Standard and Fast Composer 2?
Standard Composer 2 costs $0.50/M input and $2.50/M output tokens; it is suited for prototyping and tasks where real-time speed is not critical. The Fast variant costs $1.50/M input and $7.50/M output tokens but responds quickly enough for interactive IDE use. The Fast variant is now the default in Cursor.
How does Composer 2 compare to Codex?
Codex is OpenAI's coding agent across app, IDE extension, CLI, and cloud workflows, while Composer 2 is Cursor's native in-editor model. Composer 2's 61.7 Terminal-Bench 2.0 score supports strong autonomous CLI debugging performance; Codex operates via API with computer-use capability. The choice depends on whether you prefer IDE-native or API-based agentic workflows.
Do I need a paid plan to use Composer 2?
Cursor's Hobby plan is free and includes limited Agent requests. For extended use of Composer 2, the Pro plan at $20/month provides higher Agent limits and access to frontier models. Pro+ ($60/month) and Ultra ($200/month) offer higher usage multipliers.
