Gemini 4 Neon cost per task depends on more than its $3 / $15 per million token price. Google says Neon at its default high thinking level costs 32% less per task than Gemini 4 Carbon. Per token, Neon costs 50% more than Carbon’s introductory rate and 25% less than Carbon’s rate from December 1, 2026. Which one is cheaper for your agents comes down to tokens per task and how many attempts your team accepts.
TL;DR
- Neon list price: $3 per 1M input tokens, $15 per 1M output tokens (thinking included), $0.15 per 1M cached input. Paid tier only.
- Carbon list price: $2 / $10 through November 30, 2026, then $4 / $20 from December 1.
- Google’s claim: 32% lower cost per task than Carbon at
high, from an Artificial Analysis Intelligence Index chart. The post doesn’t say which Carbon price the chart used. - What that means: Neon only beats Carbon’s intro price if it finishes the same task in under two thirds of Carbon’s tokens. After December 1 it wins unless it burns a third more tokens than Carbon.
- What to measure: cost per accepted change, not cost per attempt.
Gemini 4 Neon pricing next to Carbon and Hydrogen
Gemini 4 Neon is the middle model of Google’s Gemini 4 family, released November 18, 2026, as gemini-4-neon. The model card describes it as adapted from Carbon and built to balance “depth and efficiency.” Here are the standard paid-tier rates per 1M tokens from the Gemini API pricing page:
| Model | Input | Output (incl. thinking) | Cached input | Batch input / output | Free tier |
|---|---|---|---|---|---|
| Gemini 4 Neon | $3.00 | $15.00 | $0.15 | $1.50 / $7.50 | No |
| Gemini 4 Carbon, through Nov 30 | $2.00 | $10.00 | $0.10 | $1.00 / $5.00 | No |
| Gemini 4 Carbon, from Dec 1 | $4.00 | $20.00 | $0.20 | $2.00 / $10.00 | No |
| Gemini 4 Hydrogen (paid tier) | $1.50 | $7.50 | $0.075 | $0.75 / $3.75 | Yes |
All three use implicit caching only. Neon’s AI Studio guide says implicit caching kicks in on prompts of at least 4,096 tokens and takes 95% off cached input. Neon has no explicit caching, so delete any cached_content fields when you move a Carbon setup over.
Google bills “every token the model processes, including thinking tokens and internal grounding system instructions and function declarations.” For a tool-heavy agent, those declarations ride along on every turn.
How Google measures Neon’s cost per task
Cost per task is the total spend for a model to finish one benchmark task: the tokens it used multiplied by its price. Google’s launch post says that at high, Neon “pairs a high Artificial Analysis Intelligence Index score with a 32% lower cost per task than Carbon.” The chart is labeled “AA Index v5.01 cost per task.”
Artificial Analysis is a third party, not Google. The post gives two more cost claims, and neither one is about Carbon:
- Neon runs at “roughly 50% to 80% lower cost per task than top competing frontier models,” with the competitors unnamed.
- At
xhigh, Neon still costs “36%+ less per task than competing models at their highest setting.”
The post doesn’t publish the token counts or the Carbon price behind the 32%. That gap matters more than usual, because Carbon’s price doubles less than two weeks after Neon launched.
Is Gemini 4 Neon cheaper than Carbon? It depends on the date
Per token, Neon sits between Carbon’s two prices: 1.5 times Carbon’s intro rate and 0.75 times its December rate. So the 32% can only come from Neon using fewer tokens per task. Run the claim both ways:
| If Google’s chart priced Carbon at | Implied Neon tokens vs Carbon | Neon vs Carbon through Nov 30 | Neon vs Carbon from Dec 1 |
|---|---|---|---|
| $2 / $10 (intro) | about 45% | 32% cheaper | about 66% cheaper |
| $4 / $20 (December) | about 91% | about 36% more expensive | 32% cheaper |
Both rows assume the two models split input and output tokens in the same ratio, a simplification. Either way, from December 1 Neon is cheaper per task on Google’s own numbers. Through November 30, the answer hangs on a detail Google didn’t publish.

What one agent task costs at list price
Here’s a worked example with round numbers, not a benchmark. Picture a coding agent session that sends 200K fresh input tokens, gets 800K tokens of cache hits as it re-reads the repository, and produces 50K output tokens including thinking.
| Model | Fresh input | Cached input | Output | Total |
|---|---|---|---|---|
| Neon (standard) | $0.60 | $0.12 | $0.75 | $1.47 |
| Neon (batch) | $0.30 | $0.06 | $0.375 | $0.74 |
| Carbon, through Nov 30 | $0.40 | $0.08 | $0.50 | $0.98 |
| Carbon, from Dec 1 | $0.80 | $0.16 | $1.00 | $1.96 |
At identical token counts, Neon loses to Carbon’s intro price and beats its December price. The break-even rule is simple. Against the intro price, Neon has to finish in under 67% of Carbon’s tokens. Against the December price, Neon stays cheaper unless it needs more than 133% of Carbon’s tokens.
Output is half of Neon’s bill in this example, and thinking tokens bill as output. That’s why the thinking level you pick moves cost more than the list price does.
Thinking levels: the dial behind Neon’s cost per task
Neon supports four thinking levels: low, medium, high (the default) and xhigh. Google’s guide is direct about the trade: xhigh “increases latency and token use,” and you should “pick the lowest thinking_level that meets your quality bar.”
A practical routing for agent work looks like this:
low: codebase questions, diff summaries, triage notes.medium: scoped fixes where the test suite is the real judge.high: refactors, debugging and long tool-call sessions. This is where Google’s 32% claim applies.xhigh: only for tasks that already failed review athigh.
Set it per request in code:
from google import genai
client = genai.Client()
interaction = client.interactions.create(
model="gemini-4-neon",
input="Find why test_checkout_retry flakes and propose a fix.",
generation_config={"thinking_level": "medium"},
)
print(interaction.output_text)
Neon rejects the old minimal level with an error and ignores temperature, top_p and top_k. Google also recommends client timeouts of at least 15 minutes for hard prompts, which long agent runs hit first.
Why cost per task still isn’t your number
A benchmark task ends when the grader scores it. Yours ends when a person merges the change. Retries, rejected diffs and review time sit between the two, and no cost-per-task chart shows them.
The number that maps to your budget is cost per accepted change: total model spend on a task, across every attempt, divided by the changes you shipped. We made the full case in when a cheaper model costs more. The short version:
cost per accepted change = cost per attempt / acceptance rate

Run the example from above. If Neon passes review on 70% of first attempts, $1.47 per attempt becomes $2.10 per accepted change. If Carbon at its December price passes 80%, $1.96 becomes $2.45. Neon still wins. But drop Neon to 55% acceptance and it costs $2.67 per accepted change, and Carbon wins. Your acceptance rates, not Google’s chart, decide the route.
Reviewer time sits outside that formula and usually costs more than the tokens. Human review is the bottleneck for parallel agents, so fewer rejected diffs save the expensive part.
How to test Neon against Carbon on your own tasks
You don’t need a new benchmark. You need two weeks of real tickets and a way to tell which model did what. Sharkly gives you that board: each task holds the agent’s run, its result and its review status in one place.
- Pick 20 to 30 ordinary tasks from your backlog: bug fixes, small refactors, test additions.
- Create two Agents. A Sharkly Agent follows its Runtime’s default model and has no model picker, per the Agents docs. So point each Agent at a Runtime configured for a different model: one on
gemini-4-neon, one ongemini-4-carbon. - Split the tasks between the two Agents with similar difficulty on each side.
- Record three numbers per task: tokens from your Gemini API usage, attempts until accepted, and reviewer minutes.
- Compute cost per accepted change for each model, at both Carbon prices if your test straddles December 1.
Sharkly doesn’t sell model tokens. Your runs bill against the Gemini API key already configured on the Runtime, so the comparison stays honest: nothing in the platform shifts the price toward one model. For the bigger picture, see why an agent platform should not sell you tokens and tracking spend across Claude Code, Codex and Gemini.
Where Neon, Carbon and Hydrogen each fit
Google’s model card puts Carbon on “your hardest, long-horizon projects” and Hydrogen on “fast everyday execution,” with Neon between them. On cost, that gives an agent team three lanes:
- Hydrogen at $1.50 / $7.50 for high-volume, low-risk work. See Gemini 4 Hydrogen for coding agents.
- Neon at
highas the default lane for complex tickets, and as the lead that directs parallel Hydrogen subagents. - Carbon for the long-horizon work Neon fails at
xhigh. Our Carbon review covers where it earns its price.
The Carbon and Hydrogen pairing guide shows a planner-and-workers board; from December 1, Neon takes the planner seat for less. For routing across vendors, see model routing for agent crews.
Conclusion
Gemini 4 Neon is cheaper than Carbon per task from December 1 on any reading of Google’s numbers. Before that date, it depends on which Carbon price sat behind the 32% chart, and Google didn’t say. The list price was never the deciding number anyway: tokens per task, thinking level and acceptance rate are.
Run the two-week test on your own backlog and price both models per accepted change. If you already run several coding agents, Sharkly gives you one board to assign the tasks, compare the Agents’ results and keep review in one queue. The Sharkly docs walk through connecting a Computer and creating Agents.
FAQ
How much does Gemini 4 Neon cost?
$3 per 1M input tokens, $15 per 1M output tokens including thinking, and $0.15 per 1M cached input tokens on the Gemini API paid tier. Batch and Flex halve that to $1.50 / $7.50. There’s no free API tier.
Is Gemini 4 Neon cheaper than Gemini 4 Carbon?
Per token, no until November 30 ($3 / $15 against $2 / $10), and yes from December 1 ($3 / $15 against $4 / $20). Per task, Google reports Neon at high 32% cheaper than Carbon, without publishing which Carbon price it used.
Does Gemini 4 Neon have a free tier?
No. The pricing page lists “Not available” for Neon’s free tier on every service level. Gemini 4 Hydrogen does have one.
Are thinking tokens billed for Gemini 4 Neon?
Yes. Google bills thinking tokens at the output rate of $15 per 1M, along with function declarations and grounding system instructions. Lowering thinking_level is the main way to cut tokens.
Which thinking level is cheapest for coding agents?
low uses the fewest tokens and xhigh the most. Google recommends testing all four on your evaluation set and picking the lowest level that meets your quality bar. Start at high for complex code changes.
When does Gemini 4 Carbon’s price go up?
On December 1, 2026. Input moves from $2 to $4 per 1M tokens and output from $10 to $20, according to the Gemini API pricing page.



