What AI coding agents cost per month, with the arithmetic

the short version

A coding agent bills for the conversation, not for the work. That single fact is what makes the monthly number surprising, because the conversation grows every turn while the work stays the same size. Below is the arithmetic, worked from published rates, for one developer running one agent through a normal day.

the rate card, and the five things it prices

Claude bills five separate classes of token at five different prices, and mixing them is where most cost estimates go wrong. Here is Claude Opus 5, the model Claude Code reaches for by default, as published on 7 August 2026:

The multipliers are the durable part. Anthropic publishes prompt caching as multipliers of each model's base input rate: 1.25x for a five-minute write, 2x for a one-hour write, 0.1x for a read. So the shape of the arithmetic on this page survives a price change even when the dollar figures do not. If Claude Opus 5 moved to $4 per million input tomorrow, every ratio below would still hold and only the totals would shift.

For reference, the other rungs on the same ladder, also read 7 August 2026: Claude Sonnet 5 at $2 per million input and $10 output under introductory pricing through 31 August 2026, rising to $3 and $15 after that; Claude Haiku 4.5 at $1 and $5. A cheaper model does not change the structure of the bill, only its size, which matters when you are deciding which agent gets which job in a parallel setup.

what one turn costs

A turn is one request and one response. In a coding session it carries the whole conversation so far, which is why its cost climbs even when your question does not get harder. Here is a turn from the middle of a session, with the token counts stated as assumptions rather than observations:

• 120,000 cache read tokens. The conversation, the files already read, the system prompt, all of it served from cache.
• 2,000 cache write tokens at the one-hour rate. The new material this turn added to the cached prefix.
• 100 fresh input tokens. Whatever was not cacheable. In real transcripts this number is frequently in single digits.
• 800 output tokens. A short explanation plus a tool call or an edit.

Priced against the card above, class by class, never summed first:

cache reads   120,000 x $0.50 / 1,000,000  = $0.0600
cache writes    2,000 x $10.00 / 1,000,000 = $0.0200
fresh input       100 x  $5.00 / 1,000,000 = $0.0005
output            800 x $25.00 / 1,000,000 = $0.0200
                                             -------
                                             $0.1005

About ten cents. Notice the shape of it. The cache reads are 97.6% of the tokens in that turn and 59.7% of its cost. The 800 output tokens are 0.65% of the tokens and 20% of the cost. Any estimate that reasons about "tokens" as one quantity is going to be wrong by a multiple, in whichever direction its author happened to guess.

Where those proportions come from

The turn shape above is chosen, not measured. It is chosen to sit close to the one real reading available: across 3.9GB of Claude Code transcripts, the cache pricing post found that 97.7% of all tokens were cache reads and that those reads were 63.9% of the bill. That corpus is one machine over several months, and it says so. Your split will differ. The point of matching it here is that a made-up turn which contradicted the only available evidence would not be worth doing arithmetic on.

a worked day

A day is turns multiplied by a rate you have to assume. State the assumptions plainly, because they are doing more work than the prices are:

Fifteen dollars for a day of agent work. The assumption most likely to be wrong is the third one. A session that starts fresh at 9am carries far less context than one that has been running since lunch, so early turns cost a fraction of ten cents and late ones cost more. Holding the shape constant is a simplification that trades accuracy for a number you can check by hand.

The assumption most likely to be wrong in the expensive direction is the second. Twenty five turns an hour is a person reading and steering; an agent left alone on a long task produces them considerably faster.

a worked month

Twenty one working days at $15.08 is $316.68, call it $317, for one developer running one agent on Claude Opus 5. That is the honest headline of this page, and it comes with the same four assumptions attached.

Two ways it moves, both large:

• More agents multiply it almost linearly. Three agents in three git worktrees are close to three times the spend, because each carries its own context and shares no cache with the others. Around $950 a month at these rates.
• A cheaper model divides it. The same month of turns on Claude Sonnet 5 at the $3 per million standard rate is 60% of the Opus figure, near $190, because every one of the five token classes is scaled off that base input rate. On Claude Haiku 4.5 at $1 per million it is a fifth, near $63.

The multiplication for the three-agent case is worth spelling out because it is where people expect a discount and there is not one. Three agents on the same repository do not share a prompt cache: the cache key is the exact prefix each one sends, and three agents working on three branches diverge on their first turn. Whatever else running several at once buys you, it does not buy cache sharing.

why cache reads dominate the token count and not the bill

This is the part that makes a coding agent price differently from a chatbot, and it is worth understanding rather than memorising.

Prompt caching is a prefix match. Everything stable at the front of the request, the system prompt, the tool definitions, the files already read, the conversation so far, is stored once and then served back on every subsequent turn at a tenth of the input price. A coding session is almost pure prefix: turn forty sends nearly the same first 100,000 tokens as turn thirty nine did, plus a little.

So the token counter runs away while the bill does not. In the worked turn above, dropping the 120,000 cache reads to zero would save six cents, while the 800 output tokens cost two. If those same 120,000 tokens had been billed as fresh input they would have cost sixty cents, six times the whole turn.

The one-hour cache write at 2x is what makes this asymmetry sharp. Writing 100,000 tokens costs $1.00 on Opus 5; reading them back costs $0.05 a turn. The write pays for itself after two reads and is pure profit after that. The context window cost table works that three-way comparison out in full.

subscription against API, and where it crosses

Claude Code is included in the Claude subscription plans as well as being usable against the API. On 7 August 2026 the published plan prices were: Pro at $20 per month, or $17 per month billed annually at $200 up front; Max plans starting from $100 per month; Team at $25 per seat per month for the standard tier. All of them list Claude Code as included.

Set that against the ten cents a turn derived above and the crossover is not subtle:

Anyone using a coding agent daily crosses the Pro line in the first week of the month. That is the whole finding, and it is the reason the subscription is the default answer for a single developer.

The caveat, stated rather than estimated

Subscription plans are rate limited, and the crossover above ignores those limits entirely. The published plan page does not state per-tier Claude Code usage limits, so this page will not put a number on how much work a Pro or Max plan actually permits. What can be said honestly is the direction: the API has no ceiling and bills you for whatever you use, the subscription has a ceiling and does not. If you are running several agents at once and hitting a wall, the wall is the thing to measure, not the price.

Two more things the crossover hides. A subscription bill tells you nothing about which work cost what, because you are not billed per token at all, so the API figure stays the most useful measure of throughput even when it is not your invoice. And the plans are per person: three developers on Pro is $60 a month, not $20.

the three counting mistakes

If you go and count your own spend rather than take this page's worked example, three errors are waiting, and each one is worth a multiple rather than a rounding. All three come from the transcript corpus post, which found them and shows the arithmetic:

• Summing the token classes and pricing at one rate. On that corpus it made the answer roughly six and a half times too high, because 97.7% of the tokens were cache reads priced at a tenth of input.
• Pricing every cache write at the five-minute rate. 99.8% of cache creation tokens in that corpus were the one-hour kind, priced at 2x rather than 1.25x. Skribbl made this mistake in its own meter until 2 August 2026 and says so in that post.
• Counting transcript lines rather than API calls. One response is written once per content block, and resumed sessions copy lines into new files, so 52% of the usage-bearing lines in that corpus were duplicates. Counting lines roughly doubles the answer.

Two of the three push the number up and one pushes it down, which is worse than if they all pointed the same way: a spreadsheet that makes two of them can look plausible while being wrong twice over. If you are going to build a budget on your own numbers, read that post first and get the counting right before the estimating starts. Then decide what to do at the limit, which is a different question and the subject of setting a token budget.

what this page cannot tell you

Three limits, and they are the reason this post prints its assumptions in a box rather than burying them.

The turn shape is chosen, not observed. 120,000 cache reads and 800 output tokens is a plausible mid-session turn calibrated against the one corpus available. It is not your turn. If your sessions are short, your cost per turn is lower and your monthly total is lower with it. If you run long autonomous tasks over a large repository, both are higher.

Rates change, and one of the ones quoted is explicitly temporary. Claude Sonnet 5 is on introductory pricing through 31 August 2026 and rises by half after that. Anything derived from a rate card has a shelf life; this one was read on 7 August 2026.

The subscription ceiling is unquantified here on purpose. See the section above. A number this page cannot verify is a number it will not print.

common questions