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.
| Hydrogen | Neon | Argon | Carbon | |
|---|---|---|---|---|
| Model ID | gemini-4-hydrogen | gemini-4-neon | gemini-4-argon | gemini-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 level | high | high | medium | medium |
| Highest thinking level | xhigh | xhigh | high | high |
| Free tier | Yes | No | No | No |
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.
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 against | Price ratio | Neon is cheaper per task when it uses under |
|---|---|---|
| Hydrogen | $1.50 / $3.00 | 50% of Hydrogen's weighted tokens |
| Carbon or Argon, to Nov 30 | $2.00 / $3.00 | 67% of their weighted tokens |
| Carbon or Argon, from Dec 1 | $4.00 / $3.00 | 133% 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:
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}")
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.
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:
| Change | What fails if you ignore it |
|---|---|
| One 1,048,576-token window shared by input, thinking and output | A 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 continuation | Long 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% off | Requests 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 400 | Tests that pin sampling for reproducibility silently stop doing anything |
minimal thinking level rejected | Requests that used it return an error |
Prompted raw-text JSON tool calls with no declared tools can return MALFORMED_FUNCTION_CALL | Old prompt-only tool protocols break; declare tools or use structured output |
Thought signatures must be returned unchanged and never copied across parallel functionCall parts | Multi-turn tool sessions lose accuracy or fail validation |
| Hard prompts can take minutes; Google suggests timeouts of at least 15 minutes or background execution | Client 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
- 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.
- Run each model at each supported thinking level. Neon and Hydrogen have four; Carbon and Argon have three.
- Record weighted tokens per accepted task. Include every attempt, retry and repair, not just the successful call. Divide by accepted tasks, not by calls.
- 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.
- 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
| For | Against |
|---|---|
| A middle option for complex work that does not need Carbon | Twice Hydrogen's price per token; it has to save steps to pay |
| Same request schema as the other Gemini 4 models | A different default thinking level, which a model-ID swap carries with it |
| Implicit caching at 95% off makes long, stable contexts cheap | Paid tier only; enterprise availability limited by region on Agent Platform |
| Google claims fewer redundant reads and shortcuts in long agent sessions | That 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.
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.
On the paid tier of the Gemini Developer API, checked 19 November 2026: $3.00 per million input tokens, $0.15 per million implicitly cached input tokens, and $15.00 per million output tokens including thinking. It is not available on the free tier.
Per token, not until December. Carbon and Argon cost $2.00 / $10.00 through November 30, 2026, and $4.00 / $20.00 from December 1. Because every Gemini 4 rate card has the same shape, the per-task answer reduces to one ratio: Neon is cheaper than Carbon only if it uses under 67% of Carbon's weighted tokens before December 1, and under 133% after.
The request schema does not change, but the default does. Neon defaults to high thinking and supports xhigh; Carbon and Argon default to medium and cap at high. Swapping the model ID alone can raise thinking-token spend. Set thinking_level explicitly and evaluate at each level.
Google's own guidance keeps Hydrogen as the default for everyday coding and agent workflows and suggests Neon for complex engineering where you want frontier-level quality. Neon costs twice as much per token, so it pays for itself only on tasks where it finishes with under half of Hydrogen's weighted tokens or saves a failure that costs more than the difference.
Discussion (4)
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.
Reader question: if Neon's default is high, can we just set it to medium and keep Carbon's behavior?
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.
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.
