Subscribe
Pricing
6 min read

The Meter Is the Price: How AI Coding Agents Actually Bill You in Late 2026

Copilot, Claude Code, Codex and Cursor charge similar sticker prices through four different meters. The meter, not the sticker, decides your worst-case bill.

Olivetti-style poster reading THE METER IS THE PRICE above four retro measuring instruments: a dial gauge, an hourglass, a ticker counter and a slider scale
Olivetti-style poster reading THE METER IS THE PRICE above four retro measuring instruments: a dial gauge, an hourglass, a ticker counter and a slider scale

The Meter Is the Price: How AI Coding Agents Actually Bill You in Late 2026

The sticker prices of AI coding agents have converged. GitHub Copilot Pro starts at $10 a month, Claude Code on a Pro subscription at $20, OpenAI Codex bundled with ChatGPT Plus at $20, Devin Core at $20, Cursor's paid tiers from $8 to $30 depending on the plan you pick. None of those numbers is comparable to any of the others, because the four most-used tools bill through four genuinely different meters: a credit allowance, a rolling time window, pure token metering, and a usage pool priced in multipliers. At heavy agent use, real spend converges toward roughly $60 to $200 per developer per month regardless of which logo is on the plan, which makes the shape of the meter, not the sticker, the thing worth understanding.

Four meters, one bill

GitHub Copilot sells seats with a dollar credit allowance. Since June 1, 2026, all Copilot plans run on usage-based AI Credits, where 1 credit equals $0.01 and consumption is computed from input, cached input, and output tokens at per-model rates published in GitHub's own docs. Pro ($10) includes $15 of monthly credits, Pro+ ($39) includes $70, and the Max tier ($100) includes $200, per a September 2026 comparison by Contra Collective. Business seats at $19 include $19 of credits as of September 1, 2026, down from a promotional $30, and credits expire monthly with no rollover. Code completions stay unlimited on paid tiers; the meter only bites on chat and agent requests. The mental model is a prepaid gift card: predictable until it empties, at which point usage either stops (if you set the bundled budget to $0, which GitHub documents) or bills onward.

Claude Code meters time, not money. Anthropic's subscription plans (Pro $20, or about $17 billed annually; Max 5x $100; Max 20x $200) do not publish a dollar allowance or a token cap. They publish multipliers against a rolling five-hour session window plus a separate weekly cap, shared across Claude chat and Claude Code. As several plan guides note (AgentCat, Runelab), Anthropic has never disclosed the numeric size of those windows; community tooling triangulates them from user reports. Past a cap you either wait for the reset or enable usage credits, which bill overage at standard API rates under a $2,000-per-day ceiling. In May 2026 Anthropic doubled the five-hour limits but left weekly caps untouched, and from September 14, 2026 the weekly limits sit permanently about 25% higher. The practical effect: your monthly ceiling is known in advance, but a heavy Tuesday afternoon can hit a wall mid-task even when your monthly allowance is far from spent.

Codex bills tokens riding on ChatGPT. On April 2, 2026 OpenAI moved Plus, Pro and Business plans from per-message estimates to token-based credit pricing, with legacy Enterprise, Edu, Health and Gov plans following on April 23, according to UI Bakery's changelog and OpenAI's own rate-card documentation. Credits now map directly to input, cached input, and output tokens. OpenAI's guidance puts typical developer usage at roughly $100 to $200 per month when Codex is a primary teammate, and eesel's breakdown notes a complex multi-file task can consume around 9x the credits of a simple edit on the same slot. This is the most honest meter of the four and the least predictable: the bill tracks exactly what the agent consumes, with no allowance to smooth it.

Cursor sells usage in multipliers, and the model price sits behind it. Cursor's current pricing page lists Plus at $8 (Grok models only), Premium at $30 (4x usage), Super at $100 (15x) and Ultra at $200 (50x), with third-party frontier models available inside the editor billed separately at API list price. Teams seats start at $30 per user. So a Cursor bill is two bills: a usage pool for the house model, and a raw per-token meter the moment you point an agent at Claude or GPT. Earlier plan structures (a $20 Pro with included credit pools, a $200 Ultra at 20x) documented by Contra Collective and Tokenade have been replaced by this tiered pool plus external-API-price arrangement.

What one task actually burns

Four retro billing instruments: a dial gauge, an hourglass, a ticker-tape machine and a balance scale

Sticker comparison fails because agents do not bill per action, they bill per token, and one agent task pushes enormous token volume. Every API call resends the conversation so far, so cumulative input scales with task length: Morph's June 2026 token-math projections put a single bug fix at roughly 400K cumulative input tokens and a feature-sized task at up to 2M. At published rates with 75% of input served from cache at 90% off, that computes to about $0.54 per bug fix on Claude Sonnet 4.6, $0.90 on Opus 4.8 and $2.28 to $7.60 for feature-sized work on the same models, versus about $0.21 for the same feature on DeepSeek V4 Pro. These are projections, not measured sessions, but the ratios come straight from the price sheets.

Two hidden multipliers sit inside every meter. First, overhead: amux's October 2026 comparison estimates around 27K tokens of system prompt and tool definitions ride along with every Claude Code request and about 15K with Codex, adding 10 to 30% on usage-billed plans before your actual prompt does anything. Second, context-length cliffs: GitHub's own pricing tables double the input and output rate on long-context tiers above 272K input tokens for several models, and OpenAI's enterprise rate card drops the context surcharge only for the sign-in-with-ChatGPT flow, not for API keys.

Where the meters blew up in 2026

The structural risk of token billing got its headline moments this year. The Verge reported, and Windows Central confirmed, that Microsoft's Experiences and Devices division (Windows, Microsoft 365, Outlook, Teams, Surface) ordered thousands of engineers off Claude Code by June 30, 2026, its fiscal year end, migrating them to GitHub Copilot CLI. Reported token bills for power users ran in the $500 to $2,000 per engineer per month range, and the division's annual AI budget was consumed early. Uber's CTO Praveen Neppalli Naga told outlets the company exhausted its 2026 AI budget in four months on Claude Code at similar per-engineer rates, then responded with prompt caching, cheaper model defaults and usage dashboards rather than usage cuts, after which usage quadrupled at lower per-token cost. Anthropic's own enterprise figures, as compiled by Morph, put the average at about $13 per developer per active day and $150 to $250 per developer per month, with 90% of users under $30 on any given day. The mean is fine; it is the tail that produced the memos.

That tail explains Anthropic's aborted June 15, 2026 billing change. The company announced, then paused the same day, a move that would have taken Agent SDK usage, headless claude -p runs, GitHub Actions integration and third-party apps off flat subscription pools and onto metered API-rate credits. Flat-rate windows are subsidized for interactive use; Morph computes that the frequently claimed 25 to 36x subscription discount would require extracting around 4,000 bug-fix-sized tasks a month from a $100 plan, which is cron-job volume, not human volume. Every vendor is converging on the same conclusion: human-speed usage can live on a flat meter, automation belongs on a token meter. OpenAI got there first in April; Anthropic tried in June and retreated; Copilot's overage path has been token-priced from day one of the credits system.

Choosing a failure mode

The budgeting question is which worst case you prefer, not which sticker is lowest. If you need a hard ceiling and accept mid-task walls, a rolling-window plan like Claude Max is the known maximum. If you want to pay exactly for what you use and tolerate variance, Codex's token credits or a BYO-key open-source runner (Aider, Cline) are the honest meters; amux estimates five parallel API-billed agents at $100 to $400 per developer per month. If you want an allowance that smooths month to month at a low entry price, Copilot's credit seats fill that role, provided you set the stop-usage budget so expiration and overage cannot surprise you.

Whichever meter you pick, compute cost per completed task, not per seat, and meter a real month before committing budget. The first month always surprises teams that budgeted from sticker prices, and in late 2026 the sticker is the least informative number on the page.

Sources

Pricingai-coding-agentsAnalysis