Gemini 4 Neon explained: model tiers, thinking levels, cached input and orchestrator agents
On 18 November 2026 Google released Gemini 4 Neon, a middle tier between Carbon and Hydrogen. This guide uses it to explain model tiers, thinking levels, cached-input pricing, orchestrator agents and how to read a vendor benchmark list.
- Reading time
- 16 min
- Sections
- 9
- Code examples
- 1
- Tables
- 2
- Sources
- 8
- Published
- 20 Nov 2026
- What changed
- Google releases Gemini 4 Neon
- Why it matters
- Neon is a new rung in the middle of a ladder, not a reason to switch everything.
- What to do
- Sort your tasks by difficulty
Google released Gemini 4 Neon on 18 November 2026. It follows Carbon and Hydrogen, which shipped earlier the same month. Google places Neon in the middle: Carbon "tackles your hardest, long-horizon projects", Hydrogen "handles fast everyday execution", and Neon "balances depth and efficiency".
Why it matters: Neon is a clear lens on model tiers, thinking levels, cached-input pricing and orchestrator agents, and its launch post is a good exercise in reading vendor benchmarks.
What happened
Google releases Gemini 4 Neon (18 November 2026)
Google announced Neon on its blog and made it available the same day. According to 9to5Google, the release followed Carbon on 10 November and Hydrogen on 12 November. The model ID in the Gemini API is gemini-4-neon.
- Price: $3 per million input tokens, $0.15 per million cached input tokens ("a 95% discount") and $15 per million output tokens. Google's release notes say pricing is flat across the full context window.
- Context: a unified window of 1,048,576 tokens shared by input, thinking and output. A normal (synchronous) request can return up to 65,536 output tokens; a background "long decode" mode can go further.
- Thinking levels:
low,medium,high(the default) andxhigh. - Availability: the paid tier of the Gemini API (there is no free tier for Neon), Google AI Studio, Gemini for business, Google Antigravity for AI Pro and Ultra subscribers, and the Gemini app for AI Pro and Ultra subscribers.
The model card says Neon "is adapted from Gemini 4 Carbon" and points to Carbon's card for architecture and training data. It gives a knowledge cutoff of March 2026.
Neon replaces Argon in the Gemini app (18 November 2026)
9to5Google reports that Neon replaces Gemini 4 Argon, which Google had pitched for code and analysis, and that Gemini 3.1 Pro is being removed. The app's model picker now offers Auto, "Everyday help" (Hydrogen), "Deeper analysis" (Neon) and "Code and complex work" (Carbon).
The pricing picture shifts at the end of the month. According to 9to5Google and DataCamp, Carbon and Argon cost $2 input and $10 output per million tokens until 30 November, then rise to $4 and $20. So in November Neon costs more per token than Carbon, and from 1 December it costs about 25% less. 9to5Google also reports that Neon is twice the price of Hydrogen. For the earlier Carbon launch and its math results, see our piece on Gemini 4 Carbon and the MathArena leaderboard; the family overview lives at Gemini 4.
How model tiers inside one family work
Think of a restaurant kitchen. The head chef is slow and expensive and takes the hardest dishes, line cooks make most plates, and the sous chef handles complex orders fast and checks the line cooks' work. All of them use the same recipes.
Model families work in a similar way. The models share a lineage, an interface and often training data, but they trade quality, speed and price differently. Google's model selection guide describes the Gemini 4 tiers like this:
| Model | Google's positioning | Thinking levels | Default level | Free tier |
|---|---|---|---|---|
| Hydrogen | "Fast and cost-efficient for everyday coding, interactive apps, tool-using agents" | low, medium, high, xhigh | high | Yes |
| Neon | "Deeper reasoning than Hydrogen and faster task completion than Carbon" | low, medium, high, xhigh | high | No |
| Carbon | "Our strongest reasoning model" | low, medium, high | medium | No |
| 3.5 Flash-Lite | "Our fastest, lowest-cost general model" | minimal, low, medium, high | minimal | Not stated |
The tiers share one request schema. Google says Carbon, Neon and Hydrogen share a request schema, context window and tool set, so "you can route each step to the model that fits it". Switching tiers is a one-line change to the model ID. That is what makes LLM routing cheap to try.
Defaults differ. Neon defaults to high; Carbon defaults to medium and tops out at high. Google's release notes call this out in the migration section. If you swap Carbon for Neon without setting the level, you also change how hard the model thinks.
The middle tier is defined by its neighbours. Google recommends Neon for complex engineering and science work when Hydrogen is not enough, and Carbon when a faster model gets stuck. The middle tier exists because many real tasks are too hard for the cheap model but do not need the most careful one.
Thinking levels: the hidden price dial
A reasoning model writes out internal "thinking" tokens before it answers. A thinking level tells the model roughly how much of that work to do. In the Gemini API, thinking tokens are billed at the output rate, and they count towards max_output_tokens. At $15 per million output tokens, thinking is often the biggest line on a Neon bill.
Artificial Analysis, an independent benchmarking firm, ran its Intelligence Index at all four of Neon's levels. Its page shows the shape of that curve:
| Thinking level | Intelligence Index | Output tokens used on the index | Time per task |
|---|---|---|---|
| low | 44 | 28.3M | 3.7 min |
| medium | 55 | 62.9M | 8.3 min |
| high (default) | 60 | 123M | 14.8 min |
| xhigh | 61 | 283M | 21.5 min |
Moving from low to medium adds 11 points for about 2.2 times the output tokens. Moving from high to xhigh adds 1 point for about 2.3 times the tokens and about 45% more time per task. At $15 per million output tokens, those output tokens alone are worth roughly $1,845 at high and $4,245 at xhigh across the whole index (our arithmetic from Artificial Analysis's token counts and Google's list price).
Google's own advice in the release notes is the same: test all four levels with a high output cap, "then choose the lowest level that meets your quality bar". Its Cloud guide maps them to workloads:
- low: classification, routing, summarisation and metadata extraction at high volume.
- medium: general coding, tool use, document Q&A and interactive work where latency matters.
- high: multi-step agentic tool loops, code generation and refactoring.
- xhigh: proofs, scientific analysis and the hardest multi-file engineering.
The blog says that at high, Neon's cost per task is 32% lower than Carbon's, and that at xhigh it costs "36%+ less per task than competing models at their highest setting". Cost per task, not price per token, is the right unit, because it multiplies price by the number of tokens the model chooses to spend. Both are Google's figures, without the task mix behind them, so test them.
Cached input: why a 95% discount changes agent economics
What gets cached
An agent re-sends the same growing conversation every turn: system instructions, tool definitions, files it has read and earlier steps. Most of that text is identical to the turn before.
Prompt caching lets the provider reuse the attention state it already computed for a prefix it has seen recently (see our KV cache page), and pass part of the saving on. Our prompt caching page covers the general mechanics.
For Neon, Google's release notes set out the rules:
- Implicit caching only. Caching runs automatically on prompts of at least 4,096 tokens. Explicit caching (
cachedContentsandcaches.create) is not supported, and requests that use it need changing. - Prefix matching. The Cloud guide says implicit caching applies to "shared prompt prefixes of 4,096 tokens or more" and advises putting static content at the start of the prompt.
- Discount size. Cached input tokens cost $0.15 per million instead of $3, which is the 95% discount.
A worked example
Picture an agent whose context has grown to 200,000 tokens, with about 20,000 new tokens per turn (illustrative numbers).
- No cache hits: 200,000 input tokens at $3 per million is $0.60 per turn.
- 90% of the prompt cached: 180,000 tokens at $0.15 per million is $0.027, plus 20,000 fresh tokens at $3 per million, which is $0.06. Total: about $0.09 per turn.
Over 50 turns that is roughly $30 against $4.35 in input charges, before output. The discount is so large that the cache hit rate can matter more than the headline input price. Artificial Analysis bakes this in: its "blended" price for Neon is $2.21 per million tokens, using a 7:2:1 mix of cache hits, fresh input and output.
A cache only helps when the prefix stays identical. Reordering tool definitions, inserting a timestamp near the top or "tidying" earlier messages breaks the match and you pay full price again. We covered this trap in detail in why trimming a coding agent's prompt can double its bill. Good context engineering for a cached model means: stable things first, changing things last, and edits made by appending rather than rewriting.
The orchestrator and subagent pattern
How it works
Google's blog describes Neon running "standalone or acting as a fast, high-judgment Orchestrator directing parallel Hydrogen subagents in Google Antigravity". This is the orchestrator-workers pattern. Think of a site foreman who reads the plans, hands out jobs to a crew and inspects the work, rather than laying every brick personally.
Google's Cloud developer guide shows the API version. A planning turn runs on gemini-4-neon with the interaction stored. Then a scoped implementation step runs on gemini-4-hydrogen, passing the planning turn's ID as previous_interaction_id on the Interactions API. Neon plans and verifies; Hydrogen executes. The guide describes this flow only for the Interactions API. Google's model selection guide shows the same idea with Carbon planning and Hydrogen implementing, and notes that the Antigravity agent in Gemini Managed Agents runs on Hydrogen by default, with Carbon or Neon as overrides.
Our article on subagent orchestration in coding agents goes deeper into when splitting work pays off and when it just multiplies tokens.
Context compaction
Compaction means summarising or dropping older material so a long session can keep going. Google claims Neon "cuts down on redundant file reads, shares progress as it works, and handles context compaction reliably in long sessions". Its Cloud guide adds two practical points:
- Thinking tokens at
highandxhighcount towardsmax_output_tokensand can pile up in multi-turn context when thought signatures are kept, so leave compaction headroom or usemediumon latency-sensitive tool turns. - With long background decodes, do not trigger compaction from cumulative input counts; check
initial_input_tokensand compact only after the turn finishes.
Note the tension with caching: compaction rewrites history, which breaks the cached prefix, so each compaction is billed at full input price. Rare compaction is fine; compacting every few turns is expensive.
Continue learning
How this article connects
12 pages link to or from it. Drag to turn, click a dot to open it.
How to read the benchmark list
Google's post lists more than twenty results. A list like that is easier to judge if you sort it into three buckets.
1. Third-party leaderboards. These are run or hosted by someone other than Google:
- Artificial Analysis Intelligence Index: 61 at xhigh, which Google calls "#3 overall". Artificial Analysis's own model page, when we checked, showed the same score of 61 ranked 6th of 95 entries. Ranks move as models are added and depend on whether each variant counts separately, so quote the score and the date, not just the rank.
- Artificial Analysis Coding Agent Index: 58.6, "#1 overall" according to Google. We could not see this figure on the Artificial Analysis model page.
- Vals Index: 70.9%, "#2" and on the Pareto frontier, per Google.
- Arena's Agent Arena Index: debuted "#2 globally" with a score of 1336 across more than 4,200 sessions, per Google.
2. Vendor-run benchmarks. Google reports, among others: Terminal-Bench 4.1 at 65.2%, FrontierCode 2.0 at 46.2% (at the default high setting), RiemannBench at 84.0%, HLE-Diamond at 71.3%, Terminal-Bench Science at 70.5%, Agents' Last Exam v1.1 at 75.8%, Zapier AutomationBench at 56.3%, Chartography at 73.5% and Vending-Bench 2 at $16,843. These may be accurate, but the vendor chose the benchmarks, the settings and the comparison models.
3. Harness-dependent results. This is the most instructive line. Google reports SWE-sweep at 12.8% on the mini-SWE harness and 39.0% on its own Antigravity harness. A harness is everything around the model: the tools it can call, the prompts, retry rules and time limits. Same model, same tasks, three times the score. DataCamp's write-up of Google's comparison table notes that on the shared mini-SWE harness the gap to OpenAI's GPT-6.2 Sol shrinks to about a point, which suggests much of the headline lead comes from the harness rather than the model.
An agentic score measures a model plus a harness. Our evals page explains how to build a small test set that measures your own combination. For comparing tiers across vendors, see our breakdown of GPT-6.2 Astra and Sol pricing and routing.
Safety figures Google reports
All of these are Google's own figures from its launch post:
- Terminal-Bench 4.0: refused 1.98% of tasks, with 0.0% cheating, matching Carbon. Terminal-Bench Science: 0% refusals.
- A coding cheating evaluation: shortcuts on 2.45% of tasks, which Google says is the lowest of any Gemini 4 model.
- An agentic safety suite: 0.09% misaligned action rate. An agent honesty evaluation: 99.2% pass rate.
- Under-service reduced by 43 to 56% and overreach by 15 to 35%, depending on effort level.
- Gray Swan IPI (indirect prompt injection) test: 0.0% attack success rate at the highest thinking level.
The model card adds context. Neon performs comparably to Hydrogen on content safety, with differences within confidence intervals, and reduces unjustified refusals. Because Google judged its capability gain over Argon to fall below its "Material Capability Change" threshold, it did not run a full new set of critical capability evaluations and carried forward Argon's results. For cybersecurity uplift and biological uplift, those carried-forward results say the critical capability level "cannot be ruled out". The full Safety and Security Report is listed as "coming soon".
What it means in practice
Neon is a new rung in the middle of a ladder, not a reason to switch everything. The useful question is which steps of your workflow sit where Hydrogen fails and Carbon is overkill.
Three practical effects stand out. First, defaults now differ across the family, so a "simple model swap" can change both quality and cost through the thinking level. Second, for agent workloads, cache hit rate is a first-class cost driver; a well-structured prompt on Neon may be cheaper than a badly structured one on a model with a lower list price. Third, the orchestrator pattern is now explicit in Google's own docs and tools, which lowers the cost of trying a planner-plus-workers design.
What to do now
- Sort your tasks by difficulty. List the main steps in your agent or pipeline and mark which ones fail on Hydrogen today. Those are Neon's candidates.
- Set the thinking level explicitly. Do not inherit the default. Run each task at low, medium, high and xhigh with a generous output cap and pick the lowest level that passes.
- Measure cost per task, not price per token. Log input, cached input, output and thinking tokens per completed task. That number is what Google's 32% claim is about.
- Restructure prompts for the cache. Put system instructions, tool definitions and fixed documents first. Append new material at the end. Keep prompts over the 4,096-token threshold where caching applies.
- Try one orchestrator split. Take a single workflow, run planning and verification on Neon and the scoped execution on Hydrogen via
previous_interaction_id, and compare total cost and success rate with a single-model run. - Watch compaction frequency. Count how often your harness compacts and what each one does to your cache hit rate.
- Re-run benchmarks in your own harness. Treat the 12.8% versus 39.0% SWE-sweep gap as a warning. Build a small private eval that uses your tools and your prompts.
- Diary the 1 December price change. Re-check any Carbon versus Neon comparison after Carbon's introductory pricing ends.
Risks and open questions
Harness effects can swamp model effects. The SWE-sweep gap shows a single model scoring three times higher in its maker's harness. Any agentic comparison that does not fix the harness is comparing two things at once.
Thinking costs are hard to predict. At high and xhigh the model decides how many tokens to spend, so budgets need headroom.
Caching is implicit, so it is less controllable. With no explicit cache, you cannot pin content or see guaranteed hits in advance; you can only structure prompts well and measure.
Frontier safety evaluation was carried forward. Google did not run a full new set of critical capability evaluations for Neon, and its own card says cyber and biological uplift thresholds "cannot be ruled out". The full Safety and Security Report is not yet published.
Watch next: the publication of Google's full Safety and Security Report for Neon, independent harness-controlled results on SWE-sweep and Terminal-Bench, how Artificial Analysis's rankings settle as more models are added, and how teams' bills change after Carbon's price rises on 1 December.
Frequently asked questions
Where does Gemini 4 Neon sit in the Gemini 4 family?
Google places it between Hydrogen and Carbon. Hydrogen is the fast, low-cost default, Carbon is the strongest reasoning model, and Neon offers "deeper reasoning than Hydrogen and faster task completion than Carbon".
How much does Gemini 4 Neon cost?
Google lists $3 per million input tokens, $0.15 per million cached input tokens and $15 per million output tokens, flat across the 1M-token context. Thinking tokens are billed as output.
What are the four thinking levels and which should I use?
They are low, medium, high (the default) and xhigh. Higher levels think longer, use more output tokens and take more time. Google advises testing all four and picking the lowest level that meets your quality bar, keeping xhigh for hard multi-step problems.
How does the 95% cached-input discount work?
Neon caches shared prompt prefixes of at least 4,096 tokens automatically. When a request starts with text the system has recently processed, those tokens are billed at $0.15 instead of $3 per million. Explicit caching is not supported, so the main lever is keeping the start of your prompt stable.
Why does Neon score 12.8% and 39.0% on the same benchmark?
Google reports SWE-sweep at 12.8% in the mini-SWE harness and 39.0% in its Antigravity harness. The harness supplies the tools, prompts and rules the model works with, so it changes results a lot. When comparing agent models, check that the harness is the same.
Summary
Gemini 4 Neon, released on 18 November 2026, is Google's middle tier between Hydrogen and Carbon, priced at $3 input, $0.15 cached input and $15 output per million tokens with a 1M-token context. It is a useful lens on how modern model families work: tiers share an interface so routing is easy, thinking levels act as a price dial with sharply diminishing returns at the top, implicit caching makes prompt structure a major cost driver for agents, and the orchestrator pattern lets a stronger model plan while cheaper subagents execute. Google's benchmark and safety figures are promising but mostly self-reported, and the SWE-sweep harness gap is a reminder to test any agent model in your own setup before you commit.
Sources
- Official Google: Introducing Gemini 4 Neon
- Official Google AI Studio: What's new in Gemini 4 Neon
- Official Google AI Studio: Choosing a model
- Web Google DeepMind: Gemini 4 Neon model card
- Docs Google Cloud: Gemini 4 Neon developer guide
- Web Artificial Analysis: Gemini 4 Neon
- Official 9to5Google: Gemini 4 Neon announcement
- Web DataCamp: Gemini 4 Neon
Cite this article
Kelahmet, Ö. C. (2026, November 20). Gemini 4 Neon explained: model tiers, thinking levels, cached input and orchestrator agents. Özer Cem KELAHMET. https://www.ozercemkelahmet.com/articles/gemini-4-neon-thinking-levels-caching-subagents
BibTeX
@online{kelahmet2026gemini,
author = {Kelahmet, {\"O}zer Cem},
title = {{Gemini 4 Neon explained: model tiers, thinking levels, cached input and orchestrator agents}},
year = {2026},
month = {nov},
url = {https://www.ozercemkelahmet.com/articles/gemini-4-neon-thinking-levels-caching-subagents}
}Version historyfirst version
- Published
Factual corrections are listed here with what changed. Wording and formatting edits are not listed.