AI Coding Tools Cost Analysis: A Model for a 30-Person Org

Search “ai coding tools cost analysis” and the first page is a FinOps vendor, two engineering-analytics vendors, a price tracker that updates weekly, and a handful of listicles. They agree on the shape of the problem: every major vendor has moved from a seat to a seat plus a meter, the seat is a floor, and the bill depends on usage nobody is measuring. Then each of them reaches for a demo button. None models the cost for an engineering organization rather than one developer, none separates token price from task cost with data, and none says who in the org is accountable for the number once it exists.

This is the cost guide for the engineering leader who has to put a figure in next quarter’s budget. Every price below was read from the vendor’s own page on October 23, 2026 and is linked, because they move. It builds the model for a 30-person org three ways, shows why the published studies disagree about whether cheaper models are cheaper, names where the arithmetic breaks, and ends on the lever YAGNI pulls: one rate card, no seats, a router that places each step on the cheapest lane that holds quality, and a case file that shows what a ticket cost to ship. It is the hub for a series of six cost posts, and each section links to the one that goes deeper.

What do AI coding tools cost in October 2026?

The sticker prices, per developer, from each vendor’s own page. Read them before you budget and again before you renew; the one thing every ranking explainer gets wrong is quoting a price six months old.

Tool	Individual plans	Team or business seat	What the seat includes	Where the meter starts
Claude Code (Anthropic pricing)	Pro $20 a month ($17 annual); Max from $100	Team Standard $20 a seat billed annually ($25 monthly); Team Premium $100 ($125 monthly); Enterprise $20 a seat annually, 20-seat minimum, plus usage at API rates	Claude Code on every paid seat, within a five-hour and weekly allowance that is not published as a token count	Usage credits at Anthropic’s API rates once the allowance is spent; every token from day one on Enterprise
Cursor (Cursor pricing)	Plus $8, Premium $30, Super $100, Ultra $200 a month	Teams from $30 a user a month, pooled usage, mixed seat types; Enterprise is custom	A pool of usage that refreshes weekly, with spending caps	Third-party models billed by usage at API list price, on top of the pool
GitHub Copilot (Copilot plans)	Pro $10 with 1,500 AI credits; Pro+ $39 with 7,000; Max $100 with 20,000	Business $19 per granted seat with 1,900 credits per user, pooled; Enterprise $39 with 3,900	One AI credit is $0.01, so a Business seat carries $19 of usage	Overage at $0.01 per credit, per the billing docs
Codex (OpenAI plan pricing)	Plus $20; Pro from $100 ($100, $200, or $500 tiers)	Business $20 a user a month billed annually ($25 monthly), two users minimum; Enterprise is contact sales	Codex included on every plan, with message allowances per five-hour window on Plus	Enterprise usage scales with credits; the API bills per token, GPT-5.6 Sol at $4 in and $20 out per million
Hosted open-weight models (Together, DeepInfra)	None; per token	None	Nothing but the tokens	From the first token: GLM-5.3 $1.40 in and $4.40 out per million; DeepSeek V4 Pro $1.32 and $3.96 on Together, $1.30 and $2.60 on DeepInfra; Kimi K3 $3 and $15
YAGNI	None; per token on one rate card	No seats. A developer with zero usage costs zero	YAGNI Code, Claude Code or Codex through the wire adapter, and the named Agents on a Team, all on the same card	From the first token, across four lanes, at 60% or more under comparable frontier API rates; the rate card is shared on a call

Two things to read off that table. The seat prices have converged: $19 to $30 for a standard business seat on every tool, with a premium seat at $100 or so for the people who live in the agent. And every tool has a second column that starts with “once” or “on top of”. That second column is the cost analysis. The first is the floor.

For the per-plan detail on the biggest line, how much Claude Code costs walks every Anthropic plan and the API table, and the Claude Code Team plan does the seat arithmetic for a 30-developer rollout.

Why is the seat price not the bill?

Because the seat buys an allowance, and the allowance is not a cost. It is a ceiling that hides the cost until it is reached, and then a meter that reveals it late.

Three mechanics do this on every tool. First, the allowance is not published as tokens. Anthropic’s spec for a Premium seat is “five times Standard”. Cursor’s is “4x”, “15x”, and “50x more usage compared to Plus”. Copilot’s is the only one denominated in dollars, 1,900 credits at a cent each, and it is pooled across the org, so one heavy developer draws down twenty light ones. Second, usage inside the allowance is never metered in dollars. On a Claude Team plan the spend report shows usage-credit spend only, once an admin turns credits on; what happened inside the seat is invisible. Third, the overage is billed at a different rate from the seat. Credits at API rates, third-party models at list price, a cent a credit. The budget line has one number on it and the invoice has two.

The consequence for a manager is a question with no answer: “what did Priya spend on the agent last month” is “we do not know, unless she ran out and bought credits”. Claude Code token usage goes through all five of Anthropic’s reports and where each one stops; the short version is that every one of them is per user and per model, and none is per unit of work.

The second consequence is a second meter. A seat is a person’s login. The moment the org adds anything that runs unattended, a review in CI or an agent that takes tickets, it needs its own API key in a separate workspace, with its own limits and its own report. Developers on seats, automation on a key, a third bill if anyone also runs a second tool, and no page where a developer’s session and an agent’s work sit side by side.

What does Claude Code vs Cursor cost for a team?

The pairwise question that ranks on its own, answered for a team rather than a laptop.

At the seat, as of October 2026, a Claude Team Standard seat is $20 a month billed annually and a Cursor Teams seat starts at $30; for ten developers that is $200 against $300 a month before anyone types. The premium end is also close: a Claude Team Premium seat is $100 and Cursor’s Super and Ultra individual plans are $100 and $200. Seat for seat there is no decision here.

The meters are built differently, and that is the decision. Claude Code on a Team seat runs inside an allowance shared with Claude chat, and when a developer runs out they wait or spill onto usage credits billed at Anthropic’s API rates, with a per-member limit an admin sets. Cursor pools usage across the team and refreshes it weekly, and third-party models, which for a coding agent means the frontier models most developers pick, are billed at API list price on top of the pool. So a Cursor team’s bill tracks which models its developers choose, and a Claude Code team’s bill tracks how many developers hit the ceiling and how often. Neither seat price predicts the invoice; the model habit and the heavy-user count do.

The comparison pages that rank for this query run a hypothetical month of tokens through both and declare a winner. The honest answer is that the two tools cost about the same at the seat, differ on the meter in ways that depend on your developers’ habits, and share the gap this guide is about: both report per user and per model, and neither can tell you what a change cost to ship. The same Claude Code, connected to YAGNI with one command, runs at 60% or more under comparable frontier API rates with the spend per developer on one page; use Claude Code with open source models covers the mechanism and where it breaks.

What does a 30-person engineering org actually pay?

The model, with the prices above and nothing invented. The org has 30 developers, eight of whom live in a coding agent all day and 22 who use one most days for an hour or two. Annual billing where it exists. Each row is a way the org could pay this quarter.

How the org pays	Seat bill a month	The metered layer	Total a month
Copilot Business for everyone, inside the pooled credits	$570	$0 while the pool of 57,000 credits ($570) holds; $0.01 a credit after	$570, then up
Claude Team, 22 Standard and 8 Premium seats	$1,240	The eight heavy developers spill four active days a month at Anthropic’s $13 a day: about $416 in usage credits	About $1,656
Cursor Teams at the floor	$900	Third-party models at API list price, unbounded until a spending cap is set	$900, then up
ChatGPT Business with Codex, annual	$600	Message allowances per window on the plan; API usage separately for anything unattended	$600, then up
Everything on an API key at Anthropic’s average	$0	$150 to $250 per developer per month, per Anthropic’s cost docs	$4,500 to $7,500
The stack most orgs actually run: Copilot plus Cursor plus a Claude Team	$2,710	Three meters: credits, list-price models, usage credits	$2,710, then up on three invoices

Read the right-hand column as a range: $570 to $7,500 a month for the same 30 people, and the pricing pages cannot tell you where in it you will land. That is the first finding of any honest cost analysis. If you are not measuring, you do not know.

The second finding is in the stacked row. Most engineering orgs did not pick one tool. Copilot came with GitHub, Cursor came with the developers, and Claude Code came with the agents. $2,710 a month before a metered token is the real floor for a lot of 30-person teams, and the three meters behind it are reported in three places, per user, per model, never per ticket.

The one number in that table that is not a list price is Anthropic’s $13 per developer per active day, which it publishes as its own median across enterprise deployments, with 90% of users under $30 a day. Treat it as the shape of the overflow, not its size. A developer on a Premium seat spills only on the days the allowance runs out; a developer on an API key spills from the first turn.

Why is token price not task cost?

Because the invoice counts tokens and the team spends attention, and three studies published this year measured the difference on real repositories.

Databricks ran coding agents against its own multi-million-line codebase in July 2026, on tasks drawn from merged internal pull requests with held-out tests. GLM 5.2, an open-weight model, cost $1.28 per completed task and was statistically tied with Opus 4.8 on quality. Opus 4.8 cost $1.94 at 87% completion. Sonnet 5 cost $2.09 at 81%, more than Opus despite a lower token price, because it used more tokens. The same model called from a different harness moved the cost per task by more than two times with quality unchanged.

Faros ran 211 tasks across twelve repositories in June 2026 and found the same ordering: Claude Code with GLM 5.2 at $0.92 a task scored higher on its judge than Claude Code with Opus 4.8 at $1.76 and Codex with GPT-5.5 at $2.06.

Insight took one feature to a merged pull request across a dozen models and three harnesses in July 2026, with the same review gate on every run, and got the opposite ordering. The range was $2.59 to $34.82 for the same merged feature. Opus 4.8 on Claude Code merged for $9.98 in 26 minutes, the fastest run. GLM-5.2 cost $14.95 and took 176 minutes, the slowest. Same feature, same gate, and the open-weight model cost more to a merge than the frontier model, because it took more turns to get there.

Put the three together and the lesson is not “open-weight wins” or “frontier wins”. The per-token price predicted almost nothing in any of them. On a large, well-structured codebase with a strong scaffold, the cheaper model finished as often as the frontier one at a third of the cost. On a single hard feature with a strict merge gate, the retries ate the saving and then some. The best open source LLM for coding lays out the field with licenses, harness-tagged scores, and dated prices; the finding to carry into a budget is that the number to manage is dollars per merged pull request, measured on your repositories, and no pricing page can give you that.

Here is what the token arithmetic looks like on one ticket, so the gap is concrete. A change to a checkout service, seven steps from reading the ticket to writing the record, 1.71 million input tokens and 78 thousand output before prompt caching, at the October 2026 list prices in the table above:

How the ticket runs	Ticket total	One Build retry added
Everything on Opus 5.5 ($4 in, $20 out)	$8.40	$11.60
Routed per step: reads and tests on Haiku 5.5, build on Sonnet 5.5, plan and review on Opus 5.5	$3.65	$5.25
Everything on GLM-5.3 ($1.40 in, $4.40 out)	$2.74	$3.76
Everything on DeepSeek V4 Pro ($1.32 in, $3.96 out)	$2.57	$3.52

The retry column is the one a pricing page cannot show. Each retry is a build, a review, a send-back, and a second build, and the reviewer’s hour reading a diff that was wrong does not appear in any column. Two retries on a hard ticket and the cheap model has spent more of your engineers’ attention than the frontier model that finished first, even with a token bill a third the size. How an LLM router cuts coding cost walks that ticket step by step and shows why routing per step, with the plan and the review on the strongest model, is the shape that holds.

Where does the math break?

Honest arithmetic names its own failure modes. Five, in the order they will bite.

Hard tasks favor the frontier. Insight’s result is the general case for a long, multi-service change behind a strict merge gate. A model that needs three attempts costs more than one that needs one, in tokens and in hours. A migration touching three services is a frontier-model ticket from the first step, and forcing it cheap makes it dearer. When a team’s task mix is hard enough for the frontier premium to pay for itself, YAGNI says so on the call rather than pretend the floor is free.

Cross-model comparisons flatter the newest models. Newer tokenizers emit more tokens for the same text, and the makers have stopped agreeing on a benchmark, so a score from one harness and a price from one host are not the same exam. Compare on your tickets, not on a leaderboard.

Self-hosting wins only at scale. Running the weights yourself beats a hosted API at billions of tokens a month with high utilization. Below that, hosted open-weight is the practical path, and the same weights vary in price across hosts: DeepSeek V4 Pro’s output token runs from $2.60 to $3.96 per million depending on the host, as of October 2026.

Vendors reprice. Cursor’s plan names and prices changed between the summer and this reading; Copilot moved from premium requests to AI credits; Anthropic’s default model moved to Opus 5.5 and its per-developer median doubled without a list-price change. A budget built on a screenshot is wrong by the renewal.

Retries eat everything. The cheapest token is the one a retry never spends, and no lane is cheap enough to make four runs cost less than one. Which is the reason the next section is about context rather than models.

Why does context lower retries more than model choice?

Because the retry starts upstream of the model. An agent that does not know why the ticket exists guesses, builds the wrong thing competently, and finds out at review. The tokens it spent were a fraction of the cost; the reviewer’s hour and the second build are the rest.

Here is the bet YAGNI is built on, and you should stress-test it on the call: most of the spread between “a third of the cost per task” and “more expensive to a merge” is context, not model quality. An Agent that reads the Team’s decision ledger, the connected tools, and the Playbook rules a reviewer’s corrections left behind, before it plans, produces less off-target output and takes fewer retries. A cheaper model grounded in your decisions beats an expensive one guessing on your repository. Context engineering for coding agents is the long version of where that context lives.

The mechanism on a YAGNI Team is a plan a person approves before a line is written. Reeve, the Staff Engineer, reads the ticket, the linked Slack thread, and the Team’s decision ledger, and states the facts it checked and the ones it planned on. A person approves the plan. A plan built on a misread ticket costs one send-back, not a build and a review. That is the cheapest possible place to catch the wrong turn, and it is a management checkpoint, not a model feature. Spec-driven development with AI covers the Plan stage in detail.

How does YAGNI change the bill?

YAGNI is additive. It reads the GitHub, Jira, Linear, and Slack the team already pays for and ships approved work back into them. Developers keep the harness they chose. Three things change on YAGNI.

No seats. A developer with zero usage costs zero. There is no allowance, so there is nothing hidden inside one, and no second meter, because developers and Agents bill on the same card. The questions in the stacked row above, three invoices reported three ways, collapse to one page.

One rate card, four lanes. YAGNI publishes four lanes, Efficient, Standard, Advanced, and Peak, each with a per-million-token price, locked for twelve months per contract while the models underneath rotate. As better models land, the lanes are upgraded and the rate does not move. The models are vetted US-hosted open-weight models, and the floor across the card is 60% or more under comparable frontier API rates. A router places each step of a run on the cheapest lane that holds quality and escalates when it would not, so the plan and the review run strong and the reads and test logs run cheap, which is where the per-task studies say the money should go. YAGNI does not publish which models serve which lane; the rate card is shared on a call, and the floor is the only public number.

The same harness, on the meter. YAGNI Code is the developer’s own coding agent, a CLI and desktop app on those lanes. Developers who keep Claude Code or Codex connect them with one command:

yagni connect claude-code

It writes the CLI’s own settings file, so the CLAUDE.md, the skills, and the MCP servers stay as they were, and --off removes it again. After a restart the same session runs on YAGNI’s lanes and its spend lands on YAGNI’s Usage page: spend, the parked-at-frontier benchmark, and savings, per developer and per Agent, with each Agent’s spend broken out by the job that spent it. A daily spend ceiling in Workspace settings is the brake, and a Team’s Pause stops every job on the Team at once.

Run the 30-person model again with that lever. The seat column goes to zero. The metered column is the same work at 60% or more under the comparable frontier rate, on one meter, visible per developer from the first token. The stacked row’s three invoices become one page. And the retry column, the one no pricing page shows, is the one the next section is about.

What does a ticket cost when an Agent Team carries it?

The per-ticket answer comes from the Team, because that is where YAGNI puts a unit of work on the meter.

An Agent Team on YAGNI mirrors one of your engineering teams and reports to one accountable person. A ticket moves through six stages, each owned by one named Agent, with a person at the three points that matter. Bailey, the Product Manager, proposes it from the backlog in Jira or Linear with evidence, and the proposal waits for a person to accept it. Reeve, the Staff Engineer, plans it, reading the ticket, the Slack thread, and the Team’s decision ledger first, and a person approves the plan. Wright, the Builder, builds it to a draft pull request in a sandbox on GitHub. Proctor, the Reviewer, runs its checks and posts one review a person can read. Fletcher, the QA Agent, in beta, boots the environment and walks the change in a browser with video attached. A person merges. Harper, the Chronicler, posts what shipped to Slack with the receipts.

Every one of those runs is metered on the same YAGNI rate card the developers are on, and the ticket’s case file shows what the workspace was charged for each of them. So the question this whole guide has been circling has a plain answer:

The budget review’s question	Seats and a spend report	YAGNI
What did each developer spend this month?	Credit or overage spend per user, once the allowance is exceeded	Spend per developer on the Usage page, from the first token
What did the coding agents spend?	A separate API workspace and report	The same page, per Agent, broken out by job
What did ticket PAY-212 cost, end to end?	Not available	One row on the case file: proposal, plan, build, review, QA, merge
Was the plan send-back cheaper than the build it prevented?	Not available	Two rows on the same case file
What would the same work have cost at the frontier?	Not available	The parked-at-frontier benchmark beside the spend
Who approved what, and when?	Not recorded	Each click a person made, beside the run it gated

That last row is the accountability the FinOps pages leave out. A cost nobody owns is a cost nobody manages. On a YAGNI Team the owner is a named person, the brake is theirs, the plan is theirs to approve, and the merge is always their click. The Team carries engineering work you would otherwise staff for, and the case file says what it cost. AI tools for engineering managers shows the Usage page from a manager’s morning, and the guide to AI agents for software development covers the Team the meter is attached to.

How should an engineering leader budget AI coding tools for next quarter?

In order, with the prices above.

1. Count the heavy developers honestly. The eight-and-22 split decides every row of the model. A premium seat costs five standard ones; it is cheaper than the credits a heavy developer would otherwise burn and dearer than a standard seat for anyone who never hits the ceiling.
2. Put the metered layer on the budget line. Turn overage reporting on from day one, with per-member limits, and export it monthly. Anthropic’s $13 a day median is the shape to plan around until you have your own.
3. Count the meters. One per tool, plus one for anything unattended. If the number is more than one, nobody in the org can see the whole bill, and that is a finding before any price is.
4. Change the default model for routine work. Opus 5.5 at $4 and $20 per million tokens against Sonnet 5.5 at $2 and $10 is the largest single lever on a Claude bill, and a router does it per step without relying on a habit.
5. Measure dollars per merged pull request on twenty real tickets. Take last month’s mix, from a config flip to a multi-file migration, run each on the frontier model and on an open-weight lane with the same harness, and record whether it reached a mergeable pull request, how long the reviewer spent, and what it cost. The split you find is your routing policy and your budget.
6. Decide where the agents live before you add one. On seats, that is a second meter. On YAGNI it is the same meter as the developers, with each Agent’s spend per job beside the people’s and each ticket’s cost on its case file.

The sixth step is where the arithmetic stops being about tools. A manager who can read what each ticket cost has a different budget conversation than one holding three per-model CSVs.

Where does each post in this guide go deeper?

This is the hub for the series on what AI coding costs. Each post takes one line of the model further.

• How much does Claude Code cost? Plans, API, and team math Every Anthropic plan and API price, linked and dated, and the arithmetic for a team of ten.
• Claude Code Team plan: budgeting a rollout for your org Seats versus usage credits, the pooled API credits that do not fund the CLI, and the 30-developer rollout three ways.
• LLM router: how model routing cuts AI coding cost One ticket routed step by step, how a router knows the cheaper model held, and YAGNI’s four lanes.
• Best open source LLM for coding: price is not task cost The open-weight field with licenses, harness-tagged scores, dated prices, and the three studies that disagree.
• Claude Code token usage: what your team can and cannot see Where the tokens go, the five Anthropic reports, and where every one of them stops.
• Use Claude Code with open source models: keep the harness The gateway mechanism from Anthropic’s own docs, the team rollout question, and YAGNI’s wire adapter.

Where to start

Count the meters. If the answer is three, the cost analysis is already done: nobody can see the bill, and the first thing to buy is one page that shows it.

Then run the twenty-ticket evaluation above on your own repositories, with your own harness and skills, and keep two numbers per ticket that no pricing page prints: whether it merged, and how long the reviewer spent. Spend the frontier premium where a person reads the output, the plan and the review, and save it where a check does. Keep the hard tickets on the strongest lane and say so in the policy.

If you want the 30-person model run on your org’s numbers, book 30 minutes and bring your seat counts, your current plans, and one ticket you consider hard. We will connect a session on the call, run the ticket, and send the arithmetic back with the rate card. YAGNI runs agent teams, managed like your engineering team: Bailey proposes, Reeve plans, Wright builds to a draft pull request, Proctor reviews, Fletcher (beta) walks the change, and Harper reports, with merge always a person’s click, on vetted US-hosted open-weight models at 60% or more under comparable frontier API rates, usage-based on one rate card, and the offer is on the home page.