Gemini 4 Hydrogen: Benchmarks and Real Cost per Agent Task

Google's new workhorse model matches its own frontier model on the leading independent index, costs a fraction of it per token, and finishes agent tasks faster than anything near its price. Whether it is cheap depends entirely on how your agent spends tokens. Here is the evidence, the arithmetic and the decisions it implies.

Google's launch post for Gemini 4 Hydrogen contains a chart its competitors could have drawn themselves. Plotted on the Artificial Analysis Intelligence Index against cost per task, OpenAI's GPT-6.1 Terra sits to the left of Hydrogen at every reasoning level, which means Terra reaches the same score for less money - Google. Google published it anyway, because the chart next to it tells the other half of the story: plotted against minutes per task, Hydrogen's line pulls ahead of both Terra and Claude Sonnet 5.5.

That pair of charts is the most honest summary of the model you will find. Gemini 4 Hydrogen, released on November 12, 2026, costs $1.50 per million input tokens and $7.50 per million output tokens, flat across a 1M context window - Google AI Studio. At its default setting it scores 51 on the Artificial Analysis Intelligence Index, one point above Google's own frontier model Gemini 4 Argon, and 54 at its new top setting - Artificial Analysis. It replaces Gemini 3.8 Flash as the model Google recommends for everyday coding and agent work, it now answers questions in Google Search for everyone, and it costs exactly twice what 3.8 Flash costs today.

This guide is about what that means for anyone running AI agents. It covers what the model is, every price on its sheet and the price changes scheduled around it, what Google's benchmarks show and what independent tests found, and then the part most launch coverage skips: why the per-token price is a poor guide to what an agent task costs, in both directions, and how caching, thinking levels and orchestration decide the real bill. It ends with worked cost examples, a comparison against the alternatives scored on the same evidence, the model's failure modes, and a migration playbook.

This guide reflects Gemini 4 Hydrogen and its competitors as of November 15, 2026, three days after launch. Prices on Google's sheet change on December 1 and January 1, and independent benchmarks are still arriving, so verify current figures before committing a budget.

Contents

1. What Gemini 4 Hydrogen Is, and What It Replaced
2. The Price Sheet and the Three Clocks Running on It
3. Google's Benchmarks, Read Carefully
4. The Independent Picture: Artificial Analysis, Puter and Box
5. Cost per Task: Why the Token Price Misleads in Both Directions
6. The Input-Token Problem: Caching Decides Most of an Agent's Bill
7. Thinking Levels: Choosing Low, Medium, High or Xhigh
8. Worked Examples: Three Agent Shapes and What They Cost
9. Orchestration: Hydrogen as the Worker Under a Frontier Planner
10. Hydrogen Against the Alternatives
11. Where Hydrogen Fails: Limitations and Failure Modes
12. Migration Playbook: From Gemini 3.8 Flash, Carbon or Argon
13. The Bigger Picture: What Hydrogen Says About Agent Economics
14. How to Decide: A Practical Checklist

1. What Gemini 4 Hydrogen Is, and What It Replaced

Google describes Gemini 4 Hydrogen as a fast, efficient model for everyday coding and agentic work, and draws the line against its larger siblings explicitly: Gemini 4 Carbon and Gemini 4 Argon "excel at deep, long-horizon reasoning on your hardest problems," while Hydrogen "is built for rapid execution across diverse agentic workflows" - Google. The announcement came from Koray Kavukcuoglu, Google DeepMind's SVP and Google's Chief AI Architect, which signals that Google treats this as a flagship launch rather than a point release.

The model card fills in what the blog post leaves out. Hydrogen is adapted from Gemini 4 Carbon, Google's top model, rather than trained as a separate small model from scratch. It accepts text, images, audio and video, shares one combined input and output window of up to 1M tokens, returns up to 64K output tokens per synchronous request, and can write up to 1M tokens through a background "long decode" mode. Its knowledge cutoff is March 2026 - Google model card. The lineage matters for agents: a model distilled from a frontier parent tends to inherit its tool-use habits and instruction following, which is exactly what Google claims Hydrogen does better than 3.8 Flash.

Where Hydrogen shows up

Hydrogen launched everywhere Google ships models on the same day. Developers get it in the Gemini API and Google AI Studio on all tiers, including the free tier, under the model ID gemini-4-hydrogen - Google AI Studio docs. Paid Google AI Pro and Ultra subscribers get it in Google Antigravity, Google's agent-first coding environment, and businesses get it through Gemini for business and in Google Sheets. In the consumer Gemini app it appears in the model picker as the "Everyday help" option, between Gemini 3.5 Flash-Lite for quick answers and Gemini 3.1 Pro for detailed research, with Argon and Carbon above them for code, analysis and the most complex work - 9to5Google. Free users reach it through automatic model selection when Google judges a prompt needs it.

The biggest deployment is Search. Google's VP of Product for Search, Robby Stein, called Hydrogen "the biggest model upgrade to Search yet" and said it is available globally for all users, with better handling of multi-part questions, typos and highly specific requests, plus a broader fan-out of simultaneous sub-queries - Google Search blog. On the enterprise side, Google Cloud's Gemini Enterprise Agent Platform lists Hydrogen among its generally available models - Google Cloud.

A model that serves Google Search to billions of queries is, almost by definition, a model Google has optimized hard for cost per answer and latency on its own hardware. That is the first structural clue to what Hydrogen is for: it is the model Google itself can afford to run at the largest scale it operates.

The naming problem, and a mental model that works

Developers have not taken kindly to the names. On the Hacker News launch thread, which drew more than 350 comments, one commenter pointed out that the capability order Hydrogen, Argon, Carbon is neither alphabetical nor by atomic number, while the other labs use legible ladders like Luna, Terra, Sol, Astra and Haiku, Sonnet, Opus, Fable - Hacker News. The confusion is real enough that it is worth replacing the chemistry with roles.

Read Hydrogen as the slot Google's Flash models used to hold: the default model you run most of your traffic through. Google's own pricing page describes Argon as "the efficient Gemini 4 model, with lower token spend per turn than Carbon" - Google AI Studio, and Carbon as the frontier model. The Decision model at the bottom is a different kind of model entirely, covered in section 9.

What it replaced, and what it did not

Google's migration guide calls Hydrogen the recommended upgrade from Gemini 3.8 Flash and earlier models - Google AI Studio docs. In the Gemini app the swap was immediate, and one Hacker News commenter described opening the app and finding 3.8 Flash already replaced by "4 Hydrogen" with no idea what it was - Hacker News. In the API, though, nothing was switched off: 3.8 Flash stays on the price list, at its introductory rate, until the end of the year. That overlap is deliberate, and section 2 explains why it is the single most important pricing fact for teams currently running on Flash. For the full background on the model Hydrogen succeeds, see our Gemini 3.8 Flash guide.

2. The Price Sheet and the Three Clocks Running on It

Hydrogen's price is simple on its face and full of consequential detail underneath. The standard paid rate is $1.50 per million input tokens, $7.50 per million output tokens with thinking tokens billed as output, and $0.075 per million cached input tokens, a 95% discount. Google offers four other ways to buy the same model, and the price differences between them are larger than the differences between many competing models.

The tier prices come from Google's pricing page, which also notes that the free tier's data is used to improve Google's products while paid-tier data is not - Google AI Studio. The Contributor tier, which halves the price in exchange for letting Google use request data, is invite-only - VentureBeat. Through OpenRouter, Hydrogen is served by Google AI Studio and Google Vertex at the same tier prices, plus a Vertex EU in-region route at $1.65 input and $8.25 output - OpenRouter.

The practical lesson from the tier table is that half the price is a scheduling decision. Any agent work that does not need an answer within seconds (overnight document processing, evaluation runs, backfills, bulk classification) costs half as much on Batch or Flex. Teams routinely leave this on the table because their agent framework sends everything through one synchronous client.

Flat pricing across the whole context window

Hydrogen charges the same rate for the millionth token of a prompt as for the first, "flat across the full context window" in Google's words - Google. That is not universal. Claude Haiku 5.5 costs $0.10 input on prompts up to 100K tokens but $0.50 input and $2.50 output above that, a fivefold jump - Anthropic. OpenAI's GPT-6.1 Sol moves from $2 to $4 input and from $10 to $15 output above 272K input tokens - OpenAI. Google's own older Gemini 3.1 Pro Preview still doubles its input price above 200K tokens - Google AI Studio.

For agents this matters more than for chatbots, because agent context grows. A coding agent that has read twenty files, or a research agent that has accumulated forty search results, crosses 100K or 200K tokens routinely. On a tiered model the price of every remaining turn jumps at that threshold; on Hydrogen it does not. The long-context discount is invisible on a headline price comparison and very visible on an invoice.

Clock one: Gemini 4 Carbon and Argon double on December 1

Google launched both of its Gemini 4 frontier models at an introductory price that expires soon. Gemini 4 Carbon and Gemini 4 Argon cost $2 input and $10 output through November 30, 2026, and $4 input and $20 output starting December 1, with cached input moving from $0.10 to $0.20 - Google AI Studio. On December 1 the gap between Hydrogen and the frontier tier therefore widens from 1.33x to 2.67x on both input and output. Our Gemini 4 Argon guide covers what that model does at both prices.

Clock two: Gemini 3.8 Flash doubles on January 1

The more consequential clock is the one on Hydrogen's predecessor. Gemini 3.8 Flash costs $0.75 input and $3.75 output through December 31, 2026, and $1.50 input and $7.50 output from January 1, 2027, with its cache storage fee also doubling from $0.50 to $1.00 per million tokens per hour - Google AI Studio. The previous-generation Gemini 3.6 Flash follows the same schedule.

Read those numbers again: on January 1, 3.8 Flash costs exactly what Hydrogen costs today. VentureBeat noticed the same thing, observing that Flash's scheduled standard rate from January 1 matches Hydrogen's price - VentureBeat. The structural reading is that $1.50 and $7.50 is Google's price for its workhorse tier, and 3.8 Flash's current rate is a migration bridge that closes at year end. Anyone who stays on 3.8 Flash past December 31 will pay Hydrogen's price for a model that scores 31 instead of 51 on the same index. The only rational reason to stay on 3.8 Flash is the six weeks of half price, and only for workloads where it genuinely costs less per task, which section 5 shows is not the agent case.

Clock three: old models get rerouted on December 1

The third clock affects teams who never chose either model. Google's pricing page states that from December 1, 2026, requests to gemini-2.5-pro will automatically route to Gemini 3.8 Flash and be billed at its rates, and requests to gemini-2.5-flash will route to Gemini 3.5 Flash-Lite - Google AI Studio. A forgotten integration pinned to a 2025 model name will keep working, but it will run on a different model with different behavior. Audit your model IDs before December 1, not after.

Is Hydrogen expensive? It depends on who you compare it with

Against the small models that most production agent traffic actually runs on, Hydrogen is not cheap. Claude Haiku 5.5, GPT-6 Luna and Meta's Muse Ember all charge $0.10 input and $0.50 output for normal-length prompts, and VentureBeat calculated that Hydrogen costs about 15 times as much per uncached input and output token as those three - VentureBeat. Even within Google's lineup, Gemini 3.5 Flash-Lite costs $0.30 input and $2.50 output.

Against the mid-tier models it benchmarks against, Hydrogen is cheaper per token. Claude Sonnet 5.5 costs $2 input and $10 output, while GPT-6.1 Terra undercuts Hydrogen at $1 input, $5 output and $0.05 for cached input - OpenAI. One Hacker News commenter asked whether Google is abandoning the fast-and-cheap tier altogether, since Hydrogen serves Search like an entry model but is priced well above what anyone pays for 3.8 Flash or Flash-Lite today - Hacker News. The answer is that Google has split the old Flash slot in two: Flash-Lite remains the cheap tier, and Hydrogen has moved up to compete with Terra and Sonnet. For a broad price comparison across every lab, our cheapest LLM APIs for agents table is the reference.

Two line items that are not tokens

Two charges sit outside the token price and can dominate it. The first is search grounding. On the paid tier, Grounding with Google Search gives 5,000 free requests per month shared across all Gemini 3 and newer models, then costs $14 per 1,000 requests, subject to a daily cap of 1,500 requests; it is not available on the free tier, and Google notes that one request to Gemini can trigger several Search queries, each charged - Google AI Studio. A research agent that searches twenty times per task pays $0.28 per task in search fees once past the free allowance, which can exceed its entire token bill.

The second is caching behavior. Hydrogen does not support explicit context caching at all (no cachedContents, no caches.create); only implicit caching applies, automatically, on prompts of at least 4,096 tokens - Google AI Studio docs. Section 6 explains why that one sentence probably matters more to your agent bill than the headline price.

3. Google's Benchmarks, Read Carefully

Google's model card compares Hydrogen against two models on ten benchmarks. The selection of comparators is itself informative: Google chose Claude Sonnet 5.5 and GPT-6.1 Terra, the mid-tier models at $2/$10 and $1/$5, rather than the small models Hydrogen's predecessor competed with. Google is positioning Hydrogen one rung up from where Flash used to sit.

All figures are Google's, as of November 2026 - Google model card. Hydrogen leads on seven of the ten, and Sonnet 5.5 leads on the other three (Google lists no Terminal-Bench 4.1 result for Terra).

What these benchmarks actually measure

A non-specialist reading this table needs to know that the names describe very different kinds of work. Terminal-Bench gives a model a command-line environment and a task (configure a server, fix a build, process data) and checks whether the end state is correct; it is the closest proxy here for a coding agent working in a real shell. OSWorld measures computer use: operating a desktop through screenshots, clicks and keystrokes. Vending-Bench 2 runs a model as the operator of a simulated vending business over a long horizon and scores the bank balance it ends with, which makes it a test of sustained, coherent decision-making rather than a single answer. AutomationBench-AA and Agents' Last Exam test multi-step workflows across business tools. HLE-Diamond is a hard expert-knowledge exam, and MKA tests agentic understanding of multimodal material.

Seen that way, the pattern in the table is coherent. Hydrogen wins the knowledge-work and multi-step workflow benchmarks, where planning across tools and staying on task matter, and loses the ones that demand precise execution in an environment: the terminal, the desktop and terminal-based science tasks. Google itself recommends Hydrogen for "fast, disciplined execution on its own or as sub-agents orchestrated alongside frontier models," iterative repository coding and multimodal knowledge work - Google model card. If your agent's core job is operating a terminal or a desktop, the table itself says Sonnet 5.5 is stronger. For a deeper look at computer-use agents and what these scores mean in practice, see our guide to GPT-6.1 Terra's computer-use benchmarks and real cost.

The jump from 3.8 Flash

The most striking number in Google's announcement is the generational one. On Terminal-Bench 4.1, Hydrogen completes 57% of tasks against 18.2% for Gemini 3.8 Flash, and Google says it finishes tasks 2.5 times faster at its default setting and cuts fabricated claims by more than five times - Google. Google also reports partner tests on complex graphs, SQL and data-heavy enterprise workflows that ran 2x to 2.8x faster with 12% to 23% lower token usage than 3.8 Flash.

Elsewhere in the announcement, Google claims Hydrogen ranks first on the Vals Tax Agent Bench at 52.3%, ties for first on the Vals Legal Research Bench at 55.8%, and ranks fifth on Agent Arena, a live benchmark of multi-step tasks. The fifth place on Agent Arena is the one independent, crowd-judged result Google cites, and it is a useful corrective to the leadership claims: on live, open-ended tasks judged by people, four models are preferred to it.

Reading vendor benchmarks without being misled

Every lab chooses the benchmarks that flatter its model, and Google is no exception. A skeptical Hacker News commenter called the release set "10 mostly random benchmarks" and argued that labs are trading pass-at-one benchmark gains for worse failures at the tail of the distribution, the 1-in-100 run where an agent overreaches or does the opposite of what was asked - Hacker News. That critique is worth taking seriously because it describes exactly the failures that cost money in production (section 11 returns to it).

Three habits make vendor tables useful rather than misleading. Compare only within the same benchmark version and harness, since Terminal-Bench 4.0 and 4.1 are not interchangeable. Weight independent measurements above vendor ones wherever both exist. And map each benchmark to the job your agent actually does instead of averaging across all of them. Our piece on why AI coding benchmarks lie goes deeper on the mechanics of benchmark inflation.

4. The Independent Picture: Artificial Analysis, Puter and Box

Three independent or semi-independent sources had published measurements of Hydrogen within three days of launch, each testing something different. Together they confirm most of Google's direction and complicate its cost story.

Artificial Analysis: 51 at high, 54 at xhigh, and very wordy

Artificial Analysis runs the most widely cited independent index of model capability. Its Intelligence Index v5.0.1 is a weighted average of nine evaluations in four equally weighted categories: knowledge work (AA-Briefcase, AutomationBench-AA, GDP.pdf), coding (FrontierCode-AA 2.0, Terminal-Bench 4.0), science (Terminal-Bench-Science, CritPt) and general knowledge (AA-Omniscience, HLE-Diamond) - Artificial Analysis methodology. Several of those are long agentic tasks with many turns, which is why the index has become a reasonable proxy for agent capability and why its cost-per-task figures are relevant to agent budgets.

On that index, Hydrogen scores 54 at xhigh, 51 at high, 41 at medium and 27 at low, ranking 16th of 80 models at its top setting. It also ranks 78th of 79 on verbosity at xhigh: it generated 304 million output tokens to complete the index at that setting against a median of 77.3 million for comparable models - Artificial Analysis. The same page puts Gemini 4 Carbon at 60, Argon at 50 and Gemini 3.8 Flash at 31.

That verbosity ranking is the single most important independent fact about Hydrogen's cost. The model reaches its scores partly by thinking a lot, and thinking tokens are billed at the output rate. Google's own model card acknowledges that "at times the model may use more tokens to maximize performance, especially at higher thinking levels" - Google model card.

A warning about index versions

Artificial Analysis rebuilt its index for version 5 in late October 2026, and the new version is much harder. Scores from version 4 are not comparable with version 5 scores. When Gemini 3.8 Flash launched in September, we reported it at 59 on the index and $0.58 per task, figures that were accurate on version 4 at the time - our Gemini 3.8 Flash guide. On version 5.0.1, the same model scores 31 at high reasoning and costs $7.77 per task, after consuming 10.2 billion input tokens to run the index - Artificial Analysis. Nothing about the model changed; the definition of a task did. Any cost-per-task figure is meaningless without the benchmark version beside it, and every figure in this guide is from version 5.0.1 unless stated otherwise.

Terminal-Bench as measured independently

On Artificial Analysis's own run of Terminal-Bench 4.0, Hydrogen solved 54% of tasks at both high and xhigh, ahead of Muse Ember at 40.9%, Claude Haiku 5.5 at 32.8% and GPT-6 Luna at 12.6%, all measured at their maximum settings - VentureBeat. On the same benchmark, Claude Sonnet 5.5 scored 64% and GPT-6.1 Terra 56% - DataCamp. The independent ordering matches Google's: Hydrogen is far ahead of the small models on terminal work, roughly level with Terra, and clearly behind Sonnet 5.5.

Puter: fewer fabrications, more tokens

Puter, a platform that resells model access to developers, ran a small but carefully designed test of Google's "fewer fabricated claims" claim. It wrote 16 prompts that omitted needed information or asked about things that do not exist (a nonexistent npm flag, a made-up JavaScript method, a missing attachment) and ran each three times on both Hydrogen and 3.8 Flash at default settings, with grading rules written in advance - Puter.

The direction of Google's claim held: Hydrogen fabricated less and was faster on every prompt. But it cost about five times as much for the same 48 answers, because it thought on 42 of them while 3.8 Flash, at its medium default, thought on none. The author notes the counts are small (one more false Hydrogen answer would make the ratio about 3x, not 6x), that every test was a single question and answer, and that the site sells access to both models. Even with those caveats, the test isolates a mechanism that matters: on short, single-turn work, Hydrogen's default thinking makes it more expensive than its predecessor, not less.

Box: an enterprise workload, measured

Box, which builds AI agents over enterprise documents, tested Hydrogen on its Complex Work Eval before launch. Hydrogen scored 79% against 74% for Gemini 3.8 Flash, finished in less than half the time, and used about 12% fewer tokens on a typical task; the gains were largest in public-sector documents, which rose from 69% to 95%, and media, from 57% to 76% - Box. Box tested with early access and published no dollar figures, so treat the result as directional. It is nonetheless a multi-step, document-heavy agent workload, and on that kind of work Hydrogen used fewer tokens than its predecessor, the opposite of what Puter found on single answers. The next section explains why both results are correct.

5. Cost per Task: Why the Token Price Misleads in Both Directions

Start from what a task actually costs, because the per-token price is only one of three factors in it. For any model and any task, the bill is the sum of three products: the input tokens the agent sends across all of its turns, multiplied by the input price after caching discounts; the output tokens it generates, including thinking, multiplied by the output price; and the tool calls it makes, such as search queries, multiplied by their fees. The per-token price appears in that formula, but so do two quantities the price sheet never shows: how many tokens the model needs to finish the task, and how much of its input is served from cache.

Those hidden quantities vary between models by much more than prices do. A model that needs three attempts to finish a task, or that rereads its whole context on every turn, or that thinks for a thousand tokens before every tool call, can cost several times more per task than a model with a higher sticker price. That is why independent cost-per-task measurements exist, and why they routinely contradict what the price sheets suggest.

The cost-per-task table

Artificial Analysis reports what it costs to run one task of its index for each model, at standard prices, using token counts reported by each provider and live measurements of each model's typical cache hit rate - Artificial Analysis methodology. Here is how Hydrogen compares on version 5.0.1.

The Fable 5.2 figures come from its Artificial Analysis page - Artificial Analysis, as do Carbon's - Artificial Analysis, Sonnet 5.5's - Artificial Analysis, Terra's - Artificial Analysis, Haiku 5.5's - Artificial Analysis and Muse Ember's - Artificial Analysis. Hydrogen's per-task costs at high, medium and low are Artificial Analysis estimates as reported by VentureBeat - VentureBeat. Carbon's figure is at its current introductory price and will rise when that price doubles on December 1.

Paradox one: half the price, four times the cost

The first surprise in the table is Gemini 3.8 Flash. At $0.75 input and $3.75 output, it costs half as much per token as Hydrogen, yet it costs $7.77 per task at high reasoning against Hydrogen's $1.87, while scoring 31 against 51 and taking 14.9 minutes per task against 8.4. Per task, the cheaper model is four times more expensive and slower.

The mechanism is visible in the token counts. Artificial Analysis recorded 10.2 billion input tokens for 3.8 Flash to complete the index, and lists a 90% cache discount for it against Hydrogen's 95% - Artificial Analysis. A weaker model on a long agentic task takes more turns, fails and retries more often, and rereads its growing context every time. Each extra turn resends the whole conversation, so turns multiply input tokens, and at Flash's price input tokens are most of the bill. Google's claim that Hydrogen finishes tasks 2.5 times faster is, in cost terms, a claim that it needs fewer turns, and fewer turns is the largest single lever on agent cost.

Paradox two: on single answers, Hydrogen costs five times more

The second surprise points the other way. In Puter's single-turn test, Hydrogen cost about five times as much as 3.8 Flash for the same 48 answers, because it wrote a median of 400 output tokens per answer against 116 and used thinking on 42 of them - Puter. On a one-shot question there are no extra turns to save; the only effect of a smarter, more deliberate model is more tokens per answer at twice the price.

Both results are right, and together they produce the most useful rule in this guide: the shape of your workload decides which model is cheaper, not the price sheet. Multi-step agent loops reward the model that finishes in fewer turns, even at a higher token price. Single-turn, high-volume calls reward the model that answers in the fewest tokens at the lowest price. Most real systems contain both shapes, which is why the best answer is usually several models rather than one (sections 7 and 9).

Terra: the same score for half the money, at a cost in time

The third comparison is the one Google drew itself. GPT-6.1 Terra at its maximum setting scores 51, exactly Hydrogen's default score, for $0.96 per task, about half Hydrogen's $1.87. But it takes 14.1 minutes per task against Hydrogen's 8.4, waits 173 seconds before its first answer token against Hydrogen's 16.8, and generates around 71 tokens per second against Hydrogen's 169 - Artificial Analysis. Google's own chart shows Terra's cost curve sitting to the left of Hydrogen's at every level.

In the chart above, Terra's dark line reaches the low 50s for under one dollar per task, while Hydrogen's blue line needs almost two dollars at high and over three at xhigh. Sonnet 5.5's grey line costs far more than either for similar scores. The companion chart, plotting the same scores against minutes per task, reverses the order between Hydrogen and Terra:

Here Hydrogen's blue line reaches 51 at high in roughly six minutes on Google's measurement, while Terra needs about fourteen minutes for the same score and Sonnet 5.5 needs over thirty minutes for its top score. One Hacker News commenter summarized the pair of charts well: at high reasoning, Hydrogen is "smarter than Terra but somewhat more expensive" - Hacker News.

Hydrogen sells time, not tokens

Put the comparisons together and the model's economic identity becomes clear. Hydrogen is not the cheapest way to buy a given level of intelligence; Terra is, at the level around 50, and the small models are far cheaper below it. Hydrogen is the fastest way to buy intelligence around 50 at a moderate price. Whether that is a bargain depends on what an hour of agent time is worth in your system, and there are four common situations where it is worth a great deal.

The first is a human waiting: a support agent, a coding assistant in an editor, or anything interactive, where 173 seconds of silence before the first token is not a slower experience but a broken one. The second is paid wall-clock time: agents that run inside sandboxes, virtual machines or browser sessions billed by the minute, where a task that finishes in half the time costs half as much in infrastructure regardless of tokens. The third is throughput on a fixed fleet: if you run a set number of concurrent agent slots, faster tasks mean more tasks per slot per day. The fourth is chains of dependent steps: when one agent's output feeds the next, latency compounds across the chain.

If none of those apply (an overnight batch of document analysis, say), Terra's lower cost per task, or Hydrogen itself on Google's half-price Batch tier, is the better buy. If they do apply, Hydrogen's premium over Terra is the price of time, and it is often cheap.

6. The Input-Token Problem: Caching Decides Most of an Agent's Bill

The single most useful number on Hydrogen's Artificial Analysis page is not its score or its price. It is the ratio between the tokens it reads and the tokens it writes: to complete the index at xhigh, Hydrogen consumed 11.3 billion input tokens and generated 304 million output tokens, an output-to-input ratio of 2.693% - Artificial Analysis. An agent reads roughly 37 tokens for every token it writes.

That ratio flips the usual intuition about where an agent's money goes. People focus on output prices because output is five times more expensive per token, but at 37 input tokens per output token, input dominates. For every million output tokens Hydrogen writes, it reads about 37 million input tokens. At the list input price, those cost about $55.70, against $7.50 for the output. If all of that input were served from cache at $0.075 per million, it would cost about $2.78. The difference between an agent whose context is cached and one whose context is not is roughly a factor of six on the total bill, far larger than the difference between Hydrogen and most of its competitors.

Why agents read so much

The mechanism is simple once you see it. A language model has no memory between calls, so an agent resends its entire context on every turn: the system prompt, the tool definitions, the task, and the full history of every previous tool call and result. A 25-turn task with a context that grows from 15,000 to 85,000 tokens sends the early tokens 25 times. Total input grows roughly with the square of the number of turns, while output grows only linearly. This is also why the number of turns a model needs (section 5) matters so much: turns are multiplied against an ever-growing context.

A worked example: one coding subagent task

To make this concrete, consider an illustrative coding subagent task on Hydrogen at its default high setting. The assumptions are ours and are deliberately ordinary: the task runs 25 turns; it starts with 15,000 tokens of context (system prompt, tool declarations, task description and a repository map); each turn adds 2,900 tokens (the model's tool call plus the file contents or test output that come back); and each turn generates 1,200 output tokens, including thinking. Those assumptions produce 1.245 million input tokens and 30,000 output tokens, an output-to-input ratio of 2.41%, close to the 2.69% Artificial Analysis measured, which suggests the shape is realistic.

These are our calculations from Google's list prices; your token counts will differ, but the proportions hold for any agent loop with a growing context. With no caching, input is 89% of the bill. With full caching, the same task costs 79% less, and output becomes the larger half.

Implicit caching only: what that means in practice

On most providers you can mark a prefix of your prompt for caching and pay to keep it warm. Hydrogen removes that option: it "does not support explicit caching," and implicit caching "runs by default on prompts of at least 4,096 tokens," discounting cached input by 95% on cache hits - Google AI Studio docs. Implicit caching is free and automatic, but it only hits when the beginning of your request is byte-for-byte identical to a recent request, and you cannot force it.

That turns prompt layout into a cost decision. Put everything that never changes at the front: the system prompt, then the tool declarations in a fixed order, then stable reference material. Append new turns at the end and never rewrite earlier ones. Keep volatile content (timestamps, request IDs, per-user variables) out of the system prompt, because a single changed character near the start invalidates the cache for everything after it. And make sure the stable prefix is at least 4,096 tokens, since a prompt shorter than that is never cached at all; for a short system prompt, the counterintuitive fix is sometimes to move stable reference material into it.

Two API details help. With the Interactions API, passing previous_interaction_id lets Google manage conversation state for multi-turn and tool-calling sessions; and if you manage history yourself through GenerateContent, Google's guide says to return prior model turns and thought signatures unchanged - Google AI Studio docs. Both keep the prefix stable. Measure the result rather than assuming it: log cached-token counts from the usage metadata of every call and track your hit rate as a first-class metric. Our guide to prompt caching for agents covers prefix design across providers in detail.

7. Thinking Levels: Choosing Low, Medium, High or Xhigh

Hydrogen has four thinking levels, set per request with thinking_level: low, medium, high (the default) and a new xhigh. Google's guidance is specific. Low uses the fewest tokens and lowest latency for cost- and latency-sensitive work; medium suits interactive coding, live UI prototyping and responsive chat; high is the "recommended default for most tasks," including complex coding and agentic execution; and xhigh is for hard, multi-step problems, with the warning that it "increases latency and token use and can cause overthinking on simpler prompts" - Google AI Studio docs. Google recommends evaluating at all four levels and choosing the lowest one that meets your quality bar.

The independent data shows how steep the trade-off is.

Scores, timings and token counts are from Artificial Analysis - Artificial Analysis; per-task costs below xhigh are its estimates as reported by VentureBeat.

Reading the curve at the margin

The useful way to read this table is at the margin, step by step. Moving from low to medium adds 14 index points for $0.51 per task. Moving from medium to high adds 10 points for $1.07. Moving from high to xhigh adds only 3 points for $1.29, nearly doubles the time per task, and nearly triples the wait for the first answer token. On Artificial Analysis's Terminal-Bench 4.0 run specifically, xhigh added no gain over high while raising the suite's cost per task from $1.87 to $3.16 - VentureBeat.

Two conclusions follow. Xhigh is a specialist tool: worth it for a hard, high-value step where those three points mean the difference between success and failure, and wasteful as a default. And medium deserves far more use than it gets. At 41, Hydrogen on medium scores higher than Claude Haiku 5.5 or Muse Ember at their maximum settings, both of which score 36 - Artificial Analysis, and it finishes an index task in 3.8 minutes. It costs more per task than those two, but it is a genuine middle option between the small models and Hydrogen's default.

The migration trap: the default changed

Teams moving from 3.8 Flash need to know that the default moved. Hydrogen defaults to high thinking where 3.8 Flash defaulted to medium, and Google's migration checklist tells developers to move from medium to high as the default and test both - Google AI Studio docs. A team that swaps the model ID and nothing else gets both a smarter model and a more talkative one, which is precisely the effect Puter measured.

To see what the levels mean for a high-volume workload, take an illustrative support-style answer with 6,500 input tokens (5,000 of them a cached, stable prefix) and 400 output tokens at high, the median Puter observed, and scale the output at other levels by Artificial Analysis's measured token ratios. Per 100,000 answers, that comes to roughly $318 at low, $411 at medium, $562 at high and $1,092 at xhigh, by our calculation from Google's list prices. The level is a 3.4x cost dial on the same model and the same prompts.

A practical routing recipe

The principle is to set the thinking level per step type rather than per application. Classification, extraction and formatting steps, which need speed and little reasoning, belong on low. Conversational turns, quick edits and tool calls with obvious arguments belong on medium. Multi-file code changes, analysis, and any step where a wrong answer is expensive belong on high. Reserve xhigh for the few steps you can name in advance where high measurably fails: a final verification pass, a difficult debugging step, a plan that everything downstream depends on. Log the level with every call, alongside its tokens and outcome, so you can see where each level earns its cost.

8. Worked Examples: Three Agent Shapes and What They Cost

Abstract cost formulas only become useful when applied to concrete workloads. The three examples below cover the most common agent shapes. Their token assumptions are illustrative and labelled as such; the prices are Google's, Anthropic's and OpenAI's current list prices; and the cross-model comparisons assume identical token counts, which is a simplification, because different models need different numbers of turns and tokens for the same task (section 5). Treat them as a way to see where the money goes, not as a substitute for measuring your own workload.

Example A: a support answer, 100,000 times a month

The first shape is the single-turn answer: a support reply, a classification, a short drafting task. Assume each call sends 6,500 input tokens, of which a 5,000-token system prompt and knowledge snippet is a stable, cacheable prefix, and receives 400 output tokens.

These are our calculations from each vendor's list prices, using Anthropic's cache-read price for Haiku 5.5 - Anthropic. On this shape, Hydrogen is the wrong default. A small model costs a tenth as much or less, and the per-answer gap between Hydrogen and Haiku 5.5 is about $5.20 per thousand answers. The question to ask is whether Hydrogen's better accuracy prevents more than $5.20 of downstream cost (a human escalation, a refund, a lost customer) per thousand answers. For many support flows it does not; for some, such as answers that commit the company to something, it easily does. Our comparison of Muse Ember, Claude Haiku 5.5 and GPT-6 Luna covers the small-model end of this decision in depth.

Example B: a coding subagent, 2,000 tasks a month

The second shape is the multi-turn agent loop, which section 6 worked through in detail: a 25-turn coding subagent task costs about $0.44 on Hydrogen at high thinking with good caching and about $2.09 with none. At 2,000 tasks a month, that is the difference between roughly $880 and $4,180 for the same work on the same model, decided entirely by prompt layout.

On identical token counts with full caching, the same task would cost about $0.29 on GPT-6.1 Terra, $0.59 on Claude Sonnet 5.5 and $1.17 on Gemini 4 Carbon at its December price, by our calculation. But identical token counts are exactly the wrong assumption for this shape, because it is the shape where models differ most in how many turns they take. The better evidence for multi-turn work is Artificial Analysis's measured cost per task. Applied to 2,000 index-sized tasks a month, it implies about $3,740 on Hydrogen at high, $1,920 on Terra at max, $10,960 on Carbon at its current price, $20,040 on Sonnet 5.5 at max and $53,080 on Claude Fable 5.2 at max, by our arithmetic from the figures in section 5. The eesel review ran the same kind of calculation and reached a similar conclusion about Hydrogen against Carbon - eesel.

There is a further lever for this shape: if the tasks can wait, Batch or Flex halves every figure. A coding agent that runs overnight on a queue of maintenance tasks has no reason to pay the standard rate.

Example C: a research agent with search grounding

The third shape is the research agent: it searches, reads results, and synthesizes a cited answer. Assume 12 turns, a context that starts at 8,000 tokens and grows by 4,000 tokens of search results per turn, 900 output tokens per turn, an 80% cache hit rate, and 20 search queries per task. On Hydrogen at high, the tokens cost about $0.27 per task by our calculation.

The search fees cost about the same again. Past the 5,000 free monthly requests, each query costs $0.014, so 20 queries add $0.28 per task. At 2,000 tasks a month that is 40,000 queries, of which 35,000 are billable: $490 a month in search fees against about $540 in tokens. There is also a ceiling to plan around: Google caps grounding at 1,500 requests per day, which at 20 queries per task limits a single project to about 75 grounded tasks a day - Google AI Studio. A research agent at real volume either needs a separate search provider, fewer and better-targeted queries, or several projects. This is the shape where the cheapest optimization is often not the model but the query count: an agent that plans its searches before running them, rather than searching reactively at every turn, can cut fees in half without touching quality.

What the three examples teach together

Across the three shapes, the most expensive mistake is different each time. For single answers it is using a model that is too big. For agent loops it is uncached context and too many turns. For research agents it is unplanned tool calls. Only in the second case is Hydrogen's price the main variable, and even there, caching moves the bill more than the model choice does.

9. Orchestration: Hydrogen as the Worker Under a Frontier Planner

The way Google itself showcases Hydrogen for serious agent work is not alone but underneath a frontier model, doing the execution while the bigger model plans. Google built that pattern into its products on launch day.

How Antigravity's Orchestrator splits the work

Google Antigravity added a new model option called Orchestrator, which pairs Hydrogen with a stronger model such as Gemini 4 Carbon within a single task. Carbon starts in a read-only phase to explore dependencies, resolve ambiguities and build a plan with explicit re-planning triggers; Hydrogen then writes the edits, updates packages and runs the tests; and if Hydrogen hits friction, it hands back to Carbon to inspect the state, repair the plan and resume. On Terminal-Bench 4.1, Orchestrator reached near-Carbon task success while consuming 24% less quota and finishing 19% faster on average - Google Antigravity. Google AI Ultra subscribers get Orchestrator with Carbon or Argon as the planner, AI Pro subscribers get it with Argon, and both are available through Gemini for business.

Google's 88-second official video introduces Hydrogen inside Antigravity, the environment where Orchestrator runs:

The same post describes a developer version of the pattern through the Antigravity SDK: an open-source issue triage system where Hydrogen agents handle triage, coding, codebase search, clarifying questions and UI iteration, while Carbon handles larger refactors, new features and security checks. Google's developer guide states the principle in one line: route planning turns to Carbon and execution turns to Hydrogen when you need both - Google AI Studio docs.

Why the split saves money, from first principles

The economics of orchestration follow from where tokens concentrate. Planning is a small number of high-stakes decisions: read the situation, decide what to do, decide when to re-plan. Execution is a large number of routine operations: open this file, apply that edit, run the tests, read the output. Section 6 showed that agent cost is dominated by the volume of tokens read and written in loops, and that volume lives overwhelmingly in execution. So the rational architecture puts the expensive model where the decisions are and the cheaper model where the tokens are.

The size of the saving depends on the price gap, which is about to grow. From December 1, Carbon costs $4 input and $20 output against Hydrogen's $1.50 and $7.50, so every token moved from planner to worker costs 62.5% less. Google's measured 24% quota saving is smaller than that because the planner still does real work and hand-backs cost tokens, but it comes with near-frontier success and a 19% speed gain, which is an unusually good trade. Our analysis of when subagents pay off covers the conditions under which splitting work across models helps and when the coordination overhead eats the saving.

Decision models: the cheapest tier in the stack

The routing step in that diagram has its own new category of model. One day before Hydrogen, Google launched the Gemini Decisions API, powered by Gemini Decision 1, which scores a closed set of options in a single forward pass instead of generating text. It accepts up to 256K tokens of mixed input and up to 1,000 independent questions per request, answers in 150 to 250 milliseconds end to end, and costs $0.10 per million input tokens with no charge for output - Google. Google names tool selection, policy checks, model routing and context grading as its uses, and says the Gemini Notebook product uses it to route queries to a model tier and thinking level, with up to 40% lower latency for everyday queries.

OpenAI got there first: its Decisions API left beta on October 22, 2026, at $0.10 per million input tokens, $0.01 cached, with no output-token charges - OpenAI Developer Community. For a Hydrogen-based system, a decision model is the natural way to choose the thinking level per request automatically, which section 7 showed is a 3.4x cost dial. Spending a fraction of a cent to decide whether a request needs low or high thinking is one of the highest-return investments in an agent stack. Our comparison of decision models including OpenAI's Decisions API and our guide to model routing for agents cover the routing layer in more depth.

10. Hydrogen Against the Alternatives

No model is the right choice for every agent, so the useful question is which model wins for which job. The table below scores nine options on the four things that decide an agent model choice, using the same evidence for every row. Each model is scored at the setting Artificial Analysis measured, and Hydrogen appears twice because its medium and high settings behave like different products.

The weights reflect a first-principles view of agent economics. Capability carries 30% and agent fit 25%, together a majority, because an agent that fails a task costs a rerun plus a human's time, which dwarfs its token bill. Cost per task carries 25% and speed 20%. Capability is the Artificial Analysis index divided by 6.5, so the top score of 65 maps to 10. Cost and speed are scored on a logarithmic scale, because each halving of cost or time matters equally: cost is 10 minus 1.5 times the number of doublings above $0.15 per task, and speed is 10 minus 1.6 times the number of doublings above 4 minutes per task, both kept between 1 and 10. Agent fit is our judgment from the agentic benchmark evidence in the cell.

The index scores, costs and times are from each model's Artificial Analysis page, cited in section 5. The agentic benchmark figures are from Google's model card and announcement (sections 3 and 4), from Artificial Analysis's Terminal-Bench 4.0 run as reported by VentureBeat and DataCamp, and from Puter's fabrication test. Fable 5.2's cache discount is from its Artificial Analysis page - Artificial Analysis.

What the ranking says, and what it does not

The top row will surprise anyone expecting a Hydrogen review to crown Hydrogen. Muse Ember wins on this weighting because it is the fastest and cheapest model on the board by a wide margin, and for the large share of agent steps that do not need more than its capability, that is the right answer. But the ranking hides a threshold: Ember's capability score of 36 is a ceiling, and for any task that needs more, it drops out entirely. A linear capability scale understates how much harder tasks get as scores rise, so read the table as "best value for steps that fit each model," not as a single winner.

Within that frame, Hydrogen's two rows are the most interesting. Hydrogen on medium is the best-value option for steps that need more than the small models can do, because it combines a 41 score with Ember-like speed. Hydrogen on high narrowly edges Terra on this weighting because the weighting values speed; for latency-insensitive batch work, Terra's lower cost per task wins. Carbon, Fable 5.2 and Sonnet 5.5 score lower overall because they are expensive and slow, but each is the right choice for a specific job: Carbon and Fable for the hardest planning and reasoning, Sonnet 5.5 for terminal and computer-use execution where it leads Google's own table. Gemini 3.8 Flash comes last, which is the clearest single argument for migrating off it.

The alternatives, one by one

GPT-6.1 Terra is Hydrogen's closest rival and the better choice when time does not matter. It matches Hydrogen's default score for half the cost per task and has the cheapest cache reads of any model here. Its weakness is speed: at max settings it waits nearly three minutes before its first answer token, which rules it out for interactive work.

Claude Sonnet 5.5 leads Google's own table on Terminal-Bench 4.1, OSWorld-2.1 and Terminal-Bench-Science, which makes it the stronger model for agents that operate shells, desktops and scientific tooling. It costs about five times as much per task as Hydrogen at high and takes four times as long, so it belongs on the execution-heavy steps where its lead matters, not on everything.

Claude Fable 5.2, released on November 9, is the most capable model measured, scoring 65 on the index; Anthropic prices it at $8 input and $40 output, with a fast mode at $16 and $80, and released the companion Claude Mythos 5.2 only to vetted organizations working in dual-use areas - Anthropic. At $26.54 per index task, it is a planner and a last resort, not a workhorse. Our Claude Fable 5.2 cost analysis works through when it earns that price.

Gemini 4 Carbon and Argon are Google's frontier tier, and the obvious planners above Hydrogen. Their December 1 price doubling makes the planner-worker split more valuable, not less. Our comparison of Gemini 4 Argon and Claude Opus 5.5 per agent task covers the frontier end of Google's lineup.

Claude Haiku 5.5, GPT-6 Luna and Muse Ember are the volume tier, about 15 times cheaper per token than Hydrogen. For classification, extraction, routing and short replies they are the right default, and Hydrogen should only see the traffic they cannot handle.

Open-weight models are where most raw agent volume actually runs. On OpenRouter's weekly usage rankings through November 14, DeepSeek V4.1 Flash 1017 led with 58 trillion tokens and low-cost models filled most of the top ten, with GPT-6 Luna at 7.68 trillion and Claude Opus 5.5 at 6.98 trillion further down, while Hydrogen, three days old, did not yet appear in the usage tables - OpenRouter. Moonshot's Kimi K3.1 Pro reaches 46 on the index at $3.68 per task through multiple hosts - VentureBeat. Self-hosting adds hardware and operations costs that per-task figures do not show.

There is also the option of not choosing models at all. Coding tools increasingly expose several of these models side by side; Cursor's model list already includes Gemini 4 Hydrogen, Argon and Carbon alongside Claude Fable 5.2 - Cursor. And platforms such as o-mega, which build and run a whole company's software (website, app, billing, content and admin) through one conversation, take the model decision away from the user entirely; that trades control over each routing choice for not having to make it. For a broader monthly ranking across every lab, see our best LLM for AI agents ranking for November 2026.

11. Where Hydrogen Fails: Limitations and Failure Modes

Every model fails somewhere, and the ways Hydrogen fails are specific enough to plan around. Most of them come from Google's own documentation, which is unusually candid this time.

More refusals, especially on images

Google's model card reports that unjustified refusals, measured as over-refusals on benign or borderline prompts that could safely be answered, rose by 5.57 percentage points against Gemini 3.8 Flash, "particularly for multimodal prompts," while refusal tone was similar - Google model card. Google adds that manual review found the losses were overwhelmingly false positives or not egregious, but an agent that refuses a legitimate step simply stops working. If your agent processes images (insurance claims, medical paperwork, product photos, identity documents), test refusal rates on your real inputs before migrating, and build a retry path that rephrases or escalates.

Overreach: Google's claim against developer experience

Google claims Hydrogen reduces overreach in agentic tasks by up to 81%, under-service by up to 79%, and misaligned actions and task shortcutting twelvefold - Google. An early Hacker News report pushed back hard, describing initial results with Hydrogen and Carbon as disappointing because of overreach (doing more than asked), overwork (continuing when it should fail fast) and orthogonal work at the 90th and 99th percentile of runs - Hacker News. Both can be true: a large average improvement can coexist with bad tail behavior. The practical defenses are the same either way: give the agent narrowly scoped tools and permissions, require confirmation for destructive actions, set explicit stop conditions, and review a sample of full trajectories rather than only final outputs.

Verbosity and latency at the top setting

At xhigh, Hydrogen ranks 78th of 79 models on verbosity and waits 46.6 seconds on average before its first answer token - Artificial Analysis. Google's docs warn that xhigh "can cause overthinking on simpler prompts." Never set xhigh as an application default, and never use it on a path where a user is waiting.

API constraints that break existing code

Several API changes will break code written for earlier Gemini models. Hydrogen rejects the minimal thinking setting with an error; it ignores in-range temperature, top_p and top_k values and returns a 400 error for out-of-range ones; it does not support explicit caching, so cached_content fields must be removed; and prompting it to emit custom raw-text JSON tool calls with no declared tools can return MALFORMED_FUNCTION_CALL, so tools should be declared natively - Google AI Studio docs. The loss of sampling controls deserves a moment's thought: teams that relied on temperature zero for repeatable outputs in tests or evaluations no longer have that lever, and should build their evaluation harnesses to tolerate variation.

Output limits per request

Synchronous requests return at most 65,536 output tokens per hop, and the max_output_tokens value caps thinking and answer together, so a low cap can starve the answer after a long think. Longer outputs need background execution or client-side continuation, and a background request with no max_output_tokens set stops at 65,536 tokens anyway. Teams migrating from 3.8 Flash should remove hardcoded low output caps or raise them.

Safety documentation still pending

The full Safety and Security Report for Hydrogen was listed as "coming soon" at launch. The model card states that Hydrogen did not show a material capability increase over Gemini 4 Argon, and that targeted testing found it does not reach Google's critical capability levels for biological or cyber risk, though "it reaches the CCL alert thresholds for both domains" - Google model card. For most business agents this changes nothing operationally, but teams in regulated sectors that need the full report for a vendor risk review should expect to wait for it.

Knowledge cutoff and fabrication

Hydrogen's knowledge ends in March 2026, eight months before its release, and the model card notes that knowledge may be less current in some domains. Fabrication is reduced, not gone: even in Puter's test, Hydrogen once stated a nonexistent npm flag as fact. Any agent that cites versions, flags, prices or regulations should ground those facts with a tool call rather than trusting the model's memory.

Naming and plan confusion

The last failure mode is organizational rather than technical. The element names confuse developers, and consumer plan access differs by model and surface: one Hacker News commenter complained that Argon is very limited on the Pro subscription and Carbon is available only on Ultra - Hacker News. Inside a company, write down which model ID each workflow uses and why, so that a future migration is a decision rather than an accident.

12. Migration Playbook: From Gemini 3.8 Flash, Carbon or Argon

Migrating to Hydrogen is mostly mechanical, but the mechanical steps hide cost decisions. Google's own checklist for teams coming from 3.8 Flash has six parts: change the model ID from gemini-3.8-flash to gemini-4-hydrogen; remove hardcoded low max_output_tokens caps or raise them to 65,536; move from medium to high as the default thinking level and test both; remove explicit caching; remove sampling parameters; and account for the shared 1M-token window replacing separate input and output budgets - Google AI Studio docs.

Setting the thinking level explicitly is the most important line in the migration, because it is the line that controls cost. This is Google's own example, using the Interactions API through the google-genai Python SDK:

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-4-hydrogen",
    input="Audit this payment retry queue for race conditions and rewrite the lock acquisition logic.",
    generation_config={
        "thinking_level": "xhigh"
    }
)

print(interaction.output_text)

Google's example uses xhigh because the task is a hard audit; for most production calls you would set low, medium or high per step, as section 7 describes, rather than relying on the default.

The steps that save money, not just the steps that compile

Beyond Google's checklist, four changes determine whether the migration lowers or raises your bill. First, restructure prompts for implicit caching: since explicit caching is gone, make sure every agent's stable prefix is at least 4,096 tokens, identical across calls, and free of volatile content (section 6). Second, set thinking per call site, starting from medium for anything conversational and high for multi-step work, instead of inheriting the new high default everywhere. Third, use Batch or Flex for asynchronous work at half price. Fourth, audit search grounding: count queries per task and set a budget, because search fees can match token costs.

For teams coming from Carbon or Argon, the request schema does not change. Hydrogen defaults to high and supports xhigh, while Carbon and Argon default to medium and cap at high, and non-streaming requests allow 65,536 output tokens against 32,768 on the larger models. The main question in that direction is which workloads Hydrogen can absorb from the frontier models before their price doubles on December 1, which is a strong reason to run that evaluation in the next two weeks.

Timing: what to move now and what can wait

The pricing clocks in section 2 make the timing logic straightforward. Multi-step agent loops should move now: on Artificial Analysis's measurements Hydrogen already costs a quarter of what 3.8 Flash costs per agentic task, so waiting only wastes money. High-volume single-turn calls currently on 3.8 Flash can stay on it until late December if they are cheaper there, which Puter's test suggests they are, but they should move to a small model or Flash-Lite rather than to Hydrogen if the small model's quality is sufficient, because on January 1 3.8 Flash's price advantage disappears. Workloads on Carbon or Argon that do not need frontier capability should be tested on Hydrogen before December 1. And anything still pinned to a Gemini 2.5 model ID should be found before December 1, when it is silently rerouted.

Whatever moves, migrate with measurement rather than faith. Run the new model in shadow on a sample of real traffic, log tokens, cached tokens, thinking level, latency and task success for both models, and compare cost per successful task rather than cost per call. Google even ships a coding-agent shortcut for the mechanical part, a /gemini-api-dev migrate my app to Gemini 4 Hydrogen command - Google AI Studio docs, but the cost decisions above are yours to make. If you lack visibility into what your agents spend per task today, an observability layer is the prerequisite; our comparison of AI agent observability tools covers the options.

13. The Bigger Picture: What Hydrogen Says About Agent Economics

Step back from the spec sheet and Hydrogen's launch reveals how the economics of AI agents are restructuring at the end of 2026. Three forces are visible in this one release, and each has consequences for anyone building on these models.

The frontier gets more expensive while the workhorse gets smarter

The first force is a widening spread between tiers. At the top, prices are rising: Google's frontier models double on December 1, and Anthropic's newest flagship, Fable 5.2, costs $8 input and $40 output per million tokens. In the middle, capability is rising at stable prices: Hydrogen matches last month's Google frontier model on the leading independent index at well under half the December frontier price.

From first principles, this is what you would expect from labs that have to recover enormous training and infrastructure costs. The frontier model is where a lab has no close substitute for a few weeks, so it can charge for it; the workhorse tier is where every lab competes, so prices there are set by competition and capability rises instead. Anthropic's IPO filing makes the capital requirement concrete: its roadshow, launched November 10, offers 825 million shares at an expected $70 to $78 each on the Nasdaq under the ticker ANT - Anthropic, with CNBC reporting that the company plans to begin trading on November 19 and could be worth up to $1.405 trillion on a fully diluted basis - CNBC. Investors at that valuation expect frontier pricing power. Our guide to Anthropic's IPO covers the financials.

The consequence for builders is that orchestration becomes the default architecture, not an optimization. When the gap between a frontier planner and a workhorse executor is 2.7x per token, and growing, running everything on the frontier model is a choice to overpay, and running everything on the workhorse is a choice to fail the hardest steps. The winning systems will route.

Google uses the workhorse tier for distribution

The second force is specific to Google. Hydrogen launched to everyone at once: free API tier, Gemini app, and Search for all users globally. Putting a new model into a search engine on launch day is a distribution channel no other model lab has, and Google is using its workhorse model, not its frontier model, to do it. The structural logic is that the workhorse is the model Google can afford to serve at Search scale, so it is the model through which most people will form their impression of Gemini 4. For developers this has a useful side effect: a model that serves Google Search is a model Google has every incentive to keep fast, cheap to run and available.

A new tier at the bottom, and a governance layer around it all

The third force is the emergence of layers around the models themselves. At the bottom, decision models from Google and OpenAI now handle routing and closed-set choices for a tenth of a dollar per million input tokens and nothing for output, which turns the routing logic of section 9 into a commodity. Around the whole stack, a governance layer is consolidating fast. Microsoft's Agent 365, which has cost $15 per user per month since it became generally available in May, licenses each person who manages or sponsors agents - Microsoft, and features in two flagship sessions at Microsoft Ignite, including the opening keynote, which calls it "the observability layer for agents, models and assistants" - Microsoft Tech Community. IBM and Microsoft announced Imagine Enterprise on November 10, an agentic platform with a fleet of more than 6,000 AI agents and assets - Microsoft, and CrowdStrike agreed on November 3 to acquire Fiddler AI to deliver agent observability - CrowdStrike.

For a cost analysis, the governance layer matters because it is a cost that does not appear on any model price sheet. An enterprise agent's true cost now includes tokens, tool fees, infrastructure time, governance licenses per person, and the human review the governance tools are there to support. The model is becoming the cheapest part of a well-run agent deployment, which is precisely why model choice should be made on cost per successful task rather than per-token price.

Model access is also a business relationship

One more lesson from the same week: which models you can use in a given tool depends on deals you do not control. OpenAI announced in August that it intended to pull its models from Cursor on November 12, 2026, after SpaceX acquired the coding tool - Engadget. As of this writing Cursor's model list still shows OpenAI's GPT-5.6 models next to Gemini 4 Hydrogen and Claude Fable 5.2 - Cursor. Building your agent stack so that a model is a configuration value, behind your own routing layer, is cheap insurance against both price changes and access changes.

What to watch next

Several things will change the picture in the coming weeks. Google's full safety report for Hydrogen is still pending. The December 1 frontier price change and the January 1 Flash price change will shift the cost-per-task table. Independent agentic evaluations beyond Artificial Analysis will show whether the tail-risk complaints about overreach hold up at scale. Explicit caching, if Google adds it to Hydrogen, would make its costs far more predictable. And OpenRouter's usage tables will show within weeks whether developers actually route volume to Hydrogen or keep it on cheaper small models. Our broader analysis of the true cost of LLM inference in 2026 tracks how these forces move prices over time.

14. How to Decide: A Practical Checklist

Gemini 4 Hydrogen is a genuinely strong model at a deliberately middle price: smarter than every small model, faster than anything at its capability level, and cheaper per task than the frontier. It is not the cheapest way to buy intelligence around 50 on the index (GPT-6.1 Terra is), and it is a poor default for single-turn, high-volume work (the small models are). Its sweet spot is multi-step agent work where time matters, as the execution layer under a frontier planner, and on medium thinking as a step up from the small models.

The decision for your own system comes down to measurement, and the steps are the same whatever you are building:

1. Classify your agent steps by shape: single-turn answers, multi-step loops, and tool-heavy research. Each shape has a different cheapest model.
2. Measure cost per successful task, not per call: log input, cached input and output tokens, tool calls, latency and outcome for every step.
3. Fix caching before switching models: in our 25-turn example, a fully cached stable prefix of at least 4,096 tokens cut the task's cost by 79%, more than any model swap would.
4. Set the thinking level per step, starting from medium for conversational work and high for multi-step work; reserve xhigh for named hard steps.
5. Put small models on simple steps and send Hydrogen only the traffic they cannot handle, ideally chosen by a decision model.
6. Add a frontier planner where planning is hard, with Hydrogen executing, and test it before Carbon and Argon double in price on December 1.
7. Batch waiting work on the Batch or Flex tier at half price.
8. Budget tool fees separately, especially search grounding at $14 per 1,000 queries and its 1,500-per-day cap.
9. Leave Gemini 3.8 Flash before January 1 and leave Gemini 2.5 model IDs before December 1.
10. Keep models swappable behind your own routing layer, because prices and access will keep changing.

The underlying lesson outlasts this model. In agent systems, intelligence is becoming a commodity input whose price varies by an order of magnitude between tiers, while the real cost is set by how efficiently a system spends it: how few turns it takes, how much context it reuses, how much thinking each step genuinely needs, and which model is doing which job. Gemini 4 Hydrogen is a very good tool for the middle of that system. The advantage goes to the teams that measure what each step costs and put each model where it earns its price.

What this article rests on

Every model figure above is read from its record, re-read from OpenRouter's model feed every 6 hours, so the figures on this page are current even where the prose around them is older. Prices are OpenRouter's listed price per million tokens: for a lab's closed models that is the lab's own list price, and for an open-weight model it is the price of the host OpenRouter routes to by default, which can differ from the lab's own API and from other hosts.

• Gemini 4 Hydrogen (Google): $1.50 in and $7.50 out per million tokens, cached input $0.075, a 1M token window, listed 12 November 2026.
• Claude Haiku 5.5 (Anthropic): $0.10 in and $0.50 out per million tokens, cached input $0.01, a 1M token window, listed 7 October 2026.
• Gemini 4 Carbon (Google): $2 in and $10 out per million tokens, cached input $0.10, a 1M token window, listed 10 November 2026.
• GPT-6 Luna (OpenAI): $0.10 in and $0.50 out per million tokens, cached input $0.01, a 1.05M token window, listed 22 September 2026.
• Muse Ember (Meta): $0.10 in and $0.50 out per million tokens, cached input $0.004, a 1M token window, listed 9 November 2026.
• Gemini 3.5 Flash Lite (Google): $0.30 in and $2.50 out per million tokens, cached input $0.03, a 1M token window, listed 21 July 2026.
• Claude Sonnet 5.5 (Anthropic): $2 in and $10 out per million tokens, cached input $0.10, a 1M token window, listed 28 September 2026.
• GPT-6.1 Terra (OpenAI): $1 in and $5 out per million tokens, cached input $0.05, a 1.05M token window, listed 26 October 2026.
• Claude Fable 5.2 (Anthropic): $8 in and $40 out per million tokens, cached input $0.20, a 1M token window, listed 9 November 2026.

In this topic: AI models

• Gemini 4 Carbon vs Argon vs Hydrogen: Which to Use (2026)
• Best LLM for AI Agents: 20 Models Ranked (November 2026)
• Kimi K3.1 Pro: Benchmarks, Real Cost and Open Weights 2026
• Gemini 4 Argon vs Opus 5.5: Real Cost per Agent Task (2026)
• Muse Spark Open: Benchmarks, License, How to Run (2026)
• Gemini 4 Argon: Benchmarks, Real Cost and Access (2026)
• Meta Muse Wonder: Benchmarks, Pricing and Access (2026)
• GPT-6 Sol vs Astra vs Luna: Which Model to Use (2026)

Which AI model should your agents run on? Every guide on it