Cursor Composer 2.5: Benchmarks, Pricing, and How It Compares to Claude Opus 4.7 and GPT‑5.5

What Composer 2.5 Is Designed For

Composer models are optimized for agentic software engineering, meaning the AI is expected to perform multi‑step development workflows rather than just produce short code snippets. Tasks can include planning changes across a codebase, editing multiple files, compiling code, and debugging through iterative test runs.

Compared with earlier versions, Composer 2.5 improves reliability on long‑running tasks, follows complex instructions more consistently, and behaves more cooperatively during collaborative development sessions inside the IDE.

This focus reflects a broader shift in AI coding tools—from simple autocomplete or snippet generation to persistent agents that can execute full development workflows.

Benchmark Performance vs. Opus 4.7 and GPT‑5.5

Cursor reports several benchmark results that place Composer 2.5 within the same general performance tier as leading frontier models.

Key reported scores include:

• SWE‑Bench Multilingual: 79.8% (Composer 2.5), 80.5% (Claude Opus 4.7), 77.8% (GPT‑5.5)
• Terminal‑Bench 2.0: 69.3% (Composer 2.5), 69.4% (Claude Opus 4.7), 82.7% (GPT‑5.5)
• CursorBench v3.1: 63.2% (Composer 2.5)

These results suggest a nuanced picture:

• On SWE‑Bench Multilingual, which measures an AI’s ability to fix real GitHub issues across languages, Composer 2.5 performs roughly at frontier level and slightly ahead of GPT‑5.5 in the reported comparison.
• On Terminal‑Bench 2.0, designed to evaluate agent performance in terminal environments, Composer 2.5 performs almost identically to Claude Opus 4.7 but trails GPT‑5.5 by a substantial margin.
• Compared with the previous generation, Composer 2.5 shows large improvements—for example rising from 73.7% to 79.8% on SWE‑Bench Multilingual.

Overall, the benchmarks suggest Composer 2.5 is competitive with top models on some software engineering tasks, though it does not consistently outperform them across all agent evaluations.

Why the Pricing Is So Disruptive

The most striking aspect of the release is pricing.

Composer 2.5 is priced at approximately:

• $0.50 per million input tokens
• $2.50 per million output tokens

A faster variant is available at $3.00 per million input tokens and $15.00 per million output tokens, still competitive with fast tiers from other frontier models.

For comparison, some reports estimate that Claude Opus models can cost around $5 per million input tokens and $25 per million output tokens, meaning the standard Composer tier can be dramatically cheaper—particularly for output tokens.

This matters because agentic coding workflows consume very large numbers of tokens. A single task might involve repository search, planning steps, editing code, compiling, and executing tests, each triggering additional model calls.

Lower token prices allow Cursor to run many more reasoning steps per task without dramatically increasing costs.

What the Model Is Built On

Composer 2.5 builds on Moonshot AI’s Kimi K2.5 open‑weight checkpoint, which Cursor then extends through additional training tailored to software engineering tasks.

Reports about the training approach indicate that the model used:

• About 25× more synthetic coding tasks than the previous generation
• A training process where roughly 85% of compute was devoted to additional training and reinforcement learning, rather than relying primarily on the base checkpoint.

Synthetic tasks allow the model to repeatedly practice structured development workflows—planning edits, modifying code, running tests, and iterating—helping improve reliability on real engineering problems.

Why This Release Matters for Cursor’s Strategy

Composer 2.5 also reflects a broader strategic shift inside Cursor.

Early versions of the IDE relied heavily on external AI providers such as OpenAI, Anthropic, and Google to power coding features. Developing competitive in‑house models changes that dynamic.

Owning more of the model stack provides several advantages:

• Lower inference costs for long‑running coding agents
• Reduced dependence on external model providers
• Greater control over model behavior within the IDE

This is especially important as competitors like Anthropic’s Claude Code benefit from tight integration between the underlying model and the coding agent itself.

By developing its own Composer models, Cursor is attempting to compete more directly in that integrated model‑plus‑tool category rather than simply routing requests to third‑party AI systems.

The Bottom Line

Composer 2.5 does not clearly dominate the frontier across all benchmarks. GPT‑5.5 still leads in some agent evaluations, and Claude Opus 4.7 remains highly competitive.

What makes the model notable is the combination of near‑frontier coding performance and dramatically lower cost. If Cursor continues improving its in‑house models while maintaining this pricing advantage, it could significantly shift the economics of AI‑assisted software development—especially for long‑running coding agents operating directly inside the IDE.