How to Use CursorBench When Picking a Model Inside Cursor

CursorBench 4.0 snapshot retrieved 1 October 2026: the public board shows Opus 5.5 Max at 57.8%, Opus 5.5 Extra High and High at 56.0%, and Sonnet 5.5 Max at 55.5%. These are Cursor configuration-specific correctness results, not a universal model ranking. The retrieved table did not include GPT-6.1 Sol.

When Cursor changes a default model, developers ask for a leaderboard. CursorBench is Cursor's answer — a first-party evaluation of models inside Cursor's agent loop, not a reproducible public harness you can run at home. The AI library mirrors Cursor's public table (score, cost, tokens, and steps, with a Cost / Tokens / Steps chart) on the CursorBench board. Use it to frame choices; confirm them on your repositories.

CursorBench 4.0 replaced 3.2 on 10 September 2026

Cursor released CursorBench 4.0 on 10 September 2026. It adds new long-horizon problems: edit, refactor, investigation, intent understanding, managing jobs, and design adherence. Vendors now quote 4.0. Anthropic used it for Claude Opus 5.5 and xAI for Grok 4.7. In the public board snapshot retrieved 1 October 2026, Opus 5.5 Max scored 57.8%, Opus 5.5 Extra High and High scored 56.0%, and Sonnet 5.5 Max scored 55.5%. These are configuration-specific scores inside Cursor's harness, not a cross-tool ranking. The captured table did not contain a GPT-6.1 Sol row.

Two rules follow:

• Do not compare 3.x and 4.0 scores. The task set changed, and 4.0's long-horizon tasks are harder. If a model scores lower on 4.0 than it did on 3.2, that does not mean it got worse.
• Check which version the board shows. The site's board states its version and mirror date in its coverage note. If it still shows 3.2, use Cursor's live page for 4.0 rankings and treat the mirror as history.

What CursorBench measures — and what it does not

The benchmark snapshot on this site documents:

• Primary axis shown: correctness on ambiguous multi-file IDE agent work drawn from real Cursor sessions.
• Publisher: Cursor (first-party), updated on the board's updatedAt field.
• Coverage note: Cursor also evaluates quality, efficiency, and interaction, and runs online traffic experiments — those axes are not fully ranked on the public board transcribed here.

The companion Cursor eval axes page explains the multi-axis system without inventing a second leaderboard. Efficiency and interaction scores stay on Cursor's side of the wall unless they publish a downloadable ranking.

That scope matters. A model that ranks highly on CursorBench is a candidate default for Cursor's agent surface. It is not automatically the best model for raw API chat, terminal agents, or batch jobs outside the IDE loop.

How to read the catalogued shortlist

The CursorBench board mirrors the full public table from cursor.com/cursorbench (see the board's coverage note for the mirror date), including reasoning tiers and Cursor-only rows such as Composer. A separate correctness-only shortlist is no longer the board UX — use the chart toggles and the single table.

Two editorial cautions ship with the data:

1. Training-data disclosures — treat a rank as directional when Cursor publishes a row-level training-data note.
2. Mid-table gaps — treat ordering between closely spaced scores as noise until you replay tasks locally.

Link each row to its model profile for verified pricing, context, and verifiedAt before you change spend.

A practical model-pick workflow inside Cursor

Step 1 — Start from the board, not from memory. Open CursorBench and note which catalogued models cluster at the top for correctness. Cross-check the Cursor harness profile for pricing model and editor-switch requirements.

Step 2 — Match model tier to task class. Frontier models on the board may be overspecified for completion-heavy days. Budget tiers may fail on long-horizon agent tasks. The OpenAI tier guide applies when you route OpenAI models inside Cursor. Pin full model IDs, especially now that GPT-6 Sol and Luna sit beside the GPT-5.6 versions. Also compare cost per task, not just score: on the 4.0 table, Opus 5.5 at Medium effort scored 52.5% at $2.91 per task, while its Max row scored 57.8% at $13.43.

Step 3 — Replay three real tasks. Small bug, cross-file feature, dependency migration. Measure review time and steering turns. The best AI for coding guide recommends this protocol for any harness; CursorBench does not replace it.

Step 4 — Check online product changes separately. Cursor's post describes online evals tied to product metrics inside Cursor. Those are not transcribed as a public leaderboard here. If a default model changes, read Cursor's announcement and rerun your repo trials.

When not to use CursorBench

• Choosing between Cursor and a terminal agent — compare harnesses on the AI harnesses index and switch guides like Cursor vs Muse Code, not CursorBench alone.
• API-only workloads — use model profiles and cross-provider comparisons on /ai-models, or boards with explicit public harnesses on /ai-models/benchmarks.
• Team procurement — mixed-editor teams may standardise on GitHub Copilot regardless of CursorBench; editor coverage beats an IDE-only eval.

Where the library fits together

CursorBench is a useful inside-Cursor shortlist. The pick that sticks is still the one that passes your tests, stays within budget at your concurrency, and survives week-four retention — not the top row on a vendor-run board copied into a blog post.

Sources

• Cursor, CursorBench (public table and changelog; CursorBench 4.0 released 2026-09-10; 3.2 released 2026-07-08). https://cursor.com/cursorbench — retrieved 2026-10-01.
• Anthropic, Introducing Claude Opus 5.5 (quotes CursorBench 4.0). https://www.anthropic.com/claude-opus-5-5 — accessed 2026-09-26.
• xAI, Introducing Grok 4.7 (quotes CursorBench 4.0). https://x.ai/news/grok-4-7 — accessed 2026-09-26.
• Cursor, More about CursorBench (methodology post). https://cursor.com/blog/cursorbench — accessed 2026-08-29.

The published table includes reasoning tiers and Cursor-only rows (for example, Composer); efficiency and interaction scores are not fully ranked on the public table. Treat the cost-per-task figures and ordering between closely spaced scores as directional until you replay representative tasks against your own repositories.