Cursor vs Copilot

Short answer: the capability gap that made this an interesting question has largely closed, and what separates them in 2026 is billing and breadth. Copilot has agent mode. Both edit across many files, both run background agents, both route to frontier models from more than one lab. If you are picking between them on a feature grid, you are answering a 2024 question.

What survives is structural. Copilot spans a dozen editors and a CLI under one subscription and arrives through procurement; Cursor is one editor and the whole company's product. Both also rewrote how they charge you this year, badly enough that the practical advice comes first — find the spending control before you turn on agent mode, because on one of these the docs say where it is and on the other they don't.

What stopped being different

For a couple of years the honest version of this comparison was short: Copilot completed lines, Cursor did the agentic work. That is no longer the shape of it.

As of 2026-07-31, GitHub's product page describes Copilot editing files in your workspace in agent mode, plus cloud agents that "plan, explore, and execute work autonomously in the background." Copilot code review works on pull requests, and Copilot CLI ships on every tier including Free. Model choice has converged too: Copilot's pricing page names Claude Haiku 4.5 and GPT-5 mini on the free tier and Opus on Pro+, while Cursor runs two pools — first-party Cursor Models (Grok 4.5, Composer 2.5) and an Other Models pool of third-party frontier models at their API rate. Neither is a single-lab product any more.

The residual differences are real but small, and they move monthly — worth an afternoon of trying both, not worth reading about.

What each actually charges

Both moved to consumption pricing, and this is where the decision lives. As of 2026-07-31.

Headline prices favour Copilot at every tier, and that is close to meaningless, because the subscription is no longer what you pay. Copilot Pro includes 1,500 monthly AI credits, Pro+ 7,000, Max 20,000. Cursor Pro includes $20 of the Other Models pool, Pro Plus $70, Ultra $400. Neither carries over — GitHub's docs are blunt that "Included AI credits do not carry over between months," resetting 00:00:00 UTC on the first.

The change that caused this year's noise is GitHub's. On 2026-06-01 Copilot stopped counting Premium Request Units and began billing on tokens consumed — input, output and cached — at each model's published API rate: "As of June 1, all Copilot plans bill based on GitHub AI Credits consumed." Subscription prices did not move; what moved was the relationship between a prompt and its cost. Agent-mode sessions consume far more than chat, because the agent's tool calls, subagents and context compaction all draw the same pool. Under the old scheme a prompt was a prompt.

Users noticed within a day. From the community thread opened that morning and locked two days later:

One prompt to Claude Sonnet 4.6 consumed around 40% of my monthly limit.

In just two days of usage, I have already used around 50% of my monthly quota, which feels unfair.

Aggregator posts cite specific invoice jumps — $29 becoming $750 is the figure that circulates — but we could not trace any to a primary source, so we don't repeat them as fact. Cursor's history is not cleaner, only quieter: it has moved between fixed request counts and shared credit pools more than once, and its docs still describe Max Mode as "available only on legacy request-based plans." Cost comparisons between them are unreliable because the articles describe different billing eras.

Where the spending cap is

This is where the popular summary is wrong. The common claim is that GitHub had no spending cap until 2026-07-02. The record is more specific, and the details change what you should do.

For an individual Copilot subscriber, overage is opt-in. When included credits run out you are not silently billed — GitHub's docs say you continue "by setting a budget for additional usage," where "a $10 budget covers 1,000 AI credits." Set none and you stop until the month resets, though completions keep working. The individual failure mode is a dead assistant on the 12th, not a surprise invoice.

For organisations it inverts, and that is the actual trap. User-level budgets went generally available on 2026-06-01 and are strict — GitHub's docs say they "always enforce a hard stop; there is no option to allow usage to continue beyond the limit." But cost-center, organisation and enterprise budgets cap metered charges only, and the setting that stops usage at the limit is "off by default," with the docs adding that "Without it, charges continue to accrue past the limit."

Two later changes get collapsed into one. On 2026-07-01 GitHub shipped per-session limits in Copilot CLI and SDK — "cap the amount an agent spends in a session," counted "across the entire session, including model calls, subagents, and background work like compaction," via /limits or --max-ai-credits, needing CLI 1.0.66+ and SDK 1.0.5+. These are explicitly soft caps: an in-flight response finishes, so "actual usage may slightly exceed the number you set." On 2026-07-02 came included-usage caps for cost centers — enterprise governance on Business and Enterprise, REST API only at announcement, not a general spending cap.

Cursor is harder to advise on, because there is less to read. Its pricing page and pricing docs, read on 2026-07-31, describe what happens when included usage runs out — on-demand usage "billed in arrears" at "the same API rates with pay-as-you-go billing" — but neither documents a user-settable cap or a toggle to refuse overage. They offer sizing guidance instead: daily agent users "Typically $60–$100/mo total usage," power users "Often $200+/mo total usage." Treat that as the real price, and check your dashboard rather than assuming a limit exists.

Breadth: one editor against one subscription

The second surviving difference is shape, and for organisations it usually decides the question first.

Copilot is not an editor. It is a subscription that follows you across surfaces: GitHub itself, Visual Studio, VS Code, Xcode, JetBrains, Neovim, Eclipse and Raycast, plus Vim, Azure Data Studio, GitHub Mobile and the CLI. One caveat — GitHub's FAQ notes that Copilot Chat "is currently available only in Visual Studio Code, JetBrains, and Visual Studio," so breadth of installation exceeds breadth of the conversational features. Still, if you have iOS developers in Xcode, backend developers in IntelliJ and everyone else in VS Code, one line item covers all of them.

Cursor is one editor — a full fork of VS Code, which is its own strength: extensions, keybindings and themes transfer, and the product has the entire company's attention. But adopting it means adopting an editor, a bigger move than adding a plugin, and your JetBrains and Xcode people aren't covered at all. Procurement matters too: Copilot arrives through a vendor most enterprises already contract with, carrying IP indemnity, audit logs and access control on the Business and Enterprise tiers, while Cursor is a new vendor to onboard. Neither fact says anything about which produces better code; both decide real evaluations.

Your own keys, and what they don't cover

Cursor accepts API keys from OpenAI, Anthropic, Google, Azure OpenAI and AWS Bedrock. The scope is narrower than the feature list suggests, and Cursor's docs say so: "Custom API keys only work with chat models. Tab completion continues using Cursor's built-in models." Apply and the agent aren't listed as supported anywhere on that page.

That matters because of which operations cost money. If you want your own key for cost control, the agent is where the spend is, and chat-only doesn't reach it. If you want it for compliance, note the second catch: "Cursor's Zero Data Retention policy does not apply when you use your own API keys," and requests still route through Cursor's servers for prompt construction. Copilot doesn't offer bring-your-own-key on the plans above at all. For the expensive work, a chat-only key path and no key path differ by close to nothing. If full BYOK is a hard requirement, the answer here is neither — see Cursor vs Claude Code.

How to actually choose

Capability being roughly a wash, the tiebreakers that hold up:

• You work across more than one IDE, or your team does. Copilot. The clearest case on the page, and it isn't close — Cursor is one editor by design.
• You want the editor itself to be better. Cursor. It is the whole product rather than a layer, and a fork can change things a plugin cannot reach.
• You want Claude Code and Codex under a seat you already pay for. Copilot Pro and above bundle them; our Codex vs Claude Code page covers what you'd be getting.
• You need enforceable limits before agents run unattended. Copilot documents them — user-level budgets that hard-stop, and per-session CLI caps since 2026-07-01. Cursor's public docs don't describe an equivalent.
• Procurement, indemnity and audit logs are part of the decision. Copilot, and that evaluation is probably shorter than the technical one.

Whichever way it lands, do the same first thing: run one realistic agent task — a multi-file change with tests, not a chat message — then look at what it consumed. That number tells you more about your annual cost than every price in the table above, because on both products the subscription is now a deposit.

Sources

Prices, billing mechanics and quotations were read from vendor pages on 2026-07-31. Every URL below returned HTTP 200 that day. This category re-prices often; verify before committing budget.

• GitHub — Copilot plans and features · GitHub Docs — Copilot features
• GitHub Changelog — Updates to Copilot billing and plans (2026-06-01) · GitHub Blog — Copilot is moving to usage-based billing
• GitHub Docs — Usage-based billing for individuals · GitHub Docs — Budgets for usage-based billing
• GitHub Changelog — AI credit session limits in Copilot CLI and SDK (2026-07-01) · GitHub Changelog — Included usage caps for cost centers (2026-07-02)
• GitHub Community discussion #197702 — the two quoted reports, posted 2026-06-01 and 2026-06-03
• cursor.com/pricing · Cursor Docs — pricing and usage pools · Cursor — API keys and what BYOK covers

Not affiliated with GitHub, Microsoft or Anysphere. If something here is wrong or has gone stale, tell us and we'll fix it.