Gemini 4 Hydrogen: The Price Is the Story — $1.50/$7.50, Four Thinking Levels, and a Router That Saves Your Budget

Google shipped Gemini 4 Hydrogen on November 12, and the headline number isn't a benchmark. It's a price: $1.50 in / $7.50 out per million tokens, with a 1M-token context at one flat rate — no long-context surcharge — and the first free API tier of any Gemini 4 model.

The benchmark line is almost an afterthought: Hydrogen scores 51 on the Artificial Analysis Intelligence Index at the default (high) thinking level and 54 at xhigh, against Argon's 50. Google didn't lead with a stronger flagship and then talk price. It put a model that scores a point above Argon at the lowest price point — and made it free to try.

This post is not about the leaderboard. It's about three bills you should run before you route a single agent task through Hydrogen: the pricing bill, the thinking-level bill, and the routing bill.

Bill 1: The price table — where Hydrogen actually sits

Three things worth noticing:

1. Hydrogen undercuts Argon's intro price by 25% — and Argon's intro price doubles on December 1. Hydrogen carries no published expiry date.
2. Against Carbon's December pricing, Hydrogen is 62.5% cheaper on both input and output.
3. The free tier is the real dividing line. Argon and Carbon don't have one; Hydrogen does. That means small-volume workloads can start at a $0 bill and grow from there, instead of starting with a subscription decision.

Bill 2: Four thinking levels — a cost knob, not a quality slider

Hydrogen ships with four thinking levels: low, medium, high (default), and xhigh. Google hasn't published the token multiplier per level, but the intent is clear: the thinking level is a cost knob.

Run the simplest possible math on official pricing. One agent task, 100K input tokens and 20K output tokens:

# Gemini 4 Hydrogen per-task cost estimate (official pricing, USD) INPUT_PRICE = 1.50 / 1_000_000 # per input token OUTPUT_PRICE = 7.50 / 1_000_000 # per output token def task_cost(input_tokens: int, output_tokens: int) -> float: return input_tokens * INPUT_PRICE + output_tokens * OUTPUT_PRICE # One medium task: 100K input + 20K output print(task_cost(100_000, 20_000)) # 0.30 USD # 100 of the same tasks a day print(task_cost(100_000, 20_000) * 100) # 30 USD # Same task on Carbon (post-Dec-1 pricing): $4 in / $20 out per million print(100_000 * 4 / 1_000_000 + 20_000 * 20 / 1_000_000) # 0.80 USD 

$0.30 vs $0.80 per task — a 2.7x gap. At 100 tasks a day that's $30 vs $80.

In practice, the level assignment should look like this:

• low: format conversion, summarization, classification — anything decidable at a glance
• medium: routine code completion, single-file changes
• high (default): multi-file work, changes that need real reasoning
• xhigh: only the genuinely hard problems — and only after a small sample proves the extra spend buys a measurable improvement over high

One trap: thinking tokens are billed as output. The higher the level, the more output tokens the thinking process burns, and the bill grows faster than intuition suggests. Grade your tasks first, then pick the level — not the other way around.

Bill 3: Orchestrator routing — spend the expensive model only where it earns it

Antigravity shipped Orchestrator alongside Hydrogen: Carbon plans, Hydrogen executes and tests, with dynamic routing between the two, inside paid Pro and Ultra subscriptions.

The split is worth copying into your own agent architecture even if you never touch Antigravity:

1. Planning (breaking down requirements, designing the approach, judging risk) goes to the strong model — few calls, high value per call
2. Execution (writing code, running tests, fixing errors, reformatting) goes to the cheap model — many calls, low value per call
3. Add an escalation rule in between: if an execution step fails twice in a row, or test coverage drops, promote that step back to the strong model

Most teams' exploding bills aren't caused by expensive models. They're caused by no grading at all — letting the flagship model do formatting work. Orchestrator just productizes the common sense.

Pre-launch checklist

[ ] Run one real week on the free tier first; record the call distribution per level [ ] Write down which task types map to low / medium / high / xhigh — in writing [ ] Thinking tokens bill as output — budget for thinking cost, not just answer cost [ ] Argon and Carbon prices rise on December 1; assess migration for tasks that depend on them [ ] Split planning from execution: strong model plans, Hydrogen executes by default [ ] Set a monthly spend cap in AI Studio before running large batches [ ] The free tier quota is unpublished — don't put all production traffic on it 

Honest limitations

First, every benchmark cited here (AA Index 51/54, 2.5x faster than Gemini 3.8 Flash) is Google's own claim, not independently reproduced, and I haven't run the model myself to verify it.

Second, the cost script is arithmetic on official pricing. Your real bill depends on your input/output ratio and your thinking-level distribution — run your own tasks on the free tier before setting a budget.

Third, the free API tier's quota is unpublished. Free is not unlimited; production traffic needs a paid fallback.

The takeaway

Google's play here is blunt: don't compete on "strongest," compete on "cheapest to run all day." A model that scores a point above Argon, priced lower, with a free tier, is built to be the everyday workhorse for agents — not the trophy on the shelf.

How much does your agent burn per day right now? Re-run that number at Hydrogen's prices and tell me the difference — drop your task type and token volume in the comments and I'll help you figure out which thinking level fits.