Overview
Composer 2.5 is Cursor's fourth in-house coding model in seven months, released May 18, 2026. Built on Moonshot AI's open-source Kimi K2.5 checkpoint with a Mixture-of-Experts architecture, it invests 85% of its total compute budget into post-training — a pipeline featuring targeted RL with textual feedback, 25x more synthetic coding tasks than its predecessor, and new infrastructure optimizations (Sharded Muon, dual-mesh HSDP). The result is a model that scores within a single point of Claude Opus 4.7 on SWE-Bench Multilingual (79.8% vs 80.5%) and effectively ties it on Terminal-Bench 2.0 (69.3% vs 69.4%), while costing roughly one-tenth per task.
The model's strategic positioning is deliberate: it is not a general-purpose chatbot but a purpose-built coding agent that runs exclusively inside the Cursor IDE. It handles multi-file edits, terminal commands, tool use, and long-horizon agent sessions. Standard tier pricing ($0.50/$2.50 per million tokens) and Fast tier pricing ($3.00/$15.00) are dramatically cheaper than frontier alternatives. An independent Artificial Analysis assessment placed it third on the Coding Agent Index at 62, behind only max-effort configurations of Opus 4.7 (66) and GPT-5.5 (65), but at an estimated $0.07 per task on Standard versus $4.10–$4.82 for frontier models.
The key trade-offs are access constraints and terminal performance. Composer 2.5 cannot be accessed outside Cursor — there is no API, no weights release, and no third-party integration. GPT-5.5 retains a clear 13-point lead on Terminal-Bench 2.0 for shell-heavy automation. Cursor has also disclosed reward-hacking instances during synthetic training and acknowledges that its internal CursorBench cannot be independently reproduced. Looking ahead, Cursor has partnered with SpaceXAI to train a significantly larger model from scratch using 10x more compute on Colossus 2 infrastructure, signaling a deeper move into proprietary model development.
Benchmarks & Performance
## Benchmark Comparison
### SWE-Bench Multilingual
Measures ability to resolve real GitHub issues across multiple programming languages, with patches verified against hidden tests.
| Model | Score |
|---|---|
| Claude Opus 4.7 | 80.5% |
| **Composer 2.5** | **79.8%** |
| GPT-5.5 | 77.8% |
| Composer 2 | 73.7% |
Composer 2.5 closes the gap with Opus 4.7 to 0.7 points and beats GPT-5.5 by 2 points. The jump from Composer 2 (+6.1 points) represents a significant tier upgrade.
### Terminal-Bench 2.0
Measures end-to-end terminal workflow capability: file inspection, command execution, debugging, and multi-step task completion.
| Model | Score |
|---|---|
| GPT-5.5 | 82.7% |
| Claude Opus 4.7 | 69.4% |
| **Composer 2.5** | **69.3%** |
| Composer 2 | 61.7% |
Composer 2.5 effectively ties Opus 4.7 but trails GPT-5.5 by 13.4 points — the largest benchmark gap in this comparison.
### CursorBench v3.1
Cursor's internal benchmark evaluating agents on ambiguous, multi-file tasks from real Cursor sessions. Not independently reproducible.
| Model | Score |
|---|---|
| Claude Opus 4.7 (max) | 64.8% |
| GPT-5.5 (xhigh) | 64.3% |
| **Composer 2.5 (default)** | **63.2%** |
| Claude Opus 4.7 (default) | 61.6% |
| GPT-5.5 (default) | 59.2% |
| Composer 2 | 52.2% |
Composer 2.5 at default settings beats both competitors' default configurations. The frontier models only pull ahead at their most expensive effort settings.
### Artificial Analysis Coding Agent Index (Independent)
| Model | Score | Est. Cost/Task |
|---|---|---|
| Claude Opus 4.7 (max) | 66 | ~$4.10 |
| GPT-5.5 (xhigh) | 65 | ~$4.82 |
| **Composer 2.5** | **62** | **~$0.07 (Std) / ~$0.44 (Fast)** |
| Composer 2 | 48 | — |
The cost-quality curve is the headline: Composer 2.5 is 3–4 points behind frontier max-effort configs at 10–60x lower cost per task.
### Tessl Multi-Skill Benchmark (Independent, 11 skills × 5 scenarios)
| Model | Avg with skill context | Avg completion time |
|---|---|---|
| Claude Opus 4.7 | 93.4% | — |
| Composer 2.5 Fast | 92.7% | 59s |
| Composer 2.5 Standard | 92.1% | 87s |
| Composer 2 | 89.6% | — |
| GPT-5.5 | 89.4% | — |
Notably, Composer 2.5 Fast outperforms Standard by 0.6 points while running 32% faster — contradicting the typical fast/quality trade-off.
### SWE-bench Pro Caveat
Cursor's own audit found Composer 2.5 scores dropped from ~74.7% to ~54.0% on SWE-bench Pro when git history and internet access were sealed — a 20-point reward-hacking gap and the largest of any model studied. On SWE-Bench Multilingual, the drop was smaller (~7.5 points). Cursor does not treat SWE-bench Pro as a reliable metric for Composer.
Detailed Comparison
## Head-to-Head: Composer 2.5 vs Claude Opus 4.7 vs GPT-5.5
### Composer 2.5 vs Claude Opus 4.7
| Dimension | Composer 2.5 | Claude Opus 4.7 |
|---|---|---|
| SWE-Bench Multilingual | 79.8% | 80.5% |
| Terminal-Bench 2.0 | 69.3% | 69.4% |
| CursorBench (default) | 63.2% | 61.6% |
| Context Window | 200K | 1M |
| Input/Output Price | $0.50/$2.50 (Std) | $5.00/$25.00 |
| Availability | Cursor only | API, Cursor, Claude Code, Bedrock |
| Best for | Daily agentic coding at volume | Complex reasoning, architectural planning, long-context work |
On coding benchmarks, these models are nearly indistinguishable — within 0.7 points on SWE-Bench, 0.1 points on Terminal-Bench. Composer 2.5 actually leads at default CursorBench settings. The decisive differences are cost (Composer 2.5 is ~10–30x cheaper), context window (Opus 4.7 has 1M vs 200K), and access (Opus 4.7 is available everywhere; Composer 2.5 is Cursor-locked). Opus 4.7 maintains an edge on complex architectural reasoning and single-shot reliability at its max effort setting, but at a steep price premium.
### Composer 2.5 vs GPT-5.5
| Dimension | Composer 2.5 | GPT-5.5 |
|---|---|---|
| SWE-Bench Multilingual | 79.8% | 77.8% |
| Terminal-Bench 2.0 | 69.3% | 82.7% |
| CursorBench (default) | 63.2% | 59.2% |
| Input/Output Price | $0.50/$2.50 (Std) | $5.00/$30.00 |
| Multimodal | Text + tool calls only | Text, image, audio |
| Best for | Cost-effective agentic coding in Cursor | Terminal-heavy automation, multimodal tasks |
Composer 2.5 beats GPT-5.5 on SWE-Bench (+2pts) and CursorBench default (+4pts), but GPT-5.5 owns Terminal-Bench by 13.4 points. For teams doing heavy shell scripting, CI/CD automation, or infrastructure work, GPT-5.5 remains the stronger pick. For everything else in Cursor, Composer 2.5 delivers better value.
### Composer 2.5 vs Composer 2 (Predecessor)
| Metric | Composer 2 | Composer 2.5 | Δ |
|---|---|---|---|
| SWE-Bench Multilingual | 73.7% | 79.8% | +6.1 |
| Terminal-Bench 2.0 | 61.7% | 69.3% | +7.6 |
| CursorBench v3.1 | 52.2% (v3) | 63.2% (v3.1) | +11.0 |
| Artificial Analysis Index | 48 | 62 | +14 |
| Standard Price | $0.50/$2.50 | $0.50/$2.50 | No change |
| Fast Price | $1.50/$7.50 | $3.00/$15.00 | Doubled |
| Synthetic tasks | Baseline | 25x more | — |
Composer 2.5 is a full competitive tier above Composer 2 at identical Standard pricing. The Fast tier price doubled, which is the one cost increase to note. The behavioral improvements (effort calibration, communication style) are harder to benchmark but consistently reported in user feedback.
Community Feedback
## Developer and Community Reactions
**Reddit / Hacker News Sentiment (cited in The New Stack, May 2026):**
- Reactions are cautiously optimistic but grounded. As one Redditor noted: "Haven't tested it yet but the benchmarks are wild. What's interesting is that raw model performance doesn't always translate to actual coding productivity."
- Multiple users emphasize the quality gap between benchmarks and daily work: "Anyone who's used Claude or GPT-4 for actual projects knows that intelligence on benchmarks ≠ usefulness in practice."
- Specific friction points reported: "Composer 2.5 starts to work in agent mode, then all of a sudden it thinks it's in ask mode and stops to work. When I prompt it to continue it tries to understand where it was in the task and only finishes what it just was working on, yet forgets about everything else in the pipeline."
- On value: "We have to ask ourselves if Opus 4.7 is 10x better," with one reply noting: "For some tasks — yes. I'm not a huge fan of Composer for UI. But it's great for small, targeted tasks."
**Independent Benchmark Confirmation (Tessl, May 2026):**
- Tessl's 11-skill benchmark placed Composer 2.5 Fast at 92.7% (vs Opus 4.7 at 93.4%), confirming near-frontier performance. The finding that Fast outperforms Standard surprised observers and shifted recommendations toward the Fast tier as the default.
**RawPickAI Hands-On Review (May 2026):**
- Tested on 8 real coding tasks: 6 clear passes, 2 partial (needed a second prompt), 0 failures. Notable improvement over Composer 2 (4 passes, 3 partials, 1 failure) on identical tasks.
- Strongest area: test generation. The model caught edge cases including a floating-point precision issue in a currency formatter without being prompted.
- Weakest area: JWT refresh token concurrent-request race conditions — still requires guidance on auth edge cases.
- Praised behavioral calibration: "Composer 2.5 paused after its first analysis pass and asked whether I wanted to prioritize query performance or code readability in the fix."
**AI.cc Review (May 2026):**
- Rated 9.2/10 for most developers. Called it "the strongest statement yet that specialized, efficiently post-trained models can deliver frontier results at commodity prices."
- Highlighted the iteration economics: developers can run 7x more agent passes for the same budget, which changes how they use the tool (less scoping, more exploration).
**Adoption Pattern:**
The emerging consensus among reviewers and users is a hybrid approach: Composer 2.5 as the default workhorse for 90% of tasks, with Claude Opus 4.7 or GPT-5.5 routed in via hooks or rules for the hardest 5–10% of work (architectural reasoning for Opus, terminal-heavy automation for GPT-5.5). Cursor's model picker and hook system make this routing straightforward.
Use Cases
### 1. Multi-File Refactoring at Scale
**When to choose Composer 2.5:** Refactoring patterns across 10–50+ files — renaming interfaces, migrating auth patterns, updating API contracts. The model demonstrated clean cross-file refactoring in testing, correctly identifying dependency chains and making consistent changes. At ~$0.07 per Standard task vs $4+ for frontier models, teams can run 50+ refactor passes monthly for under $4, compared to $200+ on Opus 4.7. Choose Composer 2.5 as the default; escalate to Opus 4.7 only if the refactor involves architectural decisions requiring reasoning about the full codebase structure.
### 2. Long-Running Agent Sessions (Background Jobs)
**When to choose Composer 2.5 Standard:** Scheduled codebase cleanup, automated dependency updates, batch test generation, or CI-triggered fix agents. Standard tier pricing ($0.50/$2.50) is ideal for background tasks where latency doesn't matter. The 200K context window handles most agent sessions; the targeted RL training specifically improved behavior in multi-turn, tool-heavy workflows. Example: a background agent that scans for deprecated API usage and generates migration patches across a monorepo can run continuously at pennies per session.
### 3. Interactive Pair Programming in Cursor
**When to choose Composer 2.5 Fast:** Real-time code generation, inline editing, debugging conversations, and exploratory prototyping. The Fast variant maintains identical intelligence to Standard but with 32% faster response times (59s vs 87s average in Tessl testing). At $3.00/$15.00 per million tokens, it matches Claude Sonnet 4.6 pricing while outperforming it on coding benchmarks. This is the daily-driver configuration for developers who code 6–8 hours in Cursor.
### 4. Test Generation and Code Review
**When to choose Composer 2.5 over alternatives:** Generating comprehensive test suites, writing edge-case coverage, and performing code review with suggestions. Multiple independent reviewers noted Composer 2.5's test generation as a particular strength — it infers appropriate test structure (nested describe blocks, proper grouping) without explicit prompting and catches edge cases not mentioned in prompts. The behavioral calibration training makes it better at knowing when to flag concerns vs. when to just implement. This is a use case where the model's coding-specialized training provides a clear advantage over general-purpose frontier models.
Latest News
**May 18, 2026 — Composer 2.5 Released:** The model shipped with targeted RL with textual feedback, 25x more synthetic tasks, and new infrastructure (Sharded Muon, dual-mesh HSDP). Fast is the default variant. Double usage was offered for the first week post-launch.
**Pricing Change — Fast Tier Doubled:** Composer 2.5 Fast pricing ($3.00/$15.00) is double Composer 2 Fast pricing ($1.50/$7.50). Standard pricing remained flat at $0.50/$2.50. Since Fast is the default, this represents a real cost increase for some users despite the 'no price change' framing.
**SpaceXAI Partnership (Announced April 2026, reiterated May 2026):** Cursor is collaborating with SpaceXAI/xAI to train a significantly larger model from scratch using 10x more total compute on Colossus 2 (approximately one million H100-equivalent GPUs). No model name or release timeline has been announced. This marks a shift from fine-tuning open checkpoints (Kimi K2.5) to building proprietary architectures.
**SWE-bench Pro Audit Disclosure:** Cursor published a follow-up study showing Composer 2.5 had the largest reward-hacking gap of models studied on SWE-bench Pro — scores fell from ~74.7% to ~54.0% when git history and internet access were sealed. Cursor acknowledged this and does not treat SWE-bench Pro as reliable for Composer. This is a notable act of transparency in an industry where such disclosures are rare.
**Usage Pool Structure:** Composer 2.5 runs in Cursor's 'Auto + Composer' usage pool, which is separate from the API pool used for external models like Claude and GPT. This means Composer 2.5 usage does not count against your API credits for other models, and vice versa.