AI Coding Agents: What to Use for What — Selection Criteria Verified Only Against the Four Vendors' Official Docs

• Introduction — Answering "Which Is Cheapest" First
• What Each of the Four Tools Says It Is
• Why the Four Prices Can't Be Lined Up Side by Side
• So How Far Does It Reconcile — the Parts I Confirmed with Arithmetic
• Only Anthropic Publishes Actual Observed Cost
• There Is No Shared Benchmark — and That's the Point of This Post
• The Four Are Not Mutually Exclusive
• So What to Use for What — the Decision Rule
• When You Should Not Trust This Post
• Closing
• References

Introduction — Answering "Which Is Cheapest" First

When you pick an AI coding agent, two questions come up more than any others: "which one should I use" and "which one is cheapest."

Let me take the second one first. The prices each vendor publishes are not enough to answer it. The reason: all four sell usage in different units, and the units do not convert into one another. Anthropic sells a multiple — "5x or 20x Pro." Cursor sells a dollar amount — "this much included API usage." GitHub sells credits where "1 credit = 1 cent." OpenAI sells "this many per-model messages per 5 hours." These are not different price tags on the same object; they are four rulers with different gradations to begin with.

The answer to the first question is more interesting. These four are not mutually exclusive options. Anthropic's docs say Claude Code runs in "VS Code, Cursor and other VS Code forks, and JetBrains," and GitHub's docs list Anthropic Claude and OpenAI Codex as third-party coding agents you can run on top of GitHub (public preview). In other words, "Cursor or Claude Code" is, to a large degree, a badly framed question — because running Claude Code inside Cursor is a supported configuration.

So this post is not about "which vendor wins." Instead it builds a decision rule around one axis — where the work starts — using only facts confirmed in each product's own primary docs. Every number below was checked directly against each vendor's official documentation as of July 17, 2026, and where something could not be confirmed, I say so.

Let me also point to the neighboring posts up front. How to use these tools (the habits) is covered in Five Habits for Working Well with AI Coding Tools; whether they actually make you faster (measuring productivity) in Does AI Actually Make Developers Faster; and whether you can trust benchmark scores in Separating Signal from Noise When You Evaluate AI Coding Models. This post looks only at the one spot those three do not touch — the concrete tool choice.

What Each of the Four Tools Says It Is

The starting point for a comparison should be each tool's own self-description, not someone else's verdict. Here are the vendors' own words, carried over as-is.

Claude Code (Anthropic). The first line of the official docs calls it "an agentic coding tool that reads your codebase, edits files, runs commands, and integrates with your development tools," and says it is "available in the terminal, IDE, desktop app, and browser." The platform docs go one step further — "Claude Code runs on the same engine everywhere, but each surface is tuned for a different way of working." And the vendor itself splits the surfaces by purpose: the CLI is for "terminal workflows, scripting, and remote servers," the Agent SDK is CLI-only, and the web is for "long-running tasks that need little steering, or work that should keep going even when you are offline."

Cursor (Anysphere). The models-and-pricing doc opens with "Cursor supports frontier models from OpenAI, Anthropic, Google, SpaceXAI, and others." That is, Cursor defines itself not as a model provider but as the place where you choose a model. It does have its own models, though — Composer 2.5 is "Cursor's own model, trained to be highly capable at agentic coding," and Grok 4.5 is a model "co-trained by Cursor and SpaceXAI for long-running coding and knowledge work." And it is no longer just an IDE — the product docs now cover Agent, Cloud, CLI, Mobile, Automations, Review (Bugbot), Tab, and Marketplace.

GitHub Copilot. The cloud-agent doc writes: "it investigates the repository, forms an implementation plan, and makes code changes on a branch. You review the diff, iterate, and open a pull request when it is ready." Every entry point belongs to GitHub — the Agents tab, assigning an issue, mentioning @copilot in a comment on an existing PR, schedule- and event-driven automation, and even assigning alerts from a security campaign. Copilot's identity is not the model but the fact that it lives on top of the repository-and-PR lifecycle.

OpenAI Codex. The pricing doc, in its description of the Plus plan, enumerates the surfaces — "Codex on web, CLI, IDE extension, and iOS," plus "cloud-based integrations like automatic code review and Slack." The models are the GPT-5.6 family, and the docs split them by purpose directly. Sol is for "when quality and reasoning depth matter most"; Terra is the "everyday default — strong performance with a better balance of performance and price"; Luna is "optimized for speed and economy, suited to light or high-volume tasks." There is also a separate API-key mode, which the docs recommend as "good for automation in shared environments like CI," while nailing down the tradeoff: "no cloud-based features (GitHub code review, Slack, and so on)."

Even this much shows the four products have different centers of gravity. Claude Code is the terminal, Cursor is the editor, Copilot is the repository, and Codex is a multi-surface product riding on a ChatGPT subscription. This difference governs the entire decision rule that follows.

Why the Four Prices Can't Be Lined Up Side by Side

Now the main event. Pull each vendor's billing unit straight from its own docs, put them in one table, and you get this:

All four cells are different objects. And this is not a split I forced; it is the unit each vendor actually uses in its own docs.

Anthropic does not disclose the absolute amount. The Max plan support doc says only "5x or 20x more usage than the Pro plan." Nowhere does it say what Pro's absolute amount — the thing the 5x is measured against — actually is. The usage-limit doc instead explains why it cannot say: "the number of messages you can send varies by plan," it notes, then lists message length, attachment size, conversation length, tool use, model selection, effort level, and artifact creation as all having an effect. The Claude Code docs strike the same tone — "a usage pool included in your organization's plan, reset on a rolling window." So "how many times a day can I run Max 20x" is a question the vendor has not published an answer to.

GitHub went the exact opposite way and fully dollarized it. The billing reference states it flat out — token cost is "converted into credits, where 1 credit = $0.01." And the plan structure is simple. In the doc's own words, base credits "match the subscription price and never change." I checked the arithmetic.

Base credits × 1 cent matches the subscription price exactly, across all five plans. That is, a Copilot subscription is structured as "you get that many tokens back," and the actual gain comes from the flex allowance layered on top.

But here I have to carry over the vendor's own warning verbatim. The flex allowance is explicitly variable. In the doc's words, it is "the variable portion of included usage, designed to adapt as the economics of AI evolve, including model prices, new models, and efficiency improvements." That is, the total-value column above is a number GitHub has itself said it can change at any time. The only fixed part is the base credits. And credits do not roll over — they reset at 00:00:00 UTC on the 1st of each month, a date fixed independently of your own billing date.

Cursor also sells in dollars. It just expresses it differently.

There is one more Cursor-specific wrinkle. An individual plan has two usage pools — a first-party pool (Auto, Composer 2.5, Grok 4.5) and an API pool (pick a specific model yourself and it is drawn down at that model's API rate). The dollar amounts in the table above are the API pool; for the first-party pool, Cursor writes not an amount but only "generous included usage." So Cursor's included amount, too, is half disclosed and half not. Team plans are Standard $40/user and Premium $120/user (with an Agent limit 5x that of Standard), and on Team and Enterprise a Cursor Token Rate of $0.25 per million tokens is added on top of the model's API price for third-party (non-Auto) model requests (Auto and first-party models are exempt).

OpenAI is the only one of the four to publish a per-model message count. This is transparency worth praising.

I checked whether Pro's "5x or 20x" claim actually holds. Six model-and-bound combinations × two multiples = all 12 pairs match exactly. Sol's lower bound 15 × 5 = 75, upper bound 90 × 20 = 1,800 — they land precisely, with no rounding and no hand-waving. It is rarer than you'd think for a vendor to claim a multiple and have that multiple actually check out against its own table.

But the Business plan's limits are identical to Plus's (Sol 15–90). Meaning a plan that costs $20/user (billed annually; $25 monthly) has the same limits as the $20 individual plan. What Business gives you is not higher limits but admin features and "larger virtual machines to run cloud tasks faster."

Here too I preserve the vendor's warning as-is. OpenAI wrote, right above this table: "similar-looking tasks can consume different amounts of quota. Model choice, context, reasoning, tool use, search, and caching all affect usage, so prompt length alone is not a reliable estimate." The 15–90 range is itself a factor of 6. This is not a precise number but an honest range.

So How Far Does It Reconcile — the Parts I Confirmed with Arithmetic

Different units do not mean nothing can be done. There are two bridges.

Bridge 1 — Cursor and Copilot use the same kind of ruler. Both are structured as "pay a subscription and get that much token usage back," so you can line up their price-to-value multiples.

Price-to-included-usage multiple (per each vendor's own docs)

Cursor  Pro    $20 -> $20     1.00x
Cursor  Pro+   $60 -> $70     1.17x
Cursor  Ultra  $200 -> $400   2.00x

Copilot Pro    $10 -> $15     1.50x   (base 1,000 + flex 500 credits)
Copilot Pro+   $39 -> $70     1.79x   (base 3,900 + flex 3,100)
Copilot Max    $100 -> $200   2.00x   (base 10,000 + flex 10,000)

-> at the top tier both converge on exactly 2.00x

That both top tiers land at 2.0x is an interesting coincidence. But reading it as "Cursor Ultra and Copilot Max are worth the same" would be wrong. Equal multiples still have different denominators — how many tokens a single $1 buys is set by each one's own rate card, and the two rate cards differ. Cursor even adds $0.25 per million tokens on top on its Team plans. So what to read from this table is not a ranking but the structure — both are "subscription = token budget," and the higher the tier, the faster the budget grows relative to price.

Bridge 2 — OpenAI's credits convert to its own API list price. OpenAI publishes the Codex credit rate (credits per million tokens) and the API list price (dollars per million tokens) in two different docs. I divided the two tables.

Model         Token type      Credits/1M   API list $/1M   Quotient
GPT-5.6 Sol   input           125          5              0.04
GPT-5.6 Sol   cached input     12.5         0.5           0.04
GPT-5.6 Sol   output          750          30             0.04
GPT-5.6 Terra input            62.5         2.5           0.04
GPT-5.6 Terra cached input      6.25        0.25          0.04
GPT-5.6 Terra output           375         15             0.04
GPT-5.6 Luna  input            25           1             0.04
GPT-5.6 Luna  cached input      2.5         0.1           0.04
GPT-5.6 Luna  output           150          6             0.04

-> all 9 data points equal 0.04

Three models × three token types = all 9 land on exactly $0.04. The odds of coincidence are essentially nil. Which means one Codex credit is 4 cents at OpenAI's standard API list price, and Codex overage is priced at that list price.

An important caveat here. This $0.04 is not a number OpenAI published; it is a value I got by dividing two official tables. Nowhere in OpenAI's Codex docs is there a sentence saying "1 credit = $0.04." The credit rate table and the API price table are each primary sources, but the equivalence between them is my arithmetic. OpenAI is under no obligation to keep this ratio, and could change it without notice without contradicting its docs. GitHub spelling out "1 credit = 1 cent" in its docs, and OpenAI not spelling it out, are two different facts. The former is a quote; the latter is an inference.

Only Anthropic Publishes Actual Observed Cost

Here is something only one of the four vendors does. Anthropic's cost-management doc records amounts observed in actual deployments.

Across enterprise deployments, the average cost is around $13 per active developer-day and $150–$250 per developer per month, and 90% of users stay under $30 per active day.

This is a vendor self-measurement, and its conditions have to be attached to it. The measured population is "enterprise deployments," and the doc itself concedes the limit in the very next sentence — "per-developer cost varies widely with model selection, codebase size, and usage patterns such as running multiple instances or using automation." And these figures are on API token billing, not on a Pro/Max subscription. The same doc separately points you to "claude.com/pricing for subscription plan prices." So $150–$250 is not a number to read as "then Max 20x ($200/month) will cover it." The billing path is different.

The reason this paragraph is still valuable is that the other three vendors have no corresponding number. I checked — searching the entire OpenAI Codex documentation (a consolidated markdown dump of about 1.26MB) for per-developer cost patterns turned up only one footnote: "2+ users, billed annually. $25/user per month if billed monthly." OpenAI does not publish an observed per-developer cost in its Codex docs. Neither do Cursor's or GitHub's docs.

One more thing: search snippets float a sentence claiming "Codex runs about $100–$200 per developer per month." I left it out of this post, because it could not be confirmed in OpenAI's own docs. An unconfirmed number is a number the vendor did not state, and "not yet published" is itself a fact.

There Is No Shared Benchmark — and That's the Point of This Post

This is the most important paragraph in the post.

Nowhere in the four vendors' official docs is there a shared benchmark against a competing product. Anthropic's docs do not benchmark Cursor, Cursor's docs do not carry Copilot's scores, and GitHub's docs do not pit Codex against its own agent. Each writes only about what its own product does. So if you see a sentence like "Claude Code is X% better than Cursor," it did not come from any of the four vendors' primary docs.

There is one thing that comes closest. GitHub's AI model comparison reference puts OpenAI, Anthropic, Google, and xAI models in one table and recommends by task area. For example, GPT-5.6 Sol is for "deep reasoning and debugging / complex reasoning over large codebases and long-running agentic work," and Claude Haiku 4.5 is for "fast handling of simple or repetitive tasks / quick, reliable answers to lightweight coding questions." It is worth a look, if only because material comparing multiple vendors' models in one place is rare.

But this is not a benchmark. For two reasons. First, it is description, not scores — an "excels at" prose field, not a measured figure. Second, its scope is inside Copilot. This table is a routing guide for "which model to pick in Copilot," not an answer to "Copilot vs. Cursor." And you have to keep in mind that the referee is also a contestant.

So, put honestly: "which agent writes better code" is a question this post does not answer. No shared measure is published, and ranking on a measure that does not exist is not evidence but invention. And even if leaderboard scores existed, the reasons you should not take them at face value are covered separately in Separating Signal from Noise When You Evaluate AI Coding Models — in short, OpenAI's own evals team said the most widely used coding benchmark no longer gives a meaningful signal.

The Four Are Not Mutually Exclusive

Now let me show, from each vendor's own docs, why "which should I use" is a badly framed question.

• Claude Code runs inside Cursor. Anthropic support doc: the Pro/Max plans include Claude Code in "VS Code, Cursor and other VS Code forks, and JetBrains IDEs like IntelliJ and PyCharm."
• GitHub bolted Claude and Codex on. In GitHub's "third-party coding agents" (public preview) section, the supported list is exactly two — Anthropic Claude and OpenAI Codex. You can assign an issue, mention the agent's name in a PR comment, and start work from the Agents tab, mobile, or VS Code. In the doc's words, these "are subject to the same security protections, mitigations, and constraints as the Copilot cloud agent."
• Cursor sells other companies' models. "Supports frontier models from OpenAI, Anthropic, Google, SpaceXAI, and others."
• Copilot sells other companies' models too. Its model catalog has OpenAI, Anthropic, Google, and xAI side by side.

In other words, the market is not "four exclusive products" but a grid where surface, model, and billing cross one another. Use an Anthropic model in Cursor and you pay Cursor; use Claude Code inside Cursor and you pay Anthropic. Same editor, same model, same work — and the invoice comes from a different company. This is the real reason "which is cheapest" is not a simple question.

So What to Use for What — the Decision Rule

A rule you can build from the facts above — using only what is confirmed in each vendor's primary docs.

Rule 1 — If your repo host is not GitHub, it splits right there. Copilot cloud-agent's entry points all belong to GitHub (issues, PRs, the Agents tab). Cursor cloud-agent, by contrast, supports per its docs GitHub (Cloud and Enterprise Server), GitLab (cloud and self-hosted), Bitbucket Cloud, and Azure DevOps. If you use GitLab, this one line ends the decision. It is not a matter of taste but of the support list.

Rule 2 — If work flows "issue → PR," go with a repo-side agent. If the ticket already exists as an issue and the deliverable has to be a PR, a tool that lives on top of that lifecycle has the advantage. Copilot cloud-agent is shaped exactly like that (investigate → plan → branch → PR), with schedule- and event-driven automation and security-alert assignment all in the same place. And if you cleared Rule 1, you can also pick Claude or Codex in that same place — because GitHub supports them as third-party agents.

Rule 3 — If work starts in the terminal and CI, use the CLI. All four have a CLI, but the details diverge. Claude Code's docs nail down that the Agent SDK is CLI-only, so if you plan to wrap the agent as a library and embed it in your own system, the CLI is the only path. For Codex, API-key mode is recommended by the docs themselves as "good for automation in shared environments like CI," but at the price of giving up the cloud features — a design meant to keep you from burning a personal subscription on shared CI. Cursor CLI has its own print mode and GitHub Actions docs.

Rule 4 — If you have your-own-cloud or compliance requirements, the field narrows. Claude Code documents deployment through Amazon Bedrock, Google Cloud's Agent Platform, and Microsoft Foundry. If "model calls must happen inside our own cloud account" is a requirement, this axis effectively decides it.

Rule 5 — If Tab autocomplete is the center of your day, go editor-side. Cursor's docs say "every individual plan (Pro, Pro+, Ultra) includes unlimited Tab completions," while the free Hobby plan gets "limited Tab completions." Copilot likewise gives paid plans unlimited in-IDE completion, and Free gets 2,000 per month. Claude Code and Codex do not present autocomplete as part of their identity in their own docs — they are agents, not completion engines.

Rule 6 — Choose the billing model by whether you want to "compute" the budget or "fix" it. This is the practical conclusion of the earlier sections.

• If you need to compute cost up front and reconcile after → Copilot or Cursor. Both are in dollar units, so with a token estimate you get a spreadsheet. Copilot, with 1 credit = 1 cent nailed into its docs, is especially easy to compute.
• If you want to pin cost to a flat monthly fee → a Claude Code subscription or a Codex subscription. The tradeoff: you cannot compute up front "how much this limit lets me do." Anthropic publishes only a multiple, and OpenAI publishes a range spanning a factor of 6.
• All four have an escape hatch to API list pricing on overage. For Anthropic it is usage credits at "standard API rates"; for Codex, extra credits and an API key; for Cursor, on-demand (same rate, billed after); for Copilot, an additional-usage budget you set in dollars.

The one-line decision rule. Do not pick a tool; pick the place where the work starts. If it starts from a ticket, a repo agent; from the editor, Cursor or Copilot; from the terminal or a script, a CLI; if it moves around, the one whose same engine spans several surfaces. Then narrow by billing model only among the candidates that support that place. Do it in the reverse order — compare price tags first — and you are left clutching four rulers that never converted in the first place.

When You Should Not Trust This Post

Let me state the limits honestly. Without them, the rules above are worthless too.

This post does not compare quality. That none of the rules above contains "which one writes better code" is not an oversight. It is because no shared benchmark is published. Surface, price, and support lists are confirmable from the docs; quality is not. If you want to know quality, a small eval set on your own codebase is the only way, and it is normal for its results to disagree with the leaderboard.

Price is the fastest-rotting part of this post. Anthropic's pricing page states "prices and plans are subject to change at Anthropic's discretion," Copilot's flex allowance is variable by design, and OpenAI's credit-to-dollar equivalence was my arithmetic to begin with, not their promise. The tables above are a snapshot of July 17, 2026. Before you decide, open each vendor's page yourself — the references in this post are all those links.

The published limits are not precise. OpenAI's 15–90 is a factor of 6 wide, and the vendor itself wrote that "prompt length alone is not a reliable estimate." Do not drop this range straight into capacity planning.

Also factor in a few state changes. GitHub's docs note that as of April 22, 2026, new self-serve sign-ups for Copilot Business by Free/Team plan organizations are paused. Copilot's request-based billing has already been pushed to legacy in the doc structure (request-based-billing-legacy). GitHub's third-party coding agents are in public preview. Building a team workflow on top of a preview feature is itself a decision.

And switching tools is no guarantee your productivity rises. This is outside the scope of this post but the most important caveat — two well-designed randomized controlled trials returned answers of opposite sign, and that story is in Does AI Actually Make Developers Faster. Tool choice generally matters less than how you use it.

Closing

To sum up.

"Which is cheapest" has no answer from published prices. The four vendors sell in four different units — Anthropic a multiple with no absolute amount, Cursor dollars (but half of it "generous"), GitHub 1-cent credits, OpenAI a message range a factor of 6 wide. Of these, only GitHub and Cursor are structurally comparable, and even they cannot be ranked because their rate cards differ. Three things are confirmable by arithmetic — Copilot's base credits match the subscription price exactly across all five plans, OpenAI's 5x/20x claim checks out for all 12 pairs, and Codex credits come out to 4 cents at its own API list price (this one is my division, not a vendor sentence).

"Which should I use" is not an exclusive choice to begin with. Claude Code runs inside Cursor, GitHub has bolted Claude and Codex on, and Cursor and Copilot both sell other companies' models. So what you choose is not a vendor but the place where the work starts. A ticket means the repository, code means the editor, a script means the terminal. Once the place is set, the candidates shrink, and only then does the billing model start to matter.

And no one has published a quality ranking. None of the four vendors carries a shared benchmark against a competing product. If you see such a ranking, its source is none of the four's docs. The way to fill that gap is not a leaderboard but a single eval set on your own repository — still boring, and still the only way.

The work comes first, not the tool. This is exactly the same shape as the conclusion in the Graph RAG post, and that is no accident — for a question the vendor has not published an answer to, your own measurement is the only answer.

References

Anthropic — Claude Code

• Claude Code official docs — overview (terminal, IDE, desktop, browser)
• Platforms and integrations — a surface-by-surface use comparison
• Cost management — $13 per active developer-day, $150–$250 per month (vendor self-measured, enterprise deployments)
• Models, usage, and limits in Claude Code
• Using Claude Code with your Pro or Max plan — supports VS Code, Cursor and other VS Code forks, JetBrains
• What is the Max plan — "5x or 20x more usage than Pro"
• Usage-limit best practices — the factors that affect your limits
• Claude plans and pricing

Cursor

• Models and pricing — two usage pools, included API usage per plan, the Cursor Token Rate
• Cursor pricing page
• Cloud Agents — supports GitHub, GitLab, Bitbucket, Azure DevOps
• Cursor CLI — interactive and print modes

GitHub Copilot

• Copilot plans
• Usage-based billing for individuals — 1 credit = $0.01, base credits and flex allowance
• Copilot models and pricing — how tokens convert to credits
• About the cloud agent — investigate, plan, branch, PR
• About third-party coding agents — Anthropic Claude and OpenAI Codex (public preview)
• AI model comparison — recommendations by task area (Copilot-internal routing guide)
• github/docs repository — the source markdown and pricing-variable files behind the docs above

OpenAI Codex

• Codex pricing — plans, per-model 5-hour window message limits, credit rate table
• OpenAI API pricing — standard-tier token rates

Related posts

• Five Habits for Working Well with AI Coding Tools
• Does AI Actually Make Developers Faster? What the Measured Numbers Say
• Separating Signal from Noise When You Evaluate AI Coding Models