GO TO A SECTION

↑ ↓ to navigate · Enter to openExplore all sections →
FDEInterviews logo

Gemini 4 Neon vs Carbon vs Hydrogen: The December 1 Price Flip, the Thinking Default, and What Breaks When You Migrate

Gemini 4 Neon costs $3 / $15 per million tokens and defaults to high thinking. Until November 30 Carbon is cheaper per token; from December 1 it is not. A break-even rule you can compute, and the migration changes that catch teams out.

BY MEI LIN · FDEINTERVIEWS EDITORIAL · UPDATED NOVEMBER 19, 2026 · 7 MIN READ

PRACTICE THIS:Choosing between Gemini 4 models ·Learn model routing ·Measure regression before migrating a model ·LLM and GenAI questions

Gemini 4 Neon is Google's new middle model: $3.00 per million input tokens and $15.00 per million output tokens, defaulting to the high thinking level, positioned between Gemini 4 Hydrogen and Gemini 4 Carbon. Two dated facts change how you should test it. Until November 30, 2026, Carbon and Argon are cheaper than Neon per token, at $2.00 / $10.00. From December 1 they rise to $4.00 / $20.00 and the order flips. And because every Gemini 4 rate card has the same shape, you can reduce the whole comparison to one ratio per task: Neon is cheaper than Carbon if it uses under 67% of Carbon's weighted tokens before December 1, and under 133% after. Measure that ratio on your own tasks. Google's claim of "leaner token usage" is exactly the thing to verify.

This post extends our Gemini 4 model selection guide, which covered Hydrogen, Argon, Carbon and Flash-Lite. Every price and default below is from Google's pricing page and Neon developer guide, checked on 19 November 2026. We made no paid API calls; the arithmetic runs locally.

Where Neon sits

Google's guidance puts the four Gemini 4 models in a line. Hydrogen stays "the default for everyday coding and agentic workflows." Carbon is for "your hardest architecture, debugging, science, and security problems." Neon goes between them, for complex engineering, knowledge work and science where you want frontier-level quality with faster end-to-end completion.

HydrogenNeonArgonCarbon
Model IDgemini-4-hydrogengemini-4-neongemini-4-argongemini-4-carbon
Input, per 1M tokens$1.50$3.00$2.00 to Nov 30, then $4.00$2.00 to Nov 30, then $4.00
Output incl. thinking, per 1M$7.50$15.00$10.00, then $20.00$10.00, then $20.00
Cached input, per 1M$0.075$0.15$0.10, then $0.20$0.10, then $0.20
Default thinking levelhighhighmediummedium
Highest thinking levelxhighxhighhighhigh
Free tierYesNoNoNo

Standard paid-tier prices on the Gemini Developer API. Batch, Flex, Priority and enterprise regional prices differ. On Google Cloud's Agent Platform, the Neon model page says it is available "to verified enterprise customers in select regions," so check availability before you design around it.

The price ladder only tells half the story, and the figure shows why the December change matters.

Same models, different order on December 1Hydrogen: $1.5 input to November 30, $1.5 input from December 1.. Neon: $3 input to November 30, $3 input from December 1.. Argon: $2 input to November 30, $4 input from December 1.. Carbon: $2 input to November 30, $4 input from December 1.. Until November 30 Neon is the most expensive Gemini 4 model per token. From December 1 Argon and Carbon cost a third more than Neon. Same models, different order on December 1 Gemini Developer API paid tier, USD per 1M tokens, checked 19 November 2026. Output is five times input on every card. Input price to Nov 30 Input price from Dec 1 Hydrogen $1.50 in / $7.50 out $1.50 in / $7.50 out Neon $3.00 in / $15.00 out $3.00 in / $15.00 out Argon $2.00 in / $10.00 out $4.00 in / $20.00 out Carbon $2.00 in / $10.00 out $4.00 in / $20.00 out $0 $1 $2 $3 $4 Until November 30 Neon is the most expensive Gemini 4 model per token. From December 1 Argon and Carbon cost a third more than Neon.

One number per run: weighted tokens

Every Gemini 4 rate card above has the same proportions. Output costs five times the input rate, and a cached input token costs 5% of it. That makes the cost of any run equal to the input rate times one number:

weighted tokens = uncached input + 0.05 × cached input + 5 × output

Thinking tokens are billed as output, so they sit in the last term. With this, comparing Neon and Carbon on a task stops being a four-variable problem. Neon is cheaper than another Gemini 4 model exactly when its weighted tokens, divided by the other model's, are below the ratio of their input prices:

Neon againstPrice ratioNeon is cheaper per task when it uses under
Hydrogen$1.50 / $3.0050% of Hydrogen's weighted tokens
Carbon or Argon, to Nov 30$2.00 / $3.0067% of their weighted tokens
Carbon or Argon, from Dec 1$4.00 / $3.00133% of their weighted tokens

We checked the proportions and computed the thresholds and an example with this script. It makes no API call, and the token counts in the example are invented for illustration:

python
RATES = {  # (input, cached input, output), USD per 1M tokens, checked 19 Nov 2026
    "hydrogen":         (1.50, 0.075, 7.50),
    "neon":             (3.00, 0.15, 15.00),
    "carbon-to-nov30":  (2.00, 0.10, 10.00),
    "carbon-from-dec1": (4.00, 0.20, 20.00),
}

def task_cost(rate, uncached_in, cached_in, out):
    i, c, o = rate
    return (uncached_in * i + cached_in * c + out * o) / 1_000_000

def weighted_tokens(uncached_in, cached_in, out):
    return uncached_in + 0.05 * cached_in + 5 * out

for name, (i, c, o) in RATES.items():   # every card is input x (1, 0.05, 5)
    assert abs(c - 0.05 * i) < 1e-9 and abs(o - 5 * i) < 1e-9, name

for other in ("hydrogen", "carbon-to-nov30", "carbon-from-dec1"):
    share = RATES[other][0] / RATES["neon"][0]
    print(f"Neon cheaper than {other} below {share:.0%} of its weighted tokens")

runs = {"hydrogen": (40_000, 360_000, 30_000),   # illustrative counts
        "neon":     (25_000, 200_000, 18_000),
        "carbon":   (25_000, 200_000, 22_000)}
for model, toks in runs.items():
    for k in ([model] if model != "carbon" else ["carbon-to-nov30", "carbon-from-dec1"]):
        print(k, f"W={weighted_tokens(*toks):,.0f}", f"${task_cost(RATES[k], *toks):.3f}")
Code
Neon cheaper than hydrogen below 50% of its weighted tokens
Neon cheaper than carbon-to-nov30 below 67% of its weighted tokens
Neon cheaper than carbon-from-dec1 below 133% of its weighted tokens
hydrogen W=208,000 $0.312
neon W=125,000 $0.375
carbon-to-nov30 W=145,000 $0.290
carbon-from-dec1 W=145,000 $0.580

In this made-up agent run, Neon finishes with 40% fewer weighted tokens than Hydrogen and still costs 20% more, because it costs twice as much per token. Against Carbon it loses this month and wins by a wide margin next month, on identical token counts. Two other things stand out. A 200,000-token cached context adds only 10,000 weighted tokens, and output, mostly thinking, is 72% of Neon's weighted total. The thinking level, not the context size, is the control that moves the bill.

Neon against Carbon: one ratio decides itTwo straight lines. Before December 1 the cost ratio is 1.5 times the token ratio and crosses parity at 67%. From December 1 it is 0.75 times the token ratio and crosses parity at 133%.. Weighted tokens = uncached input + 0.05 x cached input + 5 x output, including thinking. Measure it per accepted task, with every retry counted. Neon against Carbon: one ratio decides it Cost of a Neon run divided by the cost of a Carbon run, against Neon weighted tokens as a share of Carbon’s. 0.5x 1x 1.5x 2x 40% 67% 100% 133% 160% same cost To Nov 30: Carbon $2 / $10 Neon is cheaper below 67% From Dec 1: Carbon $4 / $20 Neon is cheaper below 133% Neon weighted tokens as a share of Carbon’s on the same task Weighted tokens = uncached input + 0.05 x cached input + 5 x output, including thinking. Measure it per accepted task, with every retry counted.

The default that changes your bill

Google's migration checklist says switching from another Gemini 4 model "requires no request schema changes." That is true and it is where teams get caught. Neon defaults to high and supports xhigh. Carbon and Argon default to medium and cap at high. A team that swaps gemini-4-carbon for gemini-4-neon and changes nothing else has also changed the thinking level, and so the largest term in the cost of every request.

Set thinking_level explicitly on every request you evaluate. Google's own advice for Neon is to run the evaluation at all four levels with a generous max_output_tokens and "pick the lowest thinking_level that meets your quality bar." A level name is a setting on one model, not a unit of compute shared across models, so medium on Neon is not guaranteed to behave like medium on Carbon.

What breaks when you migrate from older Gemini models

Moving from Gemini 3.8 Flash or earlier is a larger change, and the developer guide lists it. The ones we would put in a pre-migration review:

ChangeWhat fails if you ignore it
One 1,048,576-token window shared by input, thinking and outputA long prompt leaves less room for the answer than it did with separate budgets
Synchronous output capped at 65,536 tokens per hop; longer needs background=true or client-side continuationLong generations stop at 64K. With background=true but no max_output_tokens, the server also stops at 65,536
Explicit context caching (cachedContents) not supported; implicit caching at 4,096+ tokens gives 95% offRequests that still send cached_content need changing; caching becomes something you design prompts for, not something you call
temperature, top_p and top_k ignored; out-of-range values return 400Tests that pin sampling for reproducibility silently stop doing anything
minimal thinking level rejectedRequests that used it return an error
Prompted raw-text JSON tool calls with no declared tools can return MALFORMED_FUNCTION_CALLOld prompt-only tool protocols break; declare tools or use structured output
Thought signatures must be returned unchanged and never copied across parallel functionCall partsMulti-turn tool sessions lose accuracy or fail validation
Hard prompts can take minutes; Google suggests timeouts of at least 15 minutes or background executionClient timeouts turn slow successes into retries you pay for twice

The thought-signature rule is the one most likely to slip through review, because the failure is quiet. Our Hydrogen integration guide shows the state handling, and it applies to Neon unchanged.

How we would run the comparison

  1. Freeze the task set. Use your real tasks, including the expensive failures, and keep tools, context and grading fixed across models. Our model selection guide covers the setup.
  2. Run each model at each supported thinking level. Neon and Hydrogen have four; Carbon and Argon have three.
  3. Record weighted tokens per accepted task. Include every attempt, retry and repair, not just the successful call. Divide by accepted tasks, not by calls.
  4. Apply both rate cards. Price the same runs at November and December rates and write the rate-card date into the result. A decision made on November prices will be wrong in December.
  5. Pick per route, not per company. Neon may win the multi-file refactor route and lose the extraction route. The model routing concept explains how to keep that policy small and testable.

Pros and cons of adding Neon

ForAgainst
A middle option for complex work that does not need CarbonTwice Hydrogen's price per token; it has to save steps to pay
Same request schema as the other Gemini 4 modelsA different default thinking level, which a model-ID swap carries with it
Implicit caching at 95% off makes long, stable contexts cheapPaid tier only; enterprise availability limited by region on Agent Platform
Google claims fewer redundant reads and shortcuts in long agent sessionsThat claim is the vendor's; measure it on your tasks before you rely on it

What to say about this in an interview

If a model-choice question comes up, the strong answer is the method, not the model name. "Every Gemini 4 rate card is the input price times one, a twentieth and five, so I compare weighted tokens per accepted task. I evaluate each thinking level, set it explicitly, and I write the rate card date on the result, because Carbon's price doubles on December 1." That answer survives the next model release. A recommendation for Neon by name does not.

PRACTICE THIS

Turn it into offers. Work the real questions and concepts this maps to:

FAQ

Gemini 4 Neon (model ID gemini-4-neon) is a Gemini 4 model that Google positions between Hydrogen and Carbon, for complex software engineering, knowledge work and science tasks where you want frontier-level quality with faster end-to-end completion. It has the shared 1,048,576-token context window, long decode up to 1M tokens, and four thinking levels: low, medium, high (the default) and xhigh.

Discussion (4)

Lukas HoffmannEditor

The weighted-token trick is the part I would steal for any vendor. When every rate on a card is a fixed multiple of the input rate, you stop comparing four prices and start comparing one number per run. It also exposes what usually decides the bill: output and thinking, not the size of a mostly cached context.

Brandon FosterEditor

Reader question: if Neon's default is high, can we just set it to medium and keep Carbon's behavior?

Mei LinEditor

You can set it, and you should set it explicitly either way. You cannot assume medium on Neon behaves like medium on Carbon. A level name is a setting on one model, not a unit of compute across models. Run your evaluation set at each level and pick the lowest one that clears your quality bar.

Adam ReyesEditor

The ten-day window matters for anyone running a bake-off this month. A comparison run on November 20 prices Carbon at half its December rate. Write the rate card version into the results, or the decision will be wrong in two weeks and nobody will know why.