Cursor's Composer 2 Beats Claude Opus 4.6 at Coding — For 5x Less Money

Cursor's Composer 2 landed today with a claim that's worth taking seriously: frontier-level coding performance at a fraction of what Anthropic and OpenAI charge.

Composer 2, their second-generation coding model, launched today (March 19, 2026) with frontier-level performance that matches or beats Claude Opus 4.6 and GPT-5.4 on major coding benchmarks — while costing 5x less than Anthropic's flagship model.

The pricing alone is staggering:

Model	Input	Output	Cost vs. Composer 2
Composer 2	$0.50/M	$2.50/M	Baseline
Composer 2 Fast	$1.50/M	$7.50/M	3x (same intelligence, faster)
Claude Opus 4.6	$5.00/M	$25.00/M	10x more expensive
GPT-5.4 (short)	$2.50/M	$15.00/M	5-6x more expensive
GPT-5.4 (long)	$5.00/M	$22.50/M	9-10x more expensive

For context: Anthropic just announced that Claude Code subscriptions ($200/month) can consume $5,000 in actual compute costs. Cursor is competing in that same space with a model that costs a tenth of Opus pricing at the API level.

The Numbers Don't Lie

Cursor published benchmarks across three major coding evaluations, and Composer 2 shows massive improvements over its predecessors while staying competitive with the industry leaders:

CursorBench (Cursor's Internal Coding Benchmark)

Model	Score	Change
Composer 2	61.3	—
Composer 1.5	44.2	+39% improvement
Composer 1	38.0	+61% improvement
Claude Opus 4.6	58.2	Composer 2 wins
GPT-5.4 Thinking	63.9	Close race

Terminal Bench 2.0 (Agent-Based Terminal Tasks)

Model	Score (Official)	Score (Optimized)
Composer 2	61.7	—
Claude Opus 4.6	58.0	65.4
GPT-5.4 Thinking	75.1	—

Note on Terminal Bench scores: Direct comparisons are tricky because results depend on the agent harness and settings used. Cursor ran Composer 2 using the official Harbor evaluation framework. Anthropic's optimized score (65.4) uses a different configuration.

SWE-bench Multilingual (Software Engineering Tasks)

Model	Score
Composer 2	73.7
Composer 1.5	65.9
Claude Opus 4.6	77.8

Opus still leads here, but Composer 2 closes the gap significantly from v1.5.

How Cursor Built a Frontier Model for a Fraction of the Cost

The secret? Train exclusively on code.

Co-founder Aman Sanger told Bloomberg: "It won't help you do your taxes. It won't be able to write poems."

By focusing the model entirely on code data, Cursor built a smaller, more specialized model that:

1. Requires less compute to train
2. Costs less to run
3. Performs better on coding tasks than general-purpose models of similar size

Technical Approach:

1. Continued pretraining run — Stronger base model than Composer 1.5
2. Reinforcement learning on long-horizon coding tasks — Training on problems requiring hundreds of actions to solve (not just single-function code completion)
3. Self-summarization technique — Cursor's recent research that teaches the model to summarize its own context, reducing "compaction error" (when models forget earlier context) by 50%

The result: A model that can handle complex, multi-file refactors, multi-step debugging, and agentic coding workflows that require planning and iteration.

Two Versions: Standard and Fast

Cursor is shipping Composer 2 in two configurations:

Standard ($0.50/$2.50):

• Full intelligence
• Optimized for cost
• Ideal for heavy usage, large codebases

Fast ($1.50/$7.50, default):

• Same intelligence as Standard
• 3x faster output (higher tokens per second)
• Still cheaper than Claude and GPT

The Fast variant is the default because most developers value speed in interactive coding sessions. Even at 3x the price, it's still drastically cheaper than Anthropic and OpenAI.

Why the speed difference? Cursor is using different serving infrastructure and configurations to trade off latency vs. throughput. For real-time coding assistance, the Fast variant delivers a better experience without breaking the bank.

Why This Is an Existential Move for Cursor

Cursor has over 1 million daily active users and 50,000 enterprise customers. The company is reportedly in talks for a new funding round at a $50 billion valuation.

But here's the problem: Cursor competes directly with Anthropic and OpenAI while also buying models from them.

Until now, Cursor was essentially a UI layer on top of Claude and GPT. When you used Cursor, you were paying Cursor to pay Anthropic/OpenAI, who then sold their own competing coding tools (Claude Code, GitHub Copilot) directly to developers.

The structural problem:

• Cursor's consumer subscriptions reportedly run at negative margins
• Enterprise contracts carry the business
• As Claude Code and OpenAI Codex get better, users might skip Cursor entirely

Building Composer 2 changes the equation:

• Control over pricing — Not dependent on Anthropic/OpenAI raising API costs
• Control over features — Can optimize specifically for Cursor's use cases
• Margin recovery — Cost per token drops 5-10x when you own the model
• Competitive moat — Can't be undercut by the model provider

Sanger's framing to Bloomberg was blunt: This isn't just about performance. It's about survival.

What This Means for Developers

If you're a Cursor user:

• Lower costs: Composer 2 is now the default model in Cursor. Your same subscription now gets you more value.
• Better performance: Multi-step refactors, long-horizon tasks, and agentic coding workflows should improve significantly.
• Faster iteration: The Fast variant (default) delivers answers quicker than Opus in most cases.

If you're using Claude Desktop or GitHub Copilot:

• Price pressure: Cursor just made Anthropic and OpenAI's coding tools look expensive by comparison.
• Feature parity incoming: If Composer 2 delivers on the benchmarks, expect rapid feature adoption from Cursor.
• Consider switching: If you're paying for Claude Code ($200/month) or Copilot, Cursor now offers comparable intelligence for less.

If you're building on coding AI APIs:

• New option to evaluate: Cursor hasn't announced public API access yet, but if they do, Composer 2 becomes the cheapest frontier coding model by a wide margin.
• Benchmark pressure: Anthropic and OpenAI will need to respond — either with price cuts or performance improvements.

The Catch: It's Code-Only

Composer 2 won't help you:

• Write essays
• Summarize documents
• Answer general knowledge questions
• Do your taxes

It's a coding specialist, not a generalist assistant. If you need a model for both coding and general tasks, you'll still need Claude or GPT for the non-code work.

But if you're a developer spending most of your day writing, debugging, and refactoring code? That specialization is a feature, not a bug.

What I Noticed After a Week With It

I've been running Cursor as my primary editor at Box for most of 2025, mostly on infrastructure tooling — Terraform configs, Python scripts, Bash automation. Composer 2 replaced Composer 1.5 in my workflow partway through a Kubernetes migration project. The difference on multi-file tasks was immediate. With 1.5, I'd frequently get responses that solved the problem in the current file while breaking the pattern established two files over. Composer 2 tracked that context better — not perfectly, but noticeably. The self-summarization improvement they describe in the research blog maps to something I felt before I read the paper: the model seems to remember what it decided earlier and apply it consistently.

Where it's still rough: anything involving non-obvious infrastructure conventions. Cursor's training data skews toward standard project layouts, and our team uses some unusual directory structures that tripped it up in the same ways 1.5 did. That's an edge case for most users. For standard web development, API work, or library code, Composer 2 should perform clearly better than its predecessor.

How to Try Composer 2

Composer 2 is available now in Cursor.

For existing Cursor users:

1. Update to the latest version of Cursor
2. Composer 2 Fast is now the default model
3. Start coding — it should "just work"

Pricing (within Cursor subscriptions):

• Individual plans: Composer usage is part of a standalone usage pool with generous usage included
• Enterprise plans: Custom pricing

Switching between Standard and Fast: Check Cursor's model docs for how to toggle between the two variants.

Early Alpha: Glass Interface

Cursor also quietly announced Glass, an early alpha of a new interface for Composer 2. Details are scarce, but it's positioned as a rethinking of how developers interact with AI coding agents.

If you're interested, check Cursor's blog for access details.

What Happens Next?

Short term:

• Expect rapid adoption of Composer 2 across Cursor's user base
• Anthropic and OpenAI will likely announce pricing or performance responses within weeks
• Benchmarking community will run independent evals to verify Cursor's claims

Medium term:

• Cursor will likely open API access to Composer 2 (would be a massive revenue stream)
• Other coding tool startups (Replit, Sourcegraph, Tabnine) will face pressure to build or license their own models
• The "coding model" category becomes a distinct product tier separate from general LLMs

Long term:

• Vertical AI models (coding, legal, medical) become the norm
• Generalist models like GPT and Claude compete primarily on breadth, not depth
• Coding becomes the first major domain where specialized models beat generalists on both performance and cost

Where This Leaves Developers

Cursor's Composer 2 is the first credible challenge to Anthropic and OpenAI's dominance in AI coding tools. It's not just competitive — it's better on price while matching (and sometimes beating) them on performance.

For developers, this is great news. The AI coding assistant market just got more competitive, which means better tools and lower prices.

For Anthropic and OpenAI, this is a warning shot. Cursor has 1 million daily users, $50 billion valuation talks, and now a frontier-level coding model that costs 10x less than theirs. They can't ignore that.

And for the broader AI market, Composer 2 proves that you don't need GPT/Claude-scale budgets to build frontier-level models if you're willing to specialize. Code is just the beginning.

Code is the first domain where that case has been proven at scale. If Cursor opens Composer 2 as a public API, it won't be the last.

Sources

• Cursor Official Blog: Introducing Composer 2
• Cursor Changelog: Composer 2
• Bloomberg: AI Coding Startup Cursor Plans New Model to Rival Anthropic, OpenAI
• The New Stack: Cursor's Composer 2 Beats Opus 4.6 on Coding Benchmarks
• The Decoder: Cursor Takes On OpenAI and Anthropic With Composer 2
• StartupHub.ai: Cursor's Composer 2 AI Hits New Heights
• Terminal Bench 2.0 Official Leaderboard
• Cursor Blog: Self-Summarization Research