Which LLM Does Cursor Use? (Not One — and the Seven You Pick From, Measured)

Cursor does not use one LLM. It routes across frontier models from several vendors, ships two of its own, lets you select a specific model in the picker, and lets you bring your own API key — that is what Cursor's documentation and pricing pages state, read 2026-08-08. Which means the question that actually pays rent is not which model Cursor uses. It is which one you should select. So here is the part nobody publishes: we ran seven of the models a Cursor user realistically picks between through our executed nine-task Python benchmark. All seven scored 9/9. The measured cost across them spans $0.08 to $14.70 per 1,000 tasks — 183.75x — and the latency spans 3.6 s to 10.8 s. Identical score, wildly different bill.

People ask which LLM Cursor uses expecting a single name. There is not one. Cursor is a model-agnostic editor: it exposes a picker, it ships an Auto routing mode that chooses for you, it publishes two of its own models, and it accepts your own provider API key. Every one of those four paths puts a different model behind your cursor.

So this page does two things. First, it reports exactly what Cursor's own pages state about the model menu, with the date we read them and a plain admission where those pages did not tell us enough. Second — and this is the part you cannot get from Cursor — it gives you our executed results for the models you are choosing between, so the picker stops being a guess.

The short answer

Cursor uses whichever model you select, or whichever one its Auto router picks if you leave the choice to it. As of Cursor's documentation read on 2026-08-08, the menu spans first-party Cursor models plus third-party frontier models from OpenAI, Anthropic, Google, Moonshot and Z.ai. There is no single engine underneath.

That has a consequence people miss. Two developers on the same Cursor plan, in the same repo, can be running models whose measured cost differs by 8.8x for identical results on bounded coding work — $1.67 to $14.70 per 1,000 tasks across the six frontier models in the table below. Point Cursor at an OpenAI-compatible endpoint for a model it does not list and the spread across all seven candidates reaches 183.75x. The tool is not the variable. The dropdown is.

What Cursor's own pages list, read 2026-08-08

Attributed to Cursor, not to us. We read three of their pages on 2026-08-08:

• cursor.com/docs/models — lists two first-party models, Cursor Grok 4.5 and Composer 2.5, alongside third-party models from OpenAI (GPT-5 series variants), Anthropic, Google, Moonshot (Kimi) and Z.ai (GLM). It states that Auto has three modes — Auto Cost, Auto Balance and Auto Intelligence — and that on Teams and Enterprise plans the Cursor Router picks the model per request according to the chosen optimization mode.
• cursor.com/help/models-and-usage/available-models — names specific entries including GPT-5.6 Sol, GPT-5.5, Claude Opus 5, Claude Fable 5 and a Gemini Pro entry, plus the Cursor first-party pair. It describes Auto as balancing intelligence, cost and reliability for everyday tasks.
• cursor.com/pricing — describes the paid individual tiers as including access to frontier models and generous limits for Grok and Composer. It does not enumerate models by name.

On billing, the docs page states that Auto Cost bills at a fixed per-million-token rate regardless of which model runs, while Auto Balance and Auto Intelligence bill at each model's API rate with an additional Cursor token-rate fee on third-party models. That is the mechanism that makes the cost table below your problem and not just ours: outside the fixed-rate mode, a chattier model is a bigger invoice, and reasoning tokens bill as output. We walk through the same arithmetic for agent loops in what AI agents actually cost and for seat-and-credit products in credit-based AI coding pricing.

The default we could not verify

Two further limits on what we can tell you, both worth stating rather than papering over:

• The two Cursor pages did not agree on granularity. The docs page describes third-party support by vendor family; the help page enumerates some specific version names and some generic ones (a plain Gemini Pro entry, for instance). So we cannot hand you a definitive, exact model menu, because Cursor's own two pages do not produce the same one.
• We have not verified any of it by running Cursor. Everything in the section above is read off Cursor's pages on 2026-08-08 and attributed to them. Our first-party evidence starts at the next section, and it is about the models, not about Cursor.

If you need the live list, the picker inside your own Cursor install is the only authoritative answer, and it will be more current than any article — including this one.

The seven models you are choosing between

Here is where we can add something. Because Cursor lets you choose, the useful question is which model to select — and we have executed most of the candidates on the same nine Python tasks, at temperature 0, with the code actually run against hidden assertions.

All seven scored 9/9. Rows ordered by measured cost, cheapest first.

The score column is a flat line. That is the finding, not a failure of the test: 33 of the 45 usable models we have run as of 2026-08-06 scored 9/9, so nine short, self-contained Python functions do not separate serious 2026 coding models on correctness. What they separate is money and time.

These seven are not the whole menu, and we are not going to pretend they are. Cursor's docs page names Moonshot and Z.ai as vendor families without pinning versions, and we have executed models from both: Kimi K2.7 Code at 9/9, $1.34 per 1k and 10.4 s (priced 2026-07-17), and GLM-5.2 at 9/9, $1.99 per 1k and 12.3 s (priced 2026-07-17). Claude Haiku 4.5 is another: 9/9, $0.94 per 1k, 3.7 s (priced 2026-07-29). They are out of the table because we cannot confirm from Cursor's pages which exact builds its picker exposes — not because they scored worse. They did not: all three tie the table at 9/9, and two of the three come in under its cheapest frontier row of $1.67. If your picker offers them, put them in the comparison.

Same 9/9, a 184x cost spread

$0.08 to $14.70 per 1,000 tasks is 183.75x, at an identical 9/9. Drop DeepSeek V3.2 — which Cursor does not list, and which is not one of the five providers its bring-your-own-key feature names, so reaching it means pointing Cursor at an OpenAI-compatible endpoint — and the spread across the six frontier picks is still 8.8x, from Claude Sonnet 5's $1.67 to Gemini 3.1 Pro's $14.70. Latency spreads 3.0x, from GPT-5.4 at 3.6 s to Gemini 3.1 Pro at 10.8 s.

The reasoning-token column explains most of the shape. Four of the seven emitted 0 reasoning tokens — DeepSeek V3.2, Claude Sonnet 5, GPT-5.4 and Claude Opus 4.8 — while Gemini 3.1 Pro spent 1,094 per task and still landed on the same 9/9. Reasoning bills at the output rate. On nine bounded function specs, that thinking bought nothing our scorer could see, and it is the single largest driver of the gap between $1.67 and $14.70. Across the whole set, 14 of the 45 usable models emitted 0 reasoning tokens.

Projected out at the measured rates, one thousand tasks of roughly this size per day works out to about $29 a year on DeepSeek V3.2, $610 on Claude Sonnet 5 and $5,366 on Gemini 3.1 Pro. Those are projections from our per-task figures at the stated prices, not bills anyone sent us. For your own token mix, the cost calculator does the arithmetic. The head-to-heads sit in Claude vs GPT-5 and GPT-5.4 vs GPT-5.5 — note that GPT-5.4 measured 5.2x cheaper and 2.9x faster than GPT-5.5 for the same 9/9, which is the most counter-intuitive row in the table.

What we have run against what Cursor names

Cursor names some models we have executed, some we have not, and one we had to exclude. Rather than quietly omit the gaps, here is the map.

The Claude Fable 5 row deserves a sentence, because it is the kind of thing benchmarks usually bury. Empty responses that arrive with a content-filter finish reason are not wrong answers, and scoring them as wrong would have manufactured a bad result out of an infrastructure event. We drop them from the denominator instead — the reasoning is in the content-filter scoring bug. One other model, Qwen3.5 397B, is excluded for a different reason: token_bucket came back empty with finish_reason=length because it exhausted our 4,000-token ceiling on reasoning without emitting an answer. That ceiling is our constraint, not a defect in the model.

Why these are a floor, not a Cursor ranking

That is uncomfortably close to the axis a Cursor user cares most about, and we are not going to fudge it. Treat this table as the cost floor and the correctness baseline, not as a ranking of Cursor performance. Concretely:

• The cost column is a floor. An agent turn carries the repo context, the tool definitions and the prior turns in its prompt. Real Cursor spend per unit of work is higher than these figures, in the same direction for every model — which is why the ratios travel better than the absolute dollars.
• The score column is a floor too. A model that cannot write a correct merge_intervals from a clean spec is not going to refactor your service layer. Passing 9/9 is a necessary condition, not a sufficient one.
• The reasoning-token column is the closest thing here to an agentic signal, and it is still not one. It tells you what a model spends when the task is easy. It does not tell you what it spends when the task is a 40-file monorepo.

For the axis we cannot test, the honest move is to look at how differently the field sorts under different criteria — the AI coding ranking — and at what agent harnesses do to token consumption, in cutting token costs in coding agents. Then measure on your own repo.

Bringing your own key changes the answer

Cursor's API-key help page, read 2026-08-08, states you can supply your own key for OpenAI, Anthropic, Google, Azure OpenAI and AWS Bedrock. Three limits it also states, all of which matter more than they look:

• Custom keys work with chat models only. Tab completion continues to use Cursor's built-in models regardless of what key you paste.
• Requests still route through Cursor's servers. The key is sent to Cursor's backend on every request because prompt assembly happens there.
• Zero Data Retention does not apply when you use your own key — data handling follows your chosen provider's terms instead.

The practical read: bring-your-own-key changes who bills you and widens the menu, but it does not turn Cursor into a thin client, and it does not extend to every surface in the editor. If your goal is specifically to run a model Cursor does not list — DeepSeek V3.2 at $0.08 per 1,000 tasks being the obvious candidate from our table — the setup path, the model ids and the agent-mode caveat are in how to use DeepSeek in Cursor, which is the how-to companion to this page. An OpenAI-compatible endpoint is what makes any of that possible.

How to actually pick

Start on the cheap end and escalate only when you watch it fail. On bounded, clearly specified code generation, our seven candidates are indistinguishable on correctness. Paying 8.8x inside the frontier tier for the same 9/9 is a decision you should have to justify, not a default.

If a human is waiting, buy latency, not tier. GPT-5.4 measured 3.6 s at $1.69 per 1,000 tasks — the fastest of these seven and 7.2 s per call quicker than Gemini 3.1 Pro, which measured 8.7x its cost for the same score. Speed and price are not the same axis as capability, and on this harness they were not correlated with it at all.

Reach for Opus-tier models for the work we did not test. Ambiguous specs, long context, multi-file refactors, sustained agent loops. Nothing in our data argues for or against them there — it just says that on bounded generation, the Sonnet-versus-Opus question resolves to Sonnet on cost every time.

Watch the reasoning-token column, not the sticker price. A model that thinks for 1,094 tokens per task on a trivial function will think harder on a hard one, and that bills at the output rate. Outside Cursor's fixed-rate Auto Cost mode, verbosity is your invoice. The cheap end of the field is mapped in the cheap coding model roundup.

Re-check the menu before you commit. Cursor's model list changes on a scale of weeks — that is precisely why we refused to print a definitive one above. Open the picker.

How these numbers were produced

Nine executed Python tasks: two_sum, valid_parentheses, merge_intervals, roman_to_int, lcs_len, flatten, top_k_words, token_bucket, parse_csv_line.

The model receives a function signature and a prose spec. It never sees the assertions. The returned code runs against hidden assertions in an isolated python3 -I subprocess with a 12-second timeout. Every assertion passes or the task fails — no partial credit, no human grader, no LLM judge.

Temperature 0, max_tokens 4000, no effort or thinking-budget parameter set. One scored attempt per task, retried only on an API error, never on a wrong answer. An empty response counts as an API failure and is dropped from the denominator rather than scored as wrong.

Cost is derived, not invoiced. It is the token counts the API reported multiplied by each model's list price on the date shown in the tables. Prices move between captures, so an undated cost figure is not a fact — recompute before you act on it, a habit we argue for in LLM price volatility.

Calls go through OpenRouter's OpenAI-compatible endpoint, deliberately not through the DataLLM Lab gateway. Nothing here depends on our infrastructure and you do not have to be our customer to reproduce it.

On the counting. The core sweep was 13 models run in one sitting. The rest ran later on the same harness under the same settings, bringing the set to 47 entries as of 2026-08-06, of which 45 are usable and 2 are excluded; 33 of the 45 scored 9/9. Where this page says 45 models, that is the combined set. The core sweep was and remains 13.

What we did not measure

Not measured at all: long-context reasoning, multi-file refactoring, agentic or multi-turn tool use, any non-Python language, vision, and anything run locally. The harness is single-turn, API-hosted and Python only. It does not run agents and it does not use tools.

We did not run Cursor. Every statement about Cursor's model menu, Auto modes, routing, billing and API-key support on this page is read off Cursor's own documentation and pricing pages on 2026-08-08 and attributed to them. We measured models, not the editor. No number here is a Cursor benchmark.

Cursor's first-party models are absent. Composer 2.5 and Cursor Grok 4.5 have never been through this harness, and our xAI Grok 4.5 result is not a stand-in for Cursor's branded variant.

A known scoring artefact: the 4,000-token ceiling can truncate a very verbose model mid-answer, and a truncated answer scores as a miss. That is our constraint, not a model defect. None of the seven models in the main table were affected — all scored 9/9.

Nine tasks is nine data points. A 9/9 is a clean result on this set, not a claim about a distribution. We did not run it twice, we did not vary the prompts, and we did not buy any model a retry.

FAQ