Gemini 4 Carbon vs Argon: Cost per Accepted Change
At Standard API rates, Carbon and Argon share a token price but not a bill. Count failed attempts and thinking tokens, then recheck after the 1 December 2026 price change.
For coding, start with Gemini 4 Argon and send the hard reasoning work, such as root-cause debugging or architecture, to Gemini 4 Carbon. That is Google's own split.[1][2] Put Gemini 4 Carbon vs Argon side by side on Google's Standard API rate card and it looks like a tie: the two models charge the same per token. The bill is not a tie. Carbon spends more thinking tokens per turn, and thinking is billed as output.[3][4] So the number to compare is cost per accepted change: everything you were billed, failed attempts included, divided by the changes that actually made it through. Work it out per thinking level, and work it out again after 1 December 2026, when both models' Standard API rates double from $2 input and $10 output to $4 and $20 per million tokens.[4]
The question here is routing: which kind of task goes to which model, at which setting. If you want to know what a single Argon launch demo proves, there is a separate piece on what Argon's launch demos do and do not prove.

Gemini 4 Carbon vs Argon: same token price, different bill
Here are Google's published Standard rates for the Gemini Developer API, per million tokens. These are API rates; subscription plans are priced separately and are not covered here.[4]
| Model | Input, through 30 Nov 2026 | Output incl. thinking, through 30 Nov 2026 | Input, from 1 Dec 2026 | Output incl. thinking, from 1 Dec 2026 | Free tier |
|---|---|---|---|---|---|
| Gemini 4 Carbon | $2.00 | $10.00 | $4.00 | $20.00 | None |
| Gemini 4 Argon | $2.00 | $10.00 | $4.00 | $20.00 | None |
One exception: as of 19 November 2026, Argon also lists an invite-only Contributor tier, in private preview, at $1 input and $5 output per million tokens, on terms where your content is used to improve Google's products. Carbon has no equivalent.[4] If you have been invited onto it, Argon's per-attempt cost is half the Standard figure, which tilts every comparison below further toward Argon. The rest of this piece assumes Standard rates for both; if you pay something else, work the ratios out from your own rates.
Identical rows. Google is direct about where the difference lives: "The main difference is how many thinking tokens each model spends per turn."[3] And the pricing page leaves no room for doubt about whether you pay for them: "Every token the model processes is counted and billed, including thinking tokens".[4] You never read the reasoning, but you pay for every token of it.
How big can the gap get? One public experiment gives a feel for it. A developer on r/ChatGPTCoding ran three office-style tasks three times each, plus ten hard maths problems, through the paid API at default thinking. They reported Carbon's bill at about 4.5x Argon's on the office tasks ($0.0669 against $0.0148) and about 3x on the maths set ($0.1461 against $0.0494), with visible answers of similar length. Accuracy barely moved: 45/45 for Carbon and 44/45 for Argon on the office set, 10/10 each on maths.[5]
That is one person's result on office and maths work, and it should not be scaled up into a coding budget. The author says so plainly: "i didn't test long agentic coding, which is what google says carbon is for".[5] What it does show is the mechanism. Same price per token, very different bill, and the difference came from thinking.
What counts as an accepted change
Pick one definition and hold it fixed: a change is accepted when it passes your build and passes review. Anything else is a failed attempt, and a failed attempt is still a billed attempt.
Researchers reviewing AI agent benchmarks make the same point in general form: evaluations should "account for dollar costs, rather than proxies for cost", and because retrying keeps buying accuracy, cost and accuracy have to be judged together.[6] Their paper predates Gemini 4 and says nothing about these two models, so only the principle carries over.
That includes the quiet failures. Google's max_output_tokens setting caps thinking and output together, and the docs warn you to "Set it high enough that thinking doesn't cut the answer short, and low enough to limit spend when a hard prompt uses all of it."[2] An attempt that runs out of room mid-thought has been paid for and produced nothing you can merge. It goes in the ledger as a failure.
Acceptance is easiest to count when each change stands alone. In a branch-and-preview workflow, for example, accepted means the branch built and a reviewer approved the preview. If several changes are bundled, one bad edit can sink the lot and you lose track of which model earned what, which is why it pays to review each agent change in isolation.
Log the model and the thinking level together
Both models accept a thinking_level of low, medium (the default) or high, and Google's advice is blunt: "Run your evaluations at all three levels, then pick the lowest level that meets your quality bar."[2] That turns a two-way choice into six arms. In the same r/ChatGPTCoding experiment, Carbon at low used no thinking tokens on those tasks, still scored 45/45 and 10/10, and cost about what Argon did.[5] On those tasks, the thinking level moved the bill more than the model did.
So the ledger needs one row per attempt, with these fields:
- task class (for example, routine frontend change or hard root-cause bug)
- model and thinking level
- input, output and thought tokens, from the response's usage block, which reports thought tokens separately[7]
- billed cost, at the tariff in force on that date
- wall time
- outcome: accepted, build failed, review failed or truncated

The outcome column only means something if every attempt faces the same check. Moving the bar between retries makes a model look better or worse than it is, the same problem owners hit when they don't judge every retry by the same check.
The break-even rule
With the ledger in place, the arithmetic is short. The formula below is my own derivation from Google's pricing and positioning; Google does not publish one.
Take one task class at one thinking level. If an attempt costs c on average and a fraction p of attempts are accepted, the expected cost per accepted change is c ÷ p. Call r the ratio of Carbon's per-attempt bill to Argon's. Carbon is cheaper per accepted change only when:
p(Carbon) ÷ p(Argon) > r
Carbon's acceptance rate has to beat Argon's by a bigger factor than Carbon's bill exceeds Argon's. Because no acceptance rate can go above 100%, there is a hard ceiling: once Argon is accepted at least 1 ÷ r of the time, Carbon can at best tie on tokens. If r were 3, the low end of that non-coding experiment, Carbon could only come out ahead on tasks where Argon gets accepted less than about a third of the time.
That lines up with Google's split, if you read the split as a claim about acceptance rates. Where Argon usually lands, as Google's positioning implies it does on most engineering work, Carbon's extra thinking is paid for and not needed. On the hard bug where Argon keeps missing, Carbon's extra spend can pay for itself.
Tokens are only part of the cost. Someone reviews every attempt. Add a review cost per attempt, R, and the comparison becomes (c + R) ÷ p for each model. In the simple form I use below, R is assumed to be the same for both models. Check that assumption against your own reviews: if one model's changes are longer or harder to read, log review cost per model and per level instead.
A worked example with invented numbers
The figures in this table are made up to show the arithmetic. Nothing here was measured, and Carbon's 3x output is an arbitrary pick; I did not borrow the experiment's ratio for code. Both models are assumed to run at medium, the default thinking level.
| Task class (hypothetical) | Model at medium | Tokens per attempt, input / output incl. thinking | Cost per attempt, to 30 Nov | Attempts | Accepted | Cost per accepted change, to 30 Nov | Same, from 1 Dec |
|---|---|---|---|---|---|---|---|
| Routine frontend change | Argon | 120K / 12K | $0.36 | 10 | 8 | $0.45 | $0.90 |
| Routine frontend change | Carbon | 120K / 36K | $0.60 | 10 | 9 | $0.67 | $1.33 |
| Hard root-cause bug | Argon | 400K / 40K | $1.20 | 6 | 1 | $7.20 | $14.40 |
| Hard root-cause bug | Carbon | 400K / 120K | $2.00 | 6 | 3 | $4.00 | $8.00 |
In both rows r is about 1.67. On the routine change, Carbon's acceptance advantage is 9 ÷ 8, about 1.13, so Argon is cheaper. On the hard bug it is 3 ÷ 1, so Carbon is cheaper, despite the bigger bill per attempt.
Now add review cost. With an equal R per attempt, the routine change breaks even when:
R = (p(Argon) × c(Carbon) − p(Carbon) × c(Argon)) ÷ (p(Carbon) − p(Argon))
For these invented numbers that is $1.56 per attempt. If reviewing one attempt costs your team more than that, Carbon's one fewer failure in ten pays for its extra tokens even on routine work. Only your team knows what a review costs, so plug in your own figure.
What 1 December changes
From 1 December 2026, every Standard rate for both models doubles.[4][1] Since both double together, r does not move, and a ledger that counts only tokens gives the same verdict in December as in November.
Add review cost and it stops being that simple. Doubling c without changing R makes tokens a bigger share of each attempt. In the routine example, the review cost Carbon needs to break even rises from $1.56 to $3.12 per attempt. Any task class you sent to Carbon in November because review cost tipped it over deserves a fresh calculation from the ledger; doubling last month's figures will mislead you. Google's pricing page is also a living page, so check it again before you rely on these figures.[4]
Where the rule stops working
The strongest case against all this arithmetic is that tokens are cheap and people are not. If an engineer's review time dwarfs the bill, the argument goes, just use the stronger model and stop counting cents. That is fair, and the review-cost term exists to take it seriously. Google also reports internal results that would help Carbon on exactly the hard tasks, including "more than 2x uplift in success rate for generating secure code over Argon".[8] Google ran that benchmark on its own tasks. If the gain carries over to yours, it raises p(Carbon) where it matters; the ledger is how you find out.
Some limits are worth naming:
- Retries are not independent. If a retry carries feedback from the last failure, its odds change. Use observed attempts per accepted change from the ledger, not 1 ÷ p.
- Time is a cost too. Carbon's longer reasoning means slower turns, and Google's migration notes tell you to make sure
max_output_tokensand HTTP timeouts allow for longer reasoning passes.[2] A truncated attempt is a billed failure. A client-side timeout is at least a failure; log whatever your usage records show it cost rather than assuming it was free. - I found no public measurement for website or app code. The research behind this piece turned up no experiment comparing accepted changes on real site or app work. The r/ChatGPTCoding test was non-coding, small and run by one person, and it said so.[5]
- Subscription users are on different terms. Everything here uses API rates.[4]
None of this produces a universal winner, and that is the honest result. It gives you a way to find the winner for each kind of task you actually run.
Run the ledger for a week
Take one routine change and one hard bug you would normally hand to a model. Run each on Argon and Carbon at two thinking levels, log every attempt, failures included, and work out two numbers per arm: cost per accepted change, and the review cost at which the ranking flips. Two levels make a starter test; the full comparison needs all three. Then do it again after 1 December. If your own Gemini 4 Carbon vs Argon results disagree with Google's default split, that is worth knowing, and worth sharing.
References
- Google, The Keyword blog, “Gemini 4 Carbon is now available” (published 2026-11-10; captured 2026-11-19). Google's positioning of Argon for most software engineering and Carbon for harder multi-step coding and debugging, and the footnote on prices after 30 November 2026. Vendor statement. https://blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-carbon-now-available/
-
Google AI Studio documentation, “What's new in Gemini 4 Carbon” (living documentation; captured 2026-11-19). Carbon's
higher thinking spend per turn, the low/medium/high thinking levels and evaluation advice,
max_output_tokensbehaviour, and migration notes on timeouts. Vendor documentation. https://aistudio.google.com/docs/whats-new-gemini-4-carbon - Google AI Studio documentation, “What's new in Gemini 4 Argon” (living documentation; captured 2026-11-19). Shared context window, tools and per-token pricing with Carbon; the main difference stated as thinking tokens per turn. Vendor documentation. https://aistudio.google.com/docs/whats-new-gemini-4-argon
- Google AI Studio documentation, “Gemini Developer API pricing” (living documentation; captured 2026-11-19). Standard, Batch, Flex and Priority rates for both models before and from 1 December 2026, output price including thinking tokens, no free tier. Vendor price list; recheck before relying on it. https://aistudio.google.com/docs/pricing
- u/ranthishq, r/ChatGPTCoding, “same price per token, 3-4.5x the bill: gemini 4 carbon vs argon at default thinking” (posted about 2026-11-11; captured 2026-11-19). Third-party experiment on office and maths tasks: bills, thinking tokens, accuracy and the low-thinking result. Not a coding benchmark, as the author states. https://www.reddit.com/r/ChatGPTCoding/comments/1xtlk8o/same_price_per_token_345x_the_bill_gemini_4/
- Sayash Kapoor, Benedikt Stroebl, Zachary S. Siegel, Nitya Nadgir and Arvind Narayanan, “AI Agents That Matter”, arXiv:2407.01502 (submitted 2024-07-01; captured 2026-11-19). Argues agent evaluations should be cost-controlled and account for dollar costs alongside accuracy. Independent research preprint; predates Gemini 4. https://arxiv.org/abs/2407.01502
- Google AI Studio documentation, “Gemini thinking” (living documentation; captured 2026-11-19). Usage metadata reports thought tokens separately from input and output tokens. Vendor documentation. https://aistudio.google.com/docs/thinking
- Google, The Keyword blog, “Introducing Gemini 4 Carbon” (published 2026-10-28; captured 2026-11-19). Google's internal benchmark claim of more than 2x success-rate uplift over Argon for generating secure code. Vendor internal result, not an acceptance rate on reader code. https://blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-carbon/