I went looking for a straight answer to what an AI coding agent costs and found it in the one place nobody reads: Anthropic's own cost documentation for Claude Code.
It says the average is around $13 per developer per active day and $150 to $250 per developer per month, with 90 percent of users staying under $30 per active day.
The subscription is $20 a month.
What that gap actually means
Those two numbers are not contradictory, and the difference between them is the whole business model of this category.
The $150 to $250 figure is what a working developer consumes at API rates. The $20 is what a plan costs. A subscription is therefore not a discount, it is a bet: the vendor wagers that most subscribers will use far less than they could, and prices accordingly. The limits are how the vendor wins that bet, and the reason every product in this space has spent 2026 rebuilding how it counts your usage.
That reframes the question. You are not asking which tool is cheaper. You are asking whether you are the kind of user the bet was priced for.
If you code a couple of hours a day, the subscription is extraordinary value and you are subsidising nobody. If you run agents all day across a large repository, you are the user the limits exist to catch, and you will meet them.
Nobody sells the same unit
Here is the structural problem, and it is the reason every comparison article in this category is wrong, including three on this site before I fixed them in August 2026.
| Tool | What you are actually buying | Entry price |
|---|---|---|
| GitHub Copilot | Dollars of credits, one credit is one cent | $10 |
| Cursor | A dollar pool, plus a second pool with no published rate | $20 |
| Codex | Message equivalents, published as ranges | $20 |
| Claude Code | Rolling five-hour and weekly time windows | $20 |
| Gemini CLI | Requests per minute and per day | Free tier |
| Zed | Dollars of tokens at API list price plus 10 percent | $10 |
Six products, six incompatible units. Dollars, messages, hours, requests, tokens. The prices cluster around $20 so they look comparable, and what you receive for the money is not comparable in any direction.
You cannot convert between these. There is no exchange rate between a five-hour window and a dollar of credits, and no vendor publishes one, because publishing one would make them comparable.
The ranges are the tell
OpenAI is the most honest and the most alarming about this.
Codex's included usage is published as a range. On the $20 Plus plan you get roughly 10 to 100 message equivalents of GPT-5.6 Sol. On Pro at 5x, 50 to 500. The faster Luna model gets 250 to 2,000 on Plus and 1,250 to 10,000 on Pro 5x.
A tenfold range is not evasion. It is accurate, and that is the problem. Consumption genuinely varies that much depending on how much context each request drags along, which means the vendor cannot tell you what you are buying because it does not know either.
Past the included allowance, Codex bills in credits at token rates: GPT-5.6 Sol at 125 credits per million input tokens and 750 per million output, Luna at 5 and 30, GPT-5.4 mini at 18.75 and 113. Those are precise. The allowance they extend is a range. That combination tells you where the vendor's uncertainty actually sits.
Copilot is the only one denominated in something you understand
GitHub sells dollars. One credit is one cent, and each plan includes a credit total: $10 buys $15 of credits, $39 buys $70, $100 buys $200. Base credits equal to the price, plus what GitHub calls a flex allotment on top that it adjusts as model prices move.
Notice that the allowance exceeds the subscription in every tier. That is deliberate and it is the opposite of Zed, which prices $10 for $5 of tokens. Both are rational. GitHub wants the credit figure to look generous; Zed expects most users to bring their own key and treats the included tokens as a sample.
I priced this properly against Cursor in Cursor vs GitHub Copilot, where the short version is that the $10 against $20 framing everyone repeats is misleading in both directions.
Cursor runs two pools and publishes one rate
Cursor Pro at $20 includes $20 of third-party model usage, which is legible. It also includes a separate pool for Cursor's own models, Composer and Grok, which the company describes as generous without attaching a published rate to it.
So the honest statement about Cursor Pro is that it gives you $20 of usage you can reason about plus an unspecified amount you cannot. Pro+ at $60 includes $70, and Ultra at $200 includes $400, both following the same above-the-subscription pattern GitHub uses.
I went through the full arithmetic in the Cursor review.
Claude Code does not use money at all
This is the most different approach in the category and the least discussed.
Your allowance resets on a rolling five-hour window with a weekly cap above it. On Team and Enterprise plans the allowance is per seat, it varies by seat tier, and it is shared with Claude chat and Cowork rather than being a separate coding budget. Anthropic states directly that usage inside the seat allowance is not metered in dollars.
There is therefore no spend figure to watch. You get windows, and when you exhaust one you wait or you buy usage credits. Google arrived at the same shape for Gemini, where limits refresh every five hours until a weekly cap, which I covered in ChatGPT vs Google Gemini.
Whether time windows are better than dollars depends on what you want. Windows are predictable in that you know when they reset and you cannot be surprised by a bill. They are unpredictable in that you have no idea how much work fits inside one until you hit the edge.
Three documented traps
These are all in vendor documentation, and none of them appear in the comparison articles.
The cache lifetime halves in a way that matters. Prompt caching is why sending your whole conversation on every request is affordable. Anthropic documents the cache lifetime as one hour on a subscription, dropping to five minutes once you are drawing on usage credits, and five minutes by default on an API key or cloud provider. So the moment you go into overage, your effective cost per request rises beyond the headline rate, because you start missing cache more often. There is an environment variable to keep the one-hour lifetime, which tells you this is a pricing decision rather than a technical limit.
Agent teams cost roughly seven times a normal session. Spawning parallel agents is the marquee feature of this generation of tools, and Anthropic's own figure is approximately 7x the tokens of a standard session when teammates run in plan mode, because each one carries its own context window. That is not a reason to avoid it. It is a reason to know before you leave four agents running over lunch.
The number your tool shows you is not your bill. Claude Code's documentation says its usage command computes the dollar figure locally from token counts at standard list rates, so it ignores promotional pricing and contracted discounts and may differ from what you are charged. It also notes that background jobs consume tokens while you are idle, typically under four cents a session. Treat in-tool figures as a gauge, not an invoice.
Why your usage climbs faster than your activity
Worth understanding because it explains most surprise limits.
Every request carries the whole conversation. A one-line question in a session you opened this morning bills for the entire history, not for the line you typed. Caching softens that and does not remove it.
So the single most effective habit is clearing between unrelated tasks rather than keeping one session open all day. That is free, it is the advice in Anthropic's own cost guide, and it does more than switching to a cheaper model.
The second most effective is matching the model to the job. Reserving the most capable model for genuinely hard reasoning and using a mid-tier one for everything else changes your consumption more than most people expect, because the frontier models are several times the price per token and most coding work does not need them.
The escape hatch nobody mentions
Every metered product in this category has an unmetered alternative, and it is not a hack.
Codex explicitly supports authenticating with an API key and paying API rates instead of using plan limits. Zed's free Personal tier works with your own keys. Claude Code's terminal CLI and VS Code extension support third-party providers. And the fully open-source agents have no subscription at all: OpenCode under MIT, Goose and Aider and Cline and Continue under Apache-2.0. With those, the software is free and you pay the model provider directly.
The trade is real and it runs the direction most people do not expect. Bringing your own key is cheaper when you are light and potentially far more expensive when you are heavy, because you have removed the subsidy that a flat subscription represents for a heavy user. Anthropic's $150 to $250 figure is what that looks like without a subscription in front of it.
What you buy with your own key is not savings. It is the absence of anyone telling you that you have had enough this week, plus a bill you can actually audit.
One warning if you go that way: set a spending cap. The failure mode of a metered subscription is being told to wait. The failure mode of an uncapped API key is an agent looping overnight.
If you are choosing between the open-source agents, note that they are not equally maintained. I checked the release history of each one in Cursor alternatives, and one of the most recommended has not shipped a release in a year.
The cheapest way to run an agent today
Gemini CLI's free tier is the most generous published allowance I found: 60 requests a minute and 1,000 a day on a personal Google account, aggregated across models rather than per model. Those figures come from the project's own quota documentation rather than a vendor pricing page, so treat them as slightly softer than the rest of this post.
For a light user that is genuinely hard to beat, and it costs nothing. The catch is that you take the model Google routes you to rather than choosing one.
Below that, the honest answer is that there is no cheap way to run heavy agent work. The compute costs what it costs. Every product here is either subsidising you, rationing you, or billing you, and the ones that feel cheapest are usually rationing.
Which one to actually buy
Working through all of the above, here is where I would put people.
If you are still learning to code, none of this arithmetic should decide anything for you yet. Pick the tool with the shallowest learning curve and revisit cost later; I went through which those are in top AI coding assistants for beginners, and the browser-based Claude workflow in how to use Claude AI for coding.
If you code a few hours a week, use a free tier and stop reading comparison articles. Gemini CLI's free allowance, ChatGPT's free tier, or Claude's free tier will cover you, and the money you would spend on a subscription buys nothing you will use.
If you code most days in a normal-sized repository, take a $20 subscription and stop optimising. You are the user the bet was priced for and you are getting the better half of it. Which $20 matters less than the fact that you took one. Pick on which editor you want to live in rather than on the allowance.
If you code all day across a large codebase, you will meet the limits, so choose on how the vendor behaves when you do. Copilot gives you a dollar figure and a hard budget you can set to zero. Claude Code gives you a window and tells you when it resets. Cursor gives you a pool plus an unpublished second pool. I would rather have the dollar figure, because it is the only one of the three I can forecast.
If you run agents unattended or in CI, use an API key rather than a subscription. Not because it is cheaper, it usually is not, but because unattended work is exactly what a subscription's fair-use limits are designed to stop, and you will spend your time fighting the allowance instead of doing the work.
If you are on a team of more than about five, the per-seat allowance question matters more than the sticker price, and it is the thing to ask a vendor directly. Anthropic publishes recommended tokens-per-minute figures that fall as team size grows, on the reasoning that fewer people use the tool concurrently in larger organisations. That is a sensible assumption and it means your per-developer experience depends on your colleagues' habits, which is not something any pricing page tells you.
If your employer has a procurement process, price is not your problem. Ownership and data handling are, and they change: two of the products in this category changed hands this year alone.
One thing I would not do is switch tools to chase an allowance. The allowances move every few months. Your editor habits do not.
How this fits with the rest of the pricing story
This post is about the mechanics: what the unit is, how the limits work, where the traps sit. If you want the chronology instead, meaning which vendor changed what and when through 2026, that is a separate piece: what AI pricing did in 2026 is the dated record with sources.
The two are worth reading together, because the pattern only becomes obvious once you see the timeline. Every vendor in this category moved to metered billing within about a year of each other, and none of them moved to the same unit.
How to actually find out what you will spend
Stop estimating. Nobody's estimate survives contact with your repository, because the variable that decides your cost is how much context each request drags along, and that is a function of your codebase rather than your habits.
Put a small amount of credit on an API key. Wire it into any agent that accepts one. Work normally for two or three days. Look at what you spent, multiply out to a month, and compare against $20.
That number is real, it is yours, and it took you three days rather than reading twenty articles. Then pick the subscription if the subscription wins, and it often will.
The verdict
The $20 subscription is the right choice for most working developers, and it is right for an uncomfortable reason: it is priced below what you consume, and the limits exist to make that arithmetic work for the vendor rather than for you.
That is not a scandal. It is how flat pricing has always worked, in gyms and phone plans and buffets. It is worth understanding because it predicts everything else in this category: why the units keep changing, why nobody publishes an exchange rate, why the allowances are expressed as ranges, and why every vendor added credits in 2026.
If you take one thing from this, take the habit rather than the tool. Clear your session between tasks, match the model to the job, and measure your own consumption once rather than trusting a comparison table. Those three things will save you more than switching products will.
Verified on August 13, 2026. The $13 per active day and $150 to $250 per month figures, the five-hour and weekly window structure, the seven-times agent team cost, the cache lifetime change, and the note that in-tool cost figures may differ from your bill all come from Anthropic's published Claude Code cost documentation. The Codex ranges and credit rates come from OpenAI's published Codex pricing documentation. Copilot, Cursor and Zed figures come from their own pricing pages. Gemini CLI's free quota comes from the project's own quota documentation rather than a vendor pricing page and is the softest number here.
