Google released four Gemini 4 models in five weeks: Argon on October 13, Carbon on November 10, Hydrogen on November 12 and Neon on November 18. They share one API shape, a 1M-token window and the same tools, so choosing between them comes down to two values per call type: a model ID and an effort level. They differ in how much they think per turn, how fast they answer and what they cost.
On Artificial Analysis's measurements of Google's API, the routes look like this:
- Chat, extraction, classification and short tool calls go to Hydrogen at
mediumorhigh. Routing and tagging can drop tolow, AA's cheapest setting at $0.29 per index task. - Interactive coding and document work goes to Neon at
medium, or to Hydrogen athighif cost per token matters more than score. - Multi-file changes, agent loops and analysis over long documents go to Neon at its default
high. - The hardest problems go to Neon at
xhighfor depth with speed, or to Carbon athighwhere research-level physics and a lower hallucination rate matter most. - Existing Argon integrations keep working at the same request shape. Re-test them on Neon Medium or Hydrogen High before December 1, when Argon's price doubles.
December 1 is the date that changes the cost side: Carbon and Argon double from $2/$10 to $4/$20, and Hydrogen and Neon keep their prices.
This replaces the three-model comparison AIHubMix published before Neon launched, Gemini 4 Carbon vs Hydrogen vs Argon.
The routing table as code
Through AIHubMix's OpenAI-compatible endpoint, switching models is a change of model ID. The effort value must be one the model accepts: Neon and Hydrogen take low to xhigh, Carbon and Argon low to high.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://aihubmix.com/v1",
api_key=os.environ["AIHUBMIX_API_KEY"],
)
ROUTES = {
"classify": ("gemini-4-hydrogen", "low", 65536),
"code": ("gemini-4-neon", "medium", 65536),
"hard": ("gemini-4-carbon", "high", 32768), # Carbon: 32,768 on non-streaming calls
}
def ask(kind, prompt):
model, effort, max_out = ROUTES[kind]
response = client.chat.completions.create(
model=model,
reasoning_effort=effort,
max_completion_tokens=max_out,
timeout=900, # hard prompts can take several minutes
messages=[{"role": "user", "content": prompt}],
)
return response.choices[0].message.content
print(ask("code", "Refactor this function to remove the shared mutable state: ..."))
The Carbon route caps output at 32,768 because the call doesn't stream. On Google's own API, all four models return up to 65,536 output tokens per request and can run long decode up to the 1M window, but a direct non-streaming request to Carbon or Argon returns at most 32,768 tokens, and asking for more on such a call returns a 400. AIHubMix's parameter schemas record the same limits: 65,536 output tokens per request for all four, and 32,768 for non-streaming Carbon and Argon calls.
No live test was run for this post; the sample shows the request shape. The Hydrogen vs Neon compare page lists the two side by side.
What differs between the four requests
| Model | Model ID | Default | Levels | Price now | From Dec 1 |
|---|---|---|---|---|---|
| Hydrogen | gemini-4-hydrogen | high | low to xhigh | $1.50 / $7.50 | same |
| Neon | gemini-4-neon | high | low to xhigh | $3 / $15 | same |
| Carbon | gemini-4-carbon | medium | low to high | $2 / $10 | $4 / $20 |
| Argon | gemini-4-argon | medium | low to high | $2 / $10 | $4 / $20 |
Google's official prices, USD per million input / output tokens, from the Gemini API pricing page. Cached input is 5% of the input price on all four. AIHubMix lists all four at Google's current prices; it hasn't published December prices for Carbon and Argon.
The thinking levels set the real cost more than the per-token price does. Neon and Hydrogen default to high and add xhigh; Carbon and Argon default to medium and stop at high. A request that doesn't set a level gets a different amount of thinking depending on the model, which is why the router above sets one on every route.
Google's own model-selection guide now lists three of the four. Hydrogen is the default: "Fast and cost-efficient for everyday coding, interactive apps, tool-using agents, and multimodal documents." Neon is for "complex, high-frequency tasks", with "deeper reasoning than Hydrogen and faster task completion than Carbon." Carbon is for "your hardest problems".
Argon doesn't appear in that guide at all. That isn't a retirement, since Google has announced no shutdown date for any Gemini 4 model, but it says where Google points new projects. On Google's API, only Hydrogen has a free tier; on AIHubMix all four are pay-as-you-go.
Score, cost and time per task
The figures below come from the Artificial Analysis leaderboard, re-checked 2026-11-19 at 13:27 UTC. They are third-party measurements of Google's API, and they move as AA re-runs models.
AA prices Carbon at its December rate but Argon at today's introductory rate. To compare like with like, the two cost columns below re-price both. Every Carbon and Argon rate moves by exactly a factor of two, so the conversion is a straight halving or doubling. The re-priced figures are estimates, not AA measurements.
| Setting | AA Index | $/task now | From Dec 1 | Min/task |
|---|---|---|---|---|
| Hydrogen Medium | 41.2 | 0.80 | 0.80 | 4.2 |
| Hydrogen High (default) | 50.8 | 1.87 | 1.87 | 8.6 |
| Hydrogen Xhigh | 53.9 | 3.16 | 3.16 | 15.2 |
| Neon Low | 44.1 | 0.75 | 0.75 | 3.7 |
| Neon Medium | 54.9 | 1.90 | 1.90 | 8.3 |
| Neon High (default) | 59.6 | 3.74 | 3.74 | 14.8 |
| Neon Xhigh | 61.4 | 6.44 | 6.44 | 21.5 |
| Carbon Medium (default) | 58.3 | 3.29 | 6.59 | 29.3 |
| Carbon High | 60.0 | 3.88 | 7.76 | 36.6 |
| Argon Medium (default) | 47.6 | 4.31 | 8.63 | 28.9 |
| Argon High | 50.4 | 4.97 | 9.95 | 29.5 |
AA's averages per Intelligence Index task. AA has no Argon Low result. Hydrogen Low (26.9, $0.29, 1.5 minutes) and Carbon Low (54.2, $3.59 now and $7.19 from Dec 1, 29.8 minutes) are left out of the table.
Neon Medium is the middle of the family. It scores 4.1 points more than Hydrogen's default for about the same cost per task ($1.90 against $1.87) and about the same time (8.3 against 8.6 minutes). It also beats Hydrogen Xhigh by 0.9 points at 40% less cost and in about half the time.
Below that, Hydrogen wins. For the cheapest tasks, nothing in the family undercuts Hydrogen Low at $0.29 per task. It's also the fastest per token: 157–170 tokens per second on AA, against 97–110 for Neon and 48–66 for Carbon and Argon.
Argon is off the frontier even at today's price. Argon Medium scores 47.6 at $4.31 per task, and Neon Medium scores 7.3 points more at 56% less cost, in less than a third of the time. Hydrogen High matches Argon High's score (50.8 against 50.4) at 62% less cost per task.
Carbon's lead is narrow. Carbon High (60.0) and Neon High (59.6) are within half a point, but Carbon takes two and a half times as long per task, and Neon Xhigh scores higher on the index (61.4). Until November 30 Carbon Medium is cheaper per task than Neon High; from December 1 it isn't.
Per-evaluation results that change a route
The index averages nine evaluations. The individual results show where each model is the right pick. All figures are from the same AA snapshot, at each model's high setting.
| Evaluation | Hydrogen | Neon | Carbon | Argon |
|---|---|---|---|---|
| Terminal-Bench 4.0 | 54.0 | 61.6 | 65.2 | 57.1 |
| FrontierCode 2.0 | 36.3 | 43.3 | 40.6 | 25.7 |
| HLE-Diamond | 54.9 | 68.4 | 69.1 | 56.7 |
| CritPt (physics) | 61.5 | 59.0 | 69.0 | 52.5 |
| AutomationBench | 74.4 | 79.2 | 77.8 | 77.5 |
| Non-hallucination | 91.3% | 86.1% | 88.6% | 95.7% |
AA's scores in percent. "Non-hallucination" is one minus the hallucination rate on AA's Omniscience test.
Neon has the broadest strength: first or second on every row except CritPt and the hallucination rate, and the strongest in the family on FrontierCode and AutomationBench.
Carbon leads on Terminal-Bench 4.0, HLE-Diamond and CritPt, the last by 7.5 points over the next model. Neon's xhigh setting, which Carbon doesn't have, passes it on HLE-Diamond (71.3 against 69.1) but not on CritPt (60.5) or Terminal-Bench 4.0 (63.6). Google's guidance is to use Carbon for "system architecture, multi-file debugging, dense multimodal analysis, formal proofs, and security audits, or when a faster model gets stuck."
Hydrogen scores higher than Neon High on CritPt (61.5 against 59.0) and hallucinates less (91.3% against 86.1%). Google says it "cuts fabricated claims by more than 5x compared to Gemini 3.8 Flash by flagging missing context instead of guessing". Its weaker spot is long agentic coding: on Terminal-Bench 4.0 and FrontierCode it trails Neon by 7.6 and 7.0 points.
Argon has the lowest hallucination rate of the four at the high setting (95.7% non-hallucination), and Carbon Medium is level with it at 95.8%. If a wrong answer is far more expensive than a slow or missing one, that row matters. Argon also costs the same per token as Carbon until November 30.
The same models inside a coding agent
AA's Coding Agent Index runs each model inside a coding agent. All four Gemini 4 models run in the same agent, Google's Antigravity CLI, so the gaps between them come from the models (re-checked 13:27 UTC).
| Model | Index | Min/task | Steps/task | $/task (AA) |
|---|---|---|---|---|
| Neon Xhigh | 58.6 | 30.5 | 177 | 6.86 |
| Carbon High | 55.5 | 33.6 | 186 | 9.75 |
| Hydrogen Xhigh | 52.3 | 32.1 | 405 | 4.45 |
| Argon High | 45.5 | 37.7 | 171 | 6.84 |
AA's averages per task; costs at AA's per-token prices, which use Carbon's December rate and Argon's current rate. Neon Xhigh is first of the 40 scored configurations, under 0.2 points ahead of Claude Code with Claude Fable 5.2 Xhigh: effectively a tie.
The ranking follows the Intelligence Index, with one twist. Hydrogen is fast per token but took 405 steps per task on average, more than twice as many as the others, so it finished in about the same half hour.
Planning with one model, executing with another
Google doesn't expect one model per app. Its guide describes a common pattern: "Have Carbon design system interfaces or isolate a hard bug on the first turn. Then pass previous_interaction_id to Hydrogen to write the code edits, run parallel subagent tasks, and iterate on tests at lower latency and cost." Its Neon guide suggests the same with Neon as the planner and verifier, and Hydrogen subagents as workers.
previous_interaction_id belongs to Google's Interactions API, which keeps the conversation on Google's servers. Through AIHubMix's OpenAI-compatible endpoint you keep the history yourself. Google's rule for that case: "return prior model turns and thought signatures unchanged when switching models across turns." In practice, keep the assistant messages exactly as the first model returned them, tool calls included, and send the whole history to the second.
Failure modes when one app routes across the family
An effort table built for one model. Neon and Hydrogen accept xhigh; Carbon and Argon stop at high. A shared effort setting has to be one every routed model accepts, or the router needs a value per model, as in ROUTES.
Requests without a level. The same request thinks at high on Neon and Hydrogen and at medium on Carbon and Argon. Moving a route between models without setting a level changes how much it thinks, and so what it costs.
Long non-streaming answers on Carbon or Argon. Both return at most 32,768 tokens on a non-streaming call, and on Google's API asking for more returns a 400. Keep their routes at 32,768 or stream.
History rebuilt when the model changes. When a planner hands off to an executor across turns, the earlier assistant turns and their thought signatures have to go back unchanged. Rebuilding them from your own logs breaks the rule Google states for switching models.
Hydrogen on long agent runs. Hydrogen Xhigh took 405 steps per task in AA's coding-agent runs, more than twice as many as the others, so its speed per token didn't make those runs finish sooner: about the same half hour. At the high setting it also trails Neon by 7.6 points on Terminal-Bench 4.0.
A December budget built on AIHubMix's current prices. AIHubMix lists Carbon and Argon at the introductory price today and hasn't published what it will charge from December 1. At Google's December rates, Carbon Medium goes from $3.29 to $6.59 per AA task and Carbon High from $3.88 to $7.76, both above Neon High's $3.74, which matches them on the index. Argon Medium goes from $4.31 to $8.63, about four and a half times Neon Medium. Per token, Carbon and Argon become a third more expensive than Neon and more than twice the price of Hydrogen. Check the model pages before you budget December.
What this comparison doesn't verify
No live test was run for this post; the router shows the request shape. The measurements are AA's snapshot of Google's API from 2026-11-19 at 13:27 UTC, and AA re-runs models. The re-priced Carbon and Argon costs are estimates computed from AA's figures, not AA measurements. Hydrogen's fabricated-claims figure and the model descriptions are Google's. AIHubMix hasn't published December prices for Carbon and Argon.
Keep reading: the Gemini 4 Neon series
- If the routing left you choosing between Neon and Carbon for hard work, the head-to-head goes deeper on quality, speed and the December cost change: Gemini 4 Neon vs Carbon: is the faster model good enough?
- If you're about to point an existing Gemini integration at the Neon route, the migration guide lists the 400 errors, the default-level change and the 65K output cap: Gemini 4 Neon migration: default high thinking, 400 errors and the 65K cap
Sources
- Google AI Studio, Choosing a model
- Google AI Studio, Gemini API pricing
- Artificial Analysis, LLM leaderboard (accessed 2026-11-19, 13:27 UTC)
- Artificial Analysis, Coding Agent Index (accessed 2026-11-19, 13:27 UTC)
- AIHubMix, Gemini 4 Neon
Top comments (0)