AI Models

Gemini 4 Carbon vs Hydrogen: Cost Per Task and Routing

Gemini 4 Carbon and Hydrogen compared on price per token, price per task, benchmarks, and a plan-then-execute routing pattern with code.

·
10 min read
·
AI-assisted

AI tooling disclosure

Generative AI materially contributed to this article.

Human review confirmed by the author.

Gemini 4 Carbon vs Hydrogen: Cost Per Task and Routing

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

Comments(0)

Join the discussion by logging into your account.

No comments yet. Be the first to comment!

Shobit Singh

Passionate developer sharing knowledge about modern web technologies and best practices.

Subscribe to Shobit Singh's Newsletter

Direct email dispatches when new stories are published. Zero algorithms.