Cursor Composer 2.5 Pricing: What a Real Session Actually Costs You
Composer 2.5 standard tier runs 10x cheaper per token than Opus 4.7, but Cursor defaults to Fast tier—here's what your refactor jobs will actually cost.
We’ve been tracking Composer 2.5 since launch, and the pricing structure is deceptive in exactly one way: the standard tier costs $0.50 per million input tokens and $2.50 per million output—roughly 10x cheaper than Opus 4.7 on input, 30x on output. The catch is that Cursor ships Fast tier as the default for real-time sessions, which costs $3.00 input and $15.00 output. Most users never realize they’re paying the premium until the bill lands.
The Two-Tier Reality
Cursor released Composer 2.5 on May 18, 2026, and the pricing table is stark:
| Tier | Input | Output |
|---|---|---|
| Standard | $0.50/M | $2.50/M |
| Fast | $3.00/M | $15.00/M |
Standard is the cost-conscious pick for background agents, batch jobs, and CI workflows. Fast is what the Cursor IDE defaults to when you open an interactive session—lower latency, same intelligence. According to Lushbinary’s breakdown, the Fast tier is “the default inside the product,” which means unless you manually flip the switch in settings, every session you spin up is burning Fast-tier tokens.
The UI does show which tier you’re on, but it’s easy to miss if you’re in flow state. Check the Composer panel in your Cursor sidebar—if it doesn’t explicitly say “Standard,” you’re on Fast.
Real Math: A 200-Line Refactor
We ran the numbers on a typical refactor job—say, pulling out a helper module from a 200-line component—and the token spread is where the real cost difference lives:
- Your prompt + context files: ~8,000 input tokens
- Composer’s planning, file reads, and edits: ~12,000 output tokens
- Total: 20,000 tokens consumed
On Standard tier: (8K × $0.50 + 12K × $2.50) / 1,000,000 = $0.04 per session.
On Fast tier: (8K × $3.00 + 12K × $15.00) / 1,000,000 = $0.204 per session.
That’s $0.16 difference per refactor. Doesn’t sound like much until you run 50 in a sprint—then it’s $8 versus $1. The problem scales harder on longer sessions. A multi-file rewrite (30K output tokens) on Fast tier climbs to $0.51 per session.
Where Composer 2.5 Actually Wins
Composer 2.5 benchmarks at 79.8% on SWE-Bench Multilingual—within 0.7 points of Opus 4.7’s 80.5%. On the more real-world CursorBench v3.1 (multi-file, underspecified tasks), it scores 63.2%. We didn’t expect the performance gap to be this thin at the price delta Cursor shipped. The pricing advantage isn’t a temporary promo—it’s baked into the model’s efficiency. Cursor built Composer 2.5 on Moonshot’s open-source Kimi K2.5 checkpoint and post-trained it with 25 times more synthetic tasks than Composer 2. You’re not paying for the same compute; you’re paying for a smaller, better-trained model.
The Trap Nobody Talks About
Here’s where the math breaks. Longer planning horizons mean more output tokens. A “cheap per token” model can still rack up a huge session bill if Composer keeps the context window long to reason through multi-file refactors.
According to analysis from mer.vin, longer horizons can increase cumulative token spend even when per-step quality improves. A complex refactor that spans four files might generate 40K output tokens (Composer thinking through the whole graph), and at Fast tier that’s $0.60 per session. Scale that across a team’s daily work, and the “cheap model” becomes expensive.
Our recommendation: Use Standard for exploration and drafting. Switch to Fast for the final, ship-critical pass where latency matters and you’ve already verified the approach works.
Who Should Switch Now
If you’re already on a Pro plan (includes Composer access), check the plan details at the pricing breakdown to see if Composer 2.5 is available in your tier. Most Pro and above have immediate access.
Switch to Composer 2.5 immediately if:
- You run 10+ coding tasks per week and currently pay per-token for Claude Opus.
- You’ve benchmarked Opus 4.7’s performance and found it overkill for your work.
- You’re in Standard tier and want to keep Fast for latency-critical passes only.
Wait for your own eval data if:
- You’re using Composer 2.0 and hitting acceptable latency on your current tasks.
- Your team hasn’t profiled token spend across session types yet.
- You want to see real-world CursorBench scores from teams in your domain before migrating.
Our take: the pricing is real. The performance gap is real. The only variable is whether Fast tier’s latency matters more to you than Standard’s cost. Run the math on your own sessions, and then decide.
Sources:
What we don't know is documented at the end of this article. We update when we learn more.