Malhar Ujawane

Blog

Post·

Gemini 4 Carbon pricing: same as Opus 5.5, except the cache

Gemini 4 Carbon will cost $4/$20 per million tokens after its intro price, the same as Opus 5.5. Its implicit-only cache decides which is cheaper.

Gemini 4 Carbon pricing: same as Opus 5.5, except the cache

Google announced Gemini 4 Carbon on October 28, 2026, two weeks after Gemini 4 Argon. You can’t call it yet: Google is giving it to a subset of cyber defenders first and widening access through its Fairwind Program, with developers “as soon as possible”.

The price is already public, and it lines up exactly with Anthropic’s. After the introductory period Carbon costs $4 per million input tokens and $20 per million output, with cached input at 95% off. That is Claude Opus 5.5’s price to the cent. So the question for anyone running agents is which one has the cheaper cache, and that depends on a number Google doesn’t let you set.

There are no hands-on results in this post because I don’t have Carbon access. Everything below is pricing math from the vendors’ own pages plus a small cost model, with the code, its output and the assumptions written down.

What does Gemini 4 Carbon cost?

Here are the list prices I checked on October 29, 2026, in USD per million tokens:

Model Input Cache read Cache write Output Source
Gemini 4 Carbon (intro) $2.00 $0.10 none $10.00 Google blog
Gemini 4 Carbon (after intro) $4.00 $0.20 none $20.00 same post, footnote 1
Gemini 4 Argon $2.00 until Nov 30, then $4.00 $0.10, then $0.20 none $10.00, then $20.00 Gemini API pricing
Claude Sonnet 5.5 $2.00 $0.10 $2.50 (5 min) $10.00 Claude pricing
Claude Opus 5.5 $4.00 $0.20 $5.00 (5 min) $20.00 same page

Two things stand out. Carbon at its intro price is Sonnet 5.5’s price, and Carbon after the intro is Opus 5.5’s price. Google hasn’t said when Carbon’s intro period ends. Argon’s ends on November 30, 2026, so I’d plan on the $4/$20 number from day one.

The cache rows are where they differ. Anthropic charges 1.25x input to write a 5-minute cache entry and 0.05x to read it on Opus 5.5 and Sonnet 5.5. Gemini charges nothing to write, because you can’t write: the caching docs say explicit caching “is not supported” for Gemini 4 Argon and onward. Implicit caching is the only option.

Why does caching decide an agent’s bill?

An agent loop resends its whole context on every turn: system prompt, tool definitions, every tool result so far. I covered the mechanics in what is a context window. By turn 30 almost all the input tokens are ones the model has already seen, so the cache-read price matters more than the input price. Max Woolf made the same point about coding agents, and I linked it earlier this week.

With Anthropic you mark cache breakpoints yourself. If the prefix matches and the entry is less than 5 minutes old, the read is billed at the cache rate.

With Gemini 4 the cache is implicit. The docs describe it as automatic, with a minimum of 4,096 input tokens, and give two tips: put large shared content at the start of the prompt, and send requests with a similar prefix close together. They also add a rule that matters for agents:

Gemini caches the full previous request only if the new request adds at least 2,050 tokens. Model output, thought, and function results all count toward this total. For smaller additions, Gemini re-processes the last 2,050 tokens of the previous request at the standard input rate.

The response tells you what you got in usage.total_cached_tokens. It doesn’t let you ask for a hit.

A cost model for one agent session

I wrote the smallest model that captures both billing schemes. One session has 40 turns, a 20,000-token prefix and 1,500 output tokens per turn. I ran two turn sizes: a tool-heavy turn that grows the context by 6,000 tokens, and a chatty turn that grows it by 2,000, just under Gemini’s 2,050 line.

For Gemini, hit_rate is the chance that a turn finds the previous request in the implicit cache. On a miss the whole context is billed at the input rate. For Anthropic I assume every explicit cache read hits, which is the best case for Opus and Sonnet.

# carbon_cost.py: cost of one agent session on Gemini 4 Carbon vs Claude Opus 5.5 / Sonnet 5.5.
# Prices in USD per 1M tokens, from the vendors' pages on 2026-10-29.
PRICES = {
    #                  input  cache_write  cache_read  output
    "carbon-intro":    (2.00, None,        0.10,       10.00),  # implicit cache, no write fee
    "carbon-standard": (4.00, None,        0.20,       20.00),  # after the intro period
    "sonnet-5.5":      (2.00, 2.50,        0.10,       10.00),  # 5-minute cache write
    "opus-5.5":        (4.00, 5.00,        0.20,       20.00),
}

PREFIX = 20_000   # system prompt + tool definitions
TURNS = 40
OUTPUT = 1_500    # output + thinking tokens per turn
MIN_ADD = 2_050   # Gemini 4: smaller additions re-process the last 2,050 tokens

def session_cost(model, added_per_turn, hit_rate=1.0):
    inp, write, read, out = [p / 1e6 for p in (PRICES[model][0], PRICES[model][1] or 0,
                                               PRICES[model][2], PRICES[model][3])]
    implicit = PRICES[model][1] is None
    total = 0.0
    prev = 0
    for turn in range(TURNS):
        ctx = PREFIX + turn * added_per_turn
        new = ctx - prev
        if turn == 0:
            cost = ctx * (inp if implicit else write)
        elif implicit:
            if new >= MIN_ADD:
                cached, fresh = prev, new
            else:
                cached, fresh = prev - MIN_ADD, new + MIN_ADD
            hit = cached * read + fresh * inp
            miss = ctx * inp
            cost = hit_rate * hit + (1 - hit_rate) * miss
        else:
            # explicit breakpoint at the end of every request: read the old prefix, write the new part
            cost = prev * read + new * write
        total += cost + OUTPUT * out
        prev = ctx
    return total

for added in (6_000, 2_000):
    final = PREFIX + (TURNS - 1) * added
    print(f"\n{TURNS} turns, +{added:,} tokens/turn, final context {final:,}")
    print(f"{'model':<16}{'hit 100%':>10}{'hit 90%':>10}{'hit 70%':>10}{'hit 0%':>10}")
    for m in PRICES:
        if PRICES[m][1] is None:
            row = [session_cost(m, added, h) for h in (1.0, 0.9, 0.7, 0.0)]
        else:
            row = [session_cost(m, added)] * 4
        print(f"{m:<16}" + "".join(f"{c:>10.2f}" for c in row))

# Break-even implicit hit rate: where carbon-standard costs the same as opus-5.5
for added in (6_000, 2_000):
    target = session_cost("opus-5.5", added)
    lo, hi = 0.0, 1.0
    for _ in range(50):
        mid = (lo + hi) / 2
        if session_cost("carbon-standard", added, mid) > target:
            lo = mid
        else:
            hi = mid
    if session_cost("carbon-standard", added, 1.0) > target:
        print(f"+{added:,}/turn: carbon-standard costs more than opus-5.5 even at a 100% hit rate")
    else:
        print(f"+{added:,}/turn: carbon-standard matches opus-5.5 at a {hi:.1%} hit rate")

Output with Python 3.13.5:

40 turns, +6,000 tokens/turn, final context 254,000
model             hit 100%   hit 90%   hit 70%    hit 0%
carbon-intro          1.63      2.62      4.61     11.56
carbon-standard       3.26      5.25      9.22     23.12
sonnet-5.5            1.76      1.76      1.76      1.76
opus-5.5              3.52      3.52      3.52      3.52

40 turns, +2,000 tokens/turn, final context 98,000
model             hit 100%   hit 90%   hit 70%    hit 0%
carbon-intro          1.17      1.59      2.42      5.32
carbon-standard       2.35      3.18      4.84     10.64
sonnet-5.5            1.07      1.07      1.07      1.07
opus-5.5              2.14      2.14      2.14      2.14
+6,000/turn: carbon-standard matches opus-5.5 at a 98.7% hit rate
+2,000/turn: carbon-standard costs more than opus-5.5 even at a 100% hit rate

A line chart of session cost against Gemini’s implicit cache hit rate from 80% to 100%. Carbon at $4/$20 falls from $7.23 at 80% to $3.26 at 100% and crosses Opus 5.5’s flat $3.52 at 98.7%. Carbon’s intro price crosses Sonnet 5.5’s $1.76 at the same point.

What the numbers say

With perfect hits, Carbon is 7% cheaper than Opus. $3.26 against $3.52 for the tool-heavy session. The whole gap is the cache write fee: Opus pays $5 per million to write each turn’s 6,000 new tokens, and Carbon bills them as plain $4 input. That’s $1 per million on about 254,000 written tokens, or $0.26.

Every missed turn costs far more than that. A miss on turn 30 bills roughly 200,000 tokens at $4 instead of $0.20. At a 90% hit rate the session costs $5.25, 49% more than Opus. Carbon breaks even with Opus at a 98.7% hit rate, and the same line holds for Carbon’s intro price against Sonnet 5.5, because both pairs are priced in the same ratio.

Small turns lose even with perfect hits. When a turn adds fewer than 2,050 tokens, Gemini re-processes 2,050 tokens of the previous request at the full input rate. In the chatty session that costs about $0.30 over 39 turns, more than Opus’s write premium, so Carbon comes out at $2.35 against Opus’s $2.14 even at 100%.

Where this model is wrong

  • I don’t know Carbon’s real implicit hit rate, and Google doesn’t publish one. The whole post turns on that number, and you can only measure it once you have access.
  • I assumed Anthropic’s explicit cache always hits. A tool call that takes longer than 5 minutes lets the entry expire, and then Opus pays a full write again. The 1-hour cache costs $8 per million to write on Opus 5.5, which moves the line.
  • Real agents don’t grow by a fixed amount per turn. Some turns read a 50,000-token file, some add 300 tokens of reasoning.
  • I left out batch, flex and priority tiers, search grounding fees and Anthropic’s US-only inference multiplier.

The benchmark claims are Google’s too. Carbon’s 88.2% on SEC-bench Pro, 54.8% on ExploitGym and 71.0% on CWE-bench were “evaluated without guardrails”, per the announcement. I haven’t seen independent numbers yet.

What I’d do before moving an agent to Carbon

  1. Price it at $4/$20 from the start. If I’m quoting a client a fixed monthly cost, an intro price that ends on a date Google hasn’t announced is a risk I’d carry, so I wouldn’t quote it.
  2. Log the cache fields on every turn: usage.total_cached_tokens on Gemini, cache_read_input_tokens and cache_creation_input_tokens on Anthropic. Divide cached tokens by the previous turn’s context to get the hit rate the model above needs.
  3. Keep the prefix byte-stable. Tool definitions first, then the system prompt, with no timestamps or request IDs near the top. That’s Google’s own advice for implicit hits, and it helps on Anthropic too.
  4. Watch turn sizes. If most turns add fewer than 2,050 tokens, batch small tool calls into one turn or accept the re-processing cost.
  5. Run the same eval on both before switching. I wrote about Opus effort settings and Kimi K3.1 Pro session costs with the same rule: compare cost per solved task, not per token.

Where I think pricing is heading

My opinion: per-token prices across the frontier labs are converging, and the real competition is moving into cache mechanics and tokens per task. Carbon matching Opus 5.5 to the cent is one data point. Anthropic’s S-1 saying 80% of revenue is metered tokens and that it competes on cost per task is another (I linked it here). OpenAI’s GPT-6.1 Terra also prices cached input at 5% of the input rate (model page).

If that’s right, the useful comparison table for 2027 has a column for “who controls the cache” next to the price. What would change my mind is Google publishing a guaranteed hit rate or bringing back explicit caching for Gemini 4.

Get new posts in your inbox

© 2026 Malhar Ujawane. Built with Astro.