For a few hundred developers, make GitHub Copilot Business the default seat and buy Claude Code on Claude Enterprise only where cost per merged PR justifies it. Keep OpenAI Codex in a pilot until OpenAI publishes how big its December allowance is. All three vendors now bill agent work by the token, so the seat price tells you very little. Copilot's $19 seat comes back to you as $19 of usage. Claude Enterprise's $20 seat comes with no included usage on its pricing page. Codex's $20 Business seat includes an allowance OpenAI has not sized.
On one defined workload (below), a typical developer costs about the same on all three at list price, between $137 and $157 a month on a mid-tier model. The differences that matter are how much each product's harness spends per task, and whether you can stop the meter. Prices below were checked on each vendor's live page on November 7, 2026.
| Claude Code (Claude Enterprise) | OpenAI Codex (ChatGPT Business) | GitHub Copilot Business | |
|---|---|---|---|
| Seat price | $20/seat/month, annual, 20-seat minimum | $20/user/month annual, $25 monthly | $19/user/month |
| Usage included in the seat | None listed: "seat price + usage at API rates" | Plan allowance, size not published | 1,900 AI credits ($19), pooled |
| Overage unit | Per token at API rates | Credits, reported at about $0.04 each | AI credits at $0.01 each |
| Typical developer, mid-tier model (our workload) | $157 | $20 to $146 | $137 |
| Same developer on the top model | $293 (Opus 5.5) | Not modelled | $273 (Opus 5.5) |
| Hard spend stop | Org, group and user limits | Monthly credit limits by seat type or user | User budgets; others need "Stop usage" switched on |
| Verdict | Buy for measured heavy users | Pilot only for now | Default seat |
What Does Each Vendor Charge Per Seat and Per Token?
Each vendor sells a seat and a meter, and in November 2026 the meter is the larger part of the bill for anyone using agents. Here is what each one publishes.
Claude Code is included in every Claude business plan. Anthropic's pricing page lists the Team plan for 2 to 150 seats at $20 per standard seat per month on annual billing ($25 monthly) and $100 per premium seat ($125 monthly), with premium seats getting "5x more usage than standard seats." Enterprise is $20 per seat per month, billed annually, with a 20-seat minimum, and the page describes its billing as "Seat price + usage at API rates." Anthropic's API rate card prices Claude Opus 5.5 at $4 per million input tokens and $20 per million output tokens, with cache hits at $0.20 and five-minute cache writes at $5. Sonnet 5.5 costs half that on every line.
One inconsistency needs settling in writing. Claude Code's cost documentation says that on Team and Enterprise plans "usage draws from each member's seat allowance," which resets on a five-hour and a weekly window, and that usage credits let members go past it. The pricing page describes Enterprise as seat plus metered usage. Ask your account team which of the two your Enterprise contract is, because it changes the light-user arithmetic below.
OpenAI Codex comes with ChatGPT. OpenAI's pricing documentation lists Business at $20 per user per month on annual billing for two or more users ($25 monthly), with Enterprise priced through sales. Overflow beyond the plan allowance is billed in credits. GPT-6.1 Sol costs 50 credits per million input tokens, 2.5 per million cached and 250 per million output, and "Codex credit billing has no separate cache-write charge." Fast mode costs twice the Standard rate on purchased credits and Ultrafast six times. OpenAI does not state a dollar value per credit. CloudZero reports about four cents, worked back from API prices.
Two Codex changes affect any budget. OpenAI stopped offering usage-based Codex-only seats to new Business workspaces on June 24, 2026, and from December, Business users' chat and Codex work will draw on one shared allowance whose size has not been published.
GitHub Copilot has the plainest arithmetic. GitHub's plans documentation lists Business at $19 per granted seat per month with 1,900 AI credits, and Enterprise at $39 with 3,900. GitHub's billing docs say each licence adds its credits to one pool at the billing entity, unused credits expire monthly, and inline completions and next edit suggestions "are not billed in AI credits and remain unlimited." GitHub's model rate card sets one credit at $0.01 and charges Claude Opus 5.5 at exactly Anthropic's API list price. GPT-6.1 Sol costs $2 input and $10 output per million tokens, the same as Sonnet 5.5.
What Does One Agent Task Cost?
On a mid-tier model, our illustrative agent task costs between $0.60 and $0.65 on all three vendors, and about $1.30 on Claude Opus 5.5. We defined the task as 1.5 million cached input tokens read, 100,000 fresh input tokens (billed as cache writes where the vendor charges for them) and 25,000 output tokens, including thinking. That is roughly what a session of tool calls over a mid-sized repository looks like when caching works. Cache reads dominate the token count, which we covered when one PR billed 156M tokens.
| Model and channel | Cost of one task |
|---|---|
| Claude Opus 5.5 (Anthropic API, or Copilot) | $1.30 |
| Claude Sonnet 5.5 (Anthropic API, or Copilot) | $0.65 |
| GPT-6.1 Sol on Copilot | $0.65 |
| GPT-6.1 Sol on Codex credits (15 credits at $0.04) | $0.60 |
| GPT-6.1 Terra on Codex credits (7.5 credits) | $0.30 |
Now scale it over 21 working days. A light user runs 3 tasks a day, a typical user 10 and a heavy user 40 (parallel agents and background runs). Token cost per developer per month, before any seat:
| Usage | Mid-tier model ($0.65) | Opus 5.5 ($1.30) |
|---|---|---|
| Light, 63 tasks | $41 | $82 |
| Typical, 210 tasks | $137 | $273 |
| Heavy, 840 tasks | $546 | $1,092 |
The typical Opus row comes to $13 a day, which matches the average Anthropic publishes for Claude Code: "around $13 per developer per active day and $150-250 per developer per month," with 90% of users below $30 per active day. So the task size is in a realistic range. It is still our assumption, and your own tasks may be much larger. In Artificial Analysis's coding agent tests, Claude Code with Opus 5.5 at max effort cost $11.42 per benchmark task, against $5.59 for Copilot Fusion at max, about nine times our illustrative task.
Turned into a per-developer bill on a mid-tier model:
- On Copilot Business, the seat's credits absorb the first $19, so the developer costs $41, $137 or $546. Copilot can never cost less than the seat, and above it the bill is pure usage.
- On Claude Enterprise as the pricing page describes it, the $20 seat sits on top: $61, $157 or $566 on Sonnet 5.5, and $102, $293 or $1,112 on Opus 5.5.
- On Codex with a Business seat, the developer costs $20 plus whatever overflows the allowance. If nothing were included, that would be $58, $146 or $524. The real figure sits between $20 and that ceiling, and OpenAI has not said where.
Why Does the Same Model Cost More in Claude Code?
Claude Code spends more tokens per task than its rivals on the same model, so equal per-token prices do not give equal bills. In the HarnessTax study from UC Berkeley and Arena, published September 16, 2026, Claude Code cost about 1.6 times Codex and 2.0 times the open-source Pi harness on SWE-bench Lite (geometric means across seven models), and its first-call context was more than ten times Pi's. The harness moved the success rate by a few points and the bill by up to five times. The study ran 30 tasks per benchmark at list API prices and its confidence intervals are wide, so treat the multiplier as approximate.
The steel-man for Claude Code is quality. Artificial Analysis puts Claude Code with Opus 5.5 at max about two points above Copilot Fusion on its Coding Agent Index, and if those points mean fewer abandoned tasks on your code, the extra tokens are cheap. That is a question about your own repositories, and our earlier bake-off analysis showed harness choice can flip a model ranking. Cost per merged PR on your own code is the measure that settles it.
Claude Code's own docs name the habits that inflate a heavy user's bill: agent teams use approximately 7x more tokens than standard sessions in plan mode, and long uncleared sessions and Opus left as the default are the usual causes of unexpected spend.
Which Spend Controls Actually Stop the Meter?
All three vendors let you cap spend per user, and none of them caps it until an admin sets the limit. The differences are in the defaults and in what happens at the limit.
| Control | Claude Team / Enterprise | ChatGPT Business / Enterprise (Codex) | GitHub Copilot |
|---|---|---|---|
| Default ceiling | Seat allowance; overage only if usage credits are on | Plan allowance; overflow needs credits | Pool, then metered if paid usage is allowed |
| Per-user cap | Yes | Business: by seat type or user | Yes, user budgets are a hard stop |
| Group or cost-centre cap | Group limits and pooled group budgets | Enterprise: group limits | Cost-centre budgets |
| Alerts | 50%, 75%, 95%, 100% of a pooled budget | Usage dashboard | Budget thresholds |
| Per-user reporting | Spend CSV; Enterprise Analytics API; OpenTelemetry | Combined ChatGPT and Codex view by user, product and model | Usage reports by user |
On Claude, the Enterprise consumption guide says limits apply at organisation, group and user level, "individual limits always override group limits," and "no limit anywhere = no limit." Pooled group budgets pause members when the pool runs out. Claude Code also lets admins push contracted rates into managed settings with modelPricing, so the cost figures developers see in /usage match your contract rather than list price.
On ChatGPT, Business admins can set monthly credit limits by seat type or individual user, and automatic reload runs up to a monthly recharge limit. For Enterprise, OpenAI's June 2026 update added a workspace default limit, group limits and individual exceptions, with ChatGPT and Codex credit use in one dashboard. The pricing documentation itself describes no cap.
On Copilot, user, cost-centre, organisation and enterprise budgets exist, but an enterprise spending limit enforces nothing until you enable "Stop usage when budget limit is reached". Two Copilot costs sit outside the credit math. Code review costs an estimated $0.25 on Lite, $1.50 on Balanced and $10 on Max, excluding Actions minutes, and the cloud agent's compute draws on your GitHub Actions allowance, separate from AI credits.
Why Do the Per-Developer Estimates Disagree?
The published per-developer numbers range from about $20 to over $1,000 a month because each one measures something different. Anthropic's $150 to $250 comes from enterprise deployments and is measured per developer, alongside a per-active-day figure. CloudZero cites $100 to $200 for Codex as OpenAI's own estimate without linking a source, and its cross-vendor roundup from August 28, 2026 calls the same range "commonly reported." Blog roundups add seat prices to those figures and get a third set of numbers.
Five things drive the gaps:
- Active days against seat months: a seat that logs in twice a month pulls the per-seat average well below 30 times the per-active-day figure.
- Subscription against API rates: one developer published 90 days of Claude Code use worth $33,624 at Anthropic's list rates, on a Max 20x plan that cost $600 over the period. That is $16.85 per merged PR at list and about $0.30 at what was paid.
- The harness, with HarnessTax's spread of up to five times on the same model.
- Model mix: Opus 5.5 is twice Sonnet 5.5, and on Codex's rate card GPT-6 Astra costs 100 times GPT-6 Luna.
- Cache hit rate: an Opus 5.5 cache read costs one twentieth of fresh input, so a session that keeps missing its cache can multiply the input bill.
Use an estimate you did not measure yourself only to check that your own figure is in range.
How to Measure Cost Per Merged PR in a Pilot
Cost per merged PR is total AI-attributable spend for a cohort divided by the pull requests that cohort merged and did not revert within 30 days. It is the only unit that puts a cheap-but-chatty harness and an expensive-but-decisive one on the same scale, because it charges failed attempts to the work that eventually shipped.
The numerator has three parts. Token spend comes from each vendor's per-user export, priced at your contracted rates. Seat fees are divided over the cohort. CI compute triggered by agent pull requests goes in too, and it is easy to miss: one team running about 25 Claude Code agents measured $1.19 to $2.52 per merged PR in GitHub Actions charges in late October, down to $0.49 to $0.56 after splitting its test suite and moving some test jobs to EC2 Spot, against a Claude subscription bill of $600 a month.
Run it like this:
- Pick two or three repositories and split 20 to 30 developers into cohorts by product, not by enthusiasm, so the heavy users do not all land in one arm.
- Run four to six weeks. Fix the default model per cohort and log when anyone overrides it.
- Turn on per-user export before day one: Claude Code's OpenTelemetry or the Enterprise Analytics API, OpenAI's usage dashboard, and Copilot's usage report.
- Hold PR size comparable, or report cost per 100 changed lines next to cost per PR.
- Count reverts and the reviewer hours each cohort's PRs needed. Price reviewer time into the numerator.
Our earlier piece on private-codebase benchmarks found $18 against $8 per resolved task between two models, which is the size of gap a pilot like this can surface.
When Is a Flat Seat Cheaper Than Consumption?
A flat seat is cheaper when a developer's usage at API rates exceeds the seat's price and still fits inside its allowance. Consumption is cheaper for everyone below that line. Heavy users are where flat seats pay, and they are also the users most likely to run past the allowance.
Claude Team's premium seat is the clearest case. At $100 against Enterprise's $20 plus usage, it wins for any developer above $80 a month of API-rate usage, which on our numbers is anyone typical or heavier, provided the allowance holds. Anthropic does not publish that allowance in dollars, and Team stops at 150 seats, so an organisation with several hundred developers is on Enterprise metering for most of them anyway. The Max 20x example above shows how far a subscription allowance can run past its price, but that was one developer on a plan priced for individuals, not a Team contract.
Copilot never gets cheaper than consumption at list, because the seat is converted into credits at face value. The pool helps a mixed population, since light users' unspent credits cover part of the heavy users' overage. Your true cost of a Copilot seat is the larger of your seat total and your usage total.
Codex is the one product where the seat clearly includes agent usage, and the one where you cannot calculate the break-even, because the allowance is undisclosed and changes in December.
Who Should Not Pick Each Option
Claude Code on Claude Enterprise is the wrong default for an organisation with a long tail of light users, since each one costs $20 a month before writing any code if the seat includes no usage. Avoid it as well if nobody owns spend limits: a typical Opus user runs $293 a month and a heavy one over $1,100. Organisations that need a flat seat at more than 150 developers cannot get one on Team.
OpenAI Codex is the wrong pick for anyone who must give finance a number before December, and for new Business workspaces that wanted the usage-only Codex seat, which is no longer sold to them. It suits teams already standardised on ChatGPT, where the seat is paid for anyway.
GitHub Copilot is the wrong pick if your code is not on GitHub, or if a pilot shows Claude Code's harness clears your hardest work and Copilot's agent does not. Claude models on Copilot are priced the same per token, but they run in a different harness. Copilot also does not suit a team that will leave code review on Max, which at 1,000 PRs a month is about $10,000 in review alone.
The Decision: What Predicts Regret
Most regret on these contracts comes from four things: no hard cap on day one, a default model nobody chose, a budget built on a promotional period, and a cost comparison made per token rather than per merged PR. The seat price predicts very little of it.
Three things change our recommendation. If your Claude Enterprise contract includes a usage allowance in the seat, Claude Code's light-user penalty disappears and the choice comes down to quality and harness efficiency. If OpenAI publishes allowance sizes that cover a typical developer, Codex on an existing ChatGPT Business estate becomes the cheapest per head of the three. If your Copilot discount is deep, model it at the discounted rate, because the list comparison here cannot see it.
This Week:
- Export 90 days of per-user usage from every coding tool you already pay for, and sort developers into light, typical and heavy using the task counts above.
- Ask Anthropic in writing whether your Enterprise seat includes usage, and ask OpenAI for per-seat allowance sizes after the December change.
- Turn on hard per-user caps on all three: user spend limits on Claude, monthly credit limits on Codex, and "Stop usage" on GitHub Copilot.
This Month:
- Start a four-to-six-week cost-per-merged-PR pilot across two repositories, with CI minutes in the numerator.
- Set a default mid-tier model per tool and make Opus or Astra opt-in.
- Cap Copilot code review at Balanced until you have measured Max.
Before Renewal:
- Put heavy users on whichever product gave the lowest cost per merged PR, and the long tail on Copilot's pooled seat.
- Write the budget at undiscounted list rates and at three times current usage, and negotiate from there.
The Bottom Line
Coding agents have gone the way cloud compute went a decade ago: list prices converge, and the bill depends on how efficiently each workload runs. Per-token rates for the same Claude model are identical on Anthropic and GitHub, and a typical developer costs $137 to $157 a month on any of the three. The real spread is in harness efficiency, model defaults and caps, and you can only see it by measuring cost per merged PR on your own repositories. Copilot is the default because its seat converts to usage at face value and its user budgets stop hard. Claude Code is for the developers whose PRs prove it. Codex waits for OpenAI to publish the December allowance sizes.
Continue Reading
- GitHub Enterprise Adds Copilot, Bills From First Use
- ChatGPT and Codex Will Share OpenAI's Usage Allowance in December
- True Cost of a Copilot Seat: The Licence Is the Floor
- One PR Billed 156M Tokens. Cap the Reads, Not the Rate.
- Best AI Coding Assistant at 500 Seats: Buy Copilot Business
- Barclays Picks Claude for Half Its Developers, Copilot for Desks
- GitHub's Router Bills Every Leg. Find Your Break-Even.
- Agentic AI Pricing: Don't Buy Consumption Without a Cap
