Google made Gemini 4 Carbon generally available on November 10 and launched Gemini 4 Hydrogen two days later. The easy summary is that Carbon is the strongest model and Hydrogen is the cheap one. The useful summary is narrower, because the two models spend very different numbers of tokens per task, and per-token price alone points you at the wrong answer. This post gives you the decision table first, then the cost math, the benchmarks, a routing pattern, and migration checks.
Which model for which job #
| Job | Pick | Starting thinking level |
|---|---|---|
| Everyday coding, tool-calling agents, multimodal document work | Hydrogen | high (default) |
| Hard debugging, architecture, security audits, science | Carbon | medium (default), high for the hardest cases |
| Parallel worker and verifier agents | Hydrogen | medium or high |
| Multi-step jobs that need a plan first | Carbon plans, Hydrogen executes | Carbon medium, Hydrogen high |
| High-volume classification, routing, sub-second latency | Gemini 3.5 Flash-Lite | not applicable |
Source: Google's Hydrogen developer guide. The defaults and model roles come from that guide. The thinking levels in the last column, apart from the defaults, are my starting points for your own evals, not Google guidance.
The same guide calls Hydrogen the recommended upgrade from Gemini 3.8 Flash and earlier Gemini 3 and 2.5 models. It describes Carbon as the model that spends more thinking tokens per turn to test hypotheses and verify edge cases.
What shipped, and how the models relate #
| Model | First announced | General availability | Lineage |
|---|---|---|---|
| Gemini 4 Argon | Sep 30, 2026 | Oct 13, 2026 | Base model |
| Gemini 4 Carbon | Oct 28, 2026 (cyber defenders only) | Nov 10, 2026 | Based on Argon |
| Gemini 4 Hydrogen | Nov 12, 2026 | Nov 12, 2026 | Adapted from Carbon |
Sources: Artificial Analysis for release dates, Simon Willison on Argon's API launch, the Carbon launch post, and the model cards for Carbon and Hydrogen for lineage.
The Hydrogen developer guide says all three models share the same 1M unified context window, long decode architecture, and built-in tools. It also says moving from Carbon or Argon to Hydrogen requires no request schema changes. The exact window size and output caps are in the migration table below.
Price per token is not price per task #
| Model | Input | Cached input | Output, thinking included |
|---|---|---|---|
| Hydrogen | $1.50 | $0.075 | $7.50 |
| Carbon, through Nov 30 | $2.00 | $0.10 | $10.00 |
| Carbon, from Dec 1 | $4.00 | $0.20 | $20.00 |
USD per 1M tokens. Sources: Hydrogen from the developer guide. Carbon's $2/$10 introductory price and the $4/$20 price from December 1 from the Carbon launch post. Carbon's cached rates from Simon Willison's pricing table, which match the cached rates for Argon on Google's pricing page.
Hydrogen is 25 percent cheaper than Carbon per token until November 30, then 62.5 percent cheaper from December 1. That is my arithmetic from the table. Willison's write-up describes the later gap as 75 percent, but the figures in his own table work out to 62.5. Hydrogen's price is also flat across the whole 1M-token context, per Google's launch post.
Willison ran one SVG prompt on both models at high thinking and recorded the bill.
| Run | Output tokens | Cost | Wall time |
|---|---|---|---|
| Carbon, high | 20,305 | 20.31 cents | 4m 11s |
| Hydrogen, high | 5,311 | 3.99 cents | 19s |
Carbon cost 5.1 times as much and took 13.2 times as long (my arithmetic). At the December 1 rate, the same Carbon run would cost 40.63 cents, per the calculator below. Willison also notes the Hydrogen drawing was much plainer, so the extra Carbon spend bought visible detail. One prompt is an anecdote, not a benchmark, but it shows where the money goes.
Independent per-task numbers #
Artificial Analysis runs an independent intelligence index (v5.0.1) and publishes time, tokens, and cost per task, which makes it the cleanest comparison on spend. Time to first answer token is the wait before any visible output, thinking included.
| Model | Effort | Index | Minutes per task | First answer token (s) | Output tokens in index run |
|---|---|---|---|---|---|
| Hydrogen | xhigh | 54 | 14.7 | 42.26 | 304M |
| Hydrogen | high | 51 | 8.3 | 16.21 | 110M |
| Hydrogen | medium | 41 | 3.8 | 11.66 | 54.4M |
| Hydrogen | low | 27 | 1.4 | 6.28 | 20.3M |
| Carbon | high | 60 | 32.1 | 73.49 | 205M |
| Carbon | medium | 58 | 28.0 | 20.89 | 124M |
| Carbon | low | 54 | 25.9 | 10.90 | 83.9M |
| Argon | high | 50 | 30.3 | 43.71 | 113M |
| Argon | medium | 48 | 27.6 | 12.65 | 81.7M |
Sources: Artificial Analysis pages for Hydrogen, Carbon, and Argon, read on November 16, 2026.
At its default high setting, Hydrogen scores 51 against Argon's 50, the same comparison Google makes in its launch post. It emits about the same output volume, 110M tokens against 113M, but finishes a task in 8.3 minutes instead of 30.3 because it streams at 170 tokens per second against 64. So Hydrogen's edge over Argon is speed and the rate card, not token thrift.
Artificial Analysis lists a cost per task for three of these variants: $5.48 for Carbon at high, $4.97 for Argon at high, and $3.16 for Hydrogen at xhigh. Carbon's 60 therefore costs about 73 percent more per task than Hydrogen's 54 (my arithmetic). Those figures use the $2/$10 Carbon rate, so if token use stays the same, I would expect Carbon's number to roughly double after December 1. That is an inference, not a published figure.
One pattern deserves a test on your own workload. Hydrogen at xhigh and Carbon at low both score 54. Hydrogen finishes in 14.7 minutes against 25.9, but it emitted 304M tokens against 83.9M. On output tokens alone, that is about 2.7 times the spend at Hydrogen's lower rate (my arithmetic, ignoring input and caching). Carbon at low may be the cheaper way to buy a 54, though Artificial Analysis does not price that variant.
Latency also limits where the top settings fit. The first answer token takes 73.49 seconds on Carbon at high and 42.26 seconds on Hydrogen at xhigh, so neither suits an interactive chat surface. Hydrogen at low answers first in 6.28 seconds, but its index score of 27 sits well below the 41 of Hydrogen at medium.
The low-price claim, in context #
Hydrogen is the cheapest Gemini 4 model and has a free tier on the Gemini API, according to the developer guide. Argon, by contrast, is not available on the free tier. Against the wider market the picture is less flattering. Willison lists Claude Haiku 5.5 and GPT-6 Luna at $0.10 input and $0.50 output per million tokens, which makes Hydrogen 15 times as expensive on both sides.
So "low price" holds against Carbon and Argon, and it holds against what Hydrogen scores for the money. It does not hold against small-tier models from other labs. Whether the gap matters depends on whether those models clear your quality bar, which no table here can answer.
Benchmarks: where each model wins #
Google's Hydrogen model card compares it with Claude Sonnet 5.5 and GPT-6.1 Terra. Every benchmark figure in this section is vendor-reported.
| Benchmark | Hydrogen | Claude Sonnet 5.5 | GPT-6.1 Terra |
|---|---|---|---|
| SWE-sweep | 13.5% | 3.1% | 5.8% |
| Terminal-Bench 4.1 (cheating-adjusted) | 57.0% | 63.9% | not reported |
| Agents' Last Exam v1.1 | 71.6% | 60.4% | 69.8% |
| AutomationBench-AA | 76.1% | 71.8% | 60.2% |
| Vending-Bench 2 (bank balance) | $14,549 | $11,165 | $9,107 |
| OSWorld-2.1 (offline subset) | 77.6% | 83.9% | 74.2% |
| MKA | 53.4% | 52.0% | 43.8% |
| Chartography | 66.6% | 61.6% | 63.2% |
| Terminal-Bench-Science 0.1 | 51.4% | 59.9% | 58.3% |
| HLE-Diamond | 58.8% | 53.3% | 47.3% |
Hydrogen leads seven of the ten rows. Claude Sonnet 5.5 leads the other three: Terminal-Bench 4.1, OSWorld-2.1, and Terminal-Bench-Science 0.1. If your agents do computer use or long terminal sessions, those three rows matter more than the headline count.
Carbon's model card compares it with Argon, GPT-6 Astra, and Claude Opus 5.5. The card also lists Claude Fable 5.1, which this table leaves out for width.
| Benchmark | Carbon | Argon | GPT-6 Astra | Claude Opus 5.5 |
|---|---|---|---|---|
| AA Index v5.0 | 59 | 50 | 57 | 58 |
| FrontierSWE 2 | 61.2% | 55.0% | 65.5% | 62.3% |
| Terminal-Bench 4.0 (AA) | 65.2% | 57.1% | 59.1% | 59.6% |
| OSWorld-2.1 (offline subset) | 81.5% | 74.7% | 80.9% | 87.2% |
| AutomationBench | 53.9% | 51.3% | 41.4% | 42.5% |
| Vending-Bench 2 (bank balance) | $16,484 | $13,718 | $15,515 | $9,235 |
| GraphWalks, 256k to 1M, BFS F1 | 96.2% | 84.2% | 71.8% | 66.8% |
| Terminal-Bench-Science 0.1 (AA) | 64.8% | 52.9% | 63.3% | 59.0% |
By my count of the card's 17 rows, Carbon has the top score on 15. GPT-6 Astra leads FrontierSWE 2 and Claude Opus 5.5 leads OSWorld-2.1. The card dates its index score of 59 to v5.0, while Artificial Analysis now lists 60 on v5.0.1, most likely an index version difference.
Treat the cybersecurity rows with care. The card says those results reflect access through the Fairwind Program, the channel that gives verified defenders specialized dual-use cybersecurity capabilities, so they may not describe what the general API model does by default. Google also reports that Carbon ranks first on CursorBench 4.0, Perplexity's WANDR, and Zapier's AutomationBench at more than 2x lower cost per task than the next best external model, per its Carbon post. Those are Google's claims and I have not reproduced them.
Build it: a cost calculator you can run #
This script prices any workload on the three rate cards above. I ran it on November 16, 2026 with Node, and the output below is what it printed.
// cost.mjs - run with: node cost.mjs
// USD per 1M tokens. Output includes thinking tokens, which Google bills as output.
const PRICES = {
"hydrogen": { input: 1.5, cached: 0.075, output: 7.5 },
"carbon-intro": { input: 2.0, cached: 0.1, output: 10 }, // through Nov 30, 2026
"carbon-dec1": { input: 4.0, cached: 0.2, output: 20 }, // from Dec 1, 2026
};
const usd = (model, { input = 0, cached = 0, output = 0 }) => {
const p = PRICES[model];
return (input * p.input + cached * p.cached + output * p.output) / 1e6;
};
const scenarios = {
"1M in, 200k out, no cache": { input: 1_000_000, output: 200_000 },
"200k fresh + 800k cached in, 200k out": { input: 200_000, cached: 800_000, output: 200_000 },
"SVG run, Carbon token counts": { input: 40, output: 20_305 },
"SVG run, Hydrogen token counts": { input: 40, output: 5_311 },
};
for (const [name, usage] of Object.entries(scenarios)) {
const row = Object.keys(PRICES).map((m) => `${m}=$${usd(m, usage).toFixed(4)}`);
console.log(name.padEnd(40), row.join(" "));
}
| Scenario | Hydrogen | Carbon, intro | Carbon, from Dec 1 |
|---|---|---|---|
| 1M input, 200k output, no cache | $3.00 | $4.00 | $8.00 |
| 200k fresh plus 800k cached input, 200k output | $1.86 | $2.48 | $4.96 |
The two SVG rows print for every price list, but only two cells are meaningful: Carbon's token counts on Carbon's rates and Hydrogen's token counts on Hydrogen's. Those come to $0.2031 and $0.0399, which match Willison's 20.31 and 3.99 cents. Caching matters more than the model choice here, since implicit caching discounts cached input by 95 percent on prompts of at least 4,096 tokens.
Build it: plan with Carbon, execute with Hydrogen #
flowchart LR
T[Task arrives] --> Q{Hard to plan or debug?}
Q -- yes --> C[Carbon plans at medium thinking]
Q -- no --> H[Hydrogen at high thinking]
C --> P[Ordered plan with test criteria]
P --> W[Hydrogen workers execute steps]
W --> V[Hydrogen verifier runs tests]
H --> V
V -- fails twice --> C
V -- passes --> D[Done]
The developer guide has Carbon plan interfaces or resolve roadblocks, and Hydrogen handle code edits, parallel subagent tasks, and test runs. It tells you to route planning turns to Carbon and execution turns to Hydrogen in one multi-turn session using previous_interaction_id. Google's launch post likewise describes Carbon as coordinator and Hydrogen as worker and verifier. The escalation edge in the diagram, back to Carbon after two failed verifications, is my design choice, not Google guidance.
The guide's code examples use the same client.interactions.create call, generation_config, thinking_level, and output_text as the snippet below, but they never show previous_interaction_id, which appears only in prose. The snippet combines the two.
I type-checked the snippet against @google/genai 3.3.0 and ran it against a local mock server, which confirmed the SDK puts previous_interaction_id and generation_config in the request body. I never called the live API, so test it before you rely on it. One mismatch to watch: the SDK posted to /v1/interactions by default, while the guide's REST example uses /v1beta/interactions.
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({});
// Turn 1: Carbon plans.
const plan = await client.interactions.create({
model: "gemini-4-carbon",
input: "Plan the migration of our job queue from cron to BullMQ. Give ordered steps with test criteria.",
generation_config: { thinking_level: "medium" },
});
// Turn 2: Hydrogen executes inside the same session.
const step = await client.interactions.create({
model: "gemini-4-hydrogen",
previous_interaction_id: plan.id,
input: "Implement step 1 of the plan and write its tests.",
generation_config: { thinking_level: "high" },
});
console.log(step.output_text);
Google ships the same idea inside Antigravity as an Orchestrator that, in the launch post's words, dynamically switches between models like Carbon and Hydrogen within the same session. On Terminal-Bench 4.0 it reached near-Carbon task success rates while consuming 24 percent less quota and finishing 19 percent faster on average. That is a vendor result with no published method, so measure your own tasks.
Migration checks from Gemini 3.8 Flash #
| Change | What to do |
|---|---|
| Model ID | Replace gemini-3.8-flash with gemini-4-hydrogen |
| Default thinking | Hydrogen defaults to high, adds xhigh, and rejects minimal with an error |
| Explicit caching | Not supported, so remove cached_content fields and rely on implicit caching |
| Sampling parameters | Remove temperature, top_p, and top_k, since out-of-range values return a 400 |
| Tools | Declare tools natively, because raw-text JSON tool calls with no declared tools can return MALFORMED_FUNCTION_CALL |
| Output cap | max_output_tokens caps thinking plus answer, so raise low caps such as 8,192 to 65,536, the synchronous limit per hop |
| Long outputs | Set background to true and max_output_tokens above 65,536, which long decode can stretch to the 1M window |
| Context | One 1,048,576-token window now covers input, thinking, and output |
Source: the Hydrogen migration checklist. The same guide recommends running evals at all four thinking levels with a high output cap and then choosing the lowest level that meets your quality bar. It warns that xhigh can overthink simple prompts and raises latency and token use.
Safety notes before you ship #
Hydrogen's model card reports that unjustified refusals are higher than on Gemini 3.8 Flash, particularly for multimodal prompts, with a 5.57 percentage point shift on that evaluation. It also says Hydrogen reached the alert threshold, but not the critical capability level, for both biological and cyber risk. The card said its full safety report was coming in the following days.
For Carbon, Google's launch post reports a 0.8 percent per-attempt breach rate in simulated cyberattack testing, against 3.1 percent for Argon. These are Google's own evaluations. If you run Hydrogen on user-facing multimodal flows, log refusals and compare them against your current model before switching traffic.
Method and limits #
I fetched Google's launch posts, both model cards, the Hydrogen developer guide, Google's pricing page, the three Artificial Analysis pages, and Willison's November 12 post on November 16, 2026. Prices and index scores change, so recheck them before you commit.
Sources #
| Source | Used for |
|---|---|
| Introducing Gemini 4 Hydrogen | Launch claims, flat pricing, Orchestrator figures |
| Gemini 4 Carbon is now available | Carbon availability, price schedule, safety figures |
| Hydrogen model card | Hydrogen benchmarks, lineage, safety notes |
| Carbon model card | Carbon benchmark table, lineage |
| Hydrogen developer guide | Pricing, thinking levels, migration, routing |
| Gemini API pricing | Argon rates and free-tier status |
| Artificial Analysis: Hydrogen | Index, time, tokens, cost per task |
| Artificial Analysis: Carbon | Index, time, tokens, cost per task |
| Artificial Analysis: Argon | Index, time, tokens, cost per task |
| Simon Willison, Nov 12 | Rate table, SVG run costs, Haiku 5.5 and GPT-6 Luna prices |
| Simon Willison, Oct 13 | Argon API availability |