Gemini 4 Hydrogen for Coding Agents: Cost, Setup, Verdict

Google retired the Flash name and gave its fast tier an element instead: Gemini 4 Hydrogen, launched November 12, 2026, aimed squarely at coding agents. The headline numbers are simple - $1.50 in, $7.50 out, a 1M-token window, four thinking levels - but the number that decides whether your agent makes money is none of those. It is the cost of one finished run, thinking tokens included. I went through the official pricing page, the model card and the migration guide, and I wrote the agent code against the real SDK. Here is what Hydrogen costs in practice, how you wire it up, where the launch claims need salt, and the traps waiting in a Flash migration.

One disclosure before anything else, because this blog does not fake hands-on: I do not have a Gemini API key in my environment right now, so I could not run Hydrogen end to end. The code in this post is written against @google/genai 3.3.0 and typechecked clean against the SDK's own types, and every price and capability below comes from Google's documentation, checked today. What I will not do is invent benchmark results and attribute them to a test I never ran. Google's and Artificial Analysis's numbers are labeled as theirs wherever they appear.

The short version: the fast tier grew up

Hydrogen is the model Google wants doing the daily work of agents: writing and editing code, calling tools, running tests, answering questions about a codebase, and fanning out as parallel subagents. It replaces Gemini 3.8 Flash in that role, and 3.8 Flash stays available as the older, temporarily cheaper option.

Three facts shape everything else in this post:

• The price is flat. $1.50 per 1M input and $7.50 per 1M output tokens across the entire context window - no long-context surcharge tier like older Pro models had.
• Thinking is a priced dial. Four levels (low, medium, high by default, and a new xhigh), and thinking tokens bill at the output rate. The level you choose is a budget decision, not just a quality one.
• The window is unified. Input, thinking and output share one 1,048,576-token budget. A giant context literally leaves less room for the answer.

If your agents are step-shaped - many small edits, tool calls, test runs and retries - this is the tier built for them, and the rest of this post is the working detail. If your workload is one long chain of hard reasoning, skip to the verdict: you are probably an orchestration customer, not a Hydrogen-only one.

Gemini 4 Hydrogen specs: what you are actually buying

The full picture from the model page, so the rest of the post has a reference point:

Two rows deserve a second look. The 65,536 output cap per synchronous request is the one your agent will actually hit: a long refactor or a big generated file needs background execution to go further, which is an architecture decision, not a parameter tweak. And "implicit caching only" is a genuine removal - Gemini 4 dropped explicit context caching entirely, which becomes migration trap number one below.

The element naming is worth one sentence because it confuses everyone for a week: Hydrogen is the fast execution model, Argon is the efficient frontier reasoner, Carbon is the strongest frontier model. Google's own guidance is to pick by reasoning depth, latency and cost target - and, pointedly, to pair them.

The price that matters is cost per run, not cost per token

A token price tells you almost nothing about an agent bill. An agent run is a loop: the context goes in again on every turn, tool results pile up, and the model thinks before it acts. What you pay for is input tokens (context, history, tool results) plus output tokens (thinking plus the visible answer) multiplied by the number of runs you actually serve.

Here is the arithmetic, live. Set the shape of one of your runs and read the bill:

On zainvibes.com this section is interactive: a cost calculator - set the shape of one of your runs (turns, context, cached share, thinking level) and read the real bill per run and per month. Try it on the original post.

Three things the calculator cannot show you, which matter as much as the sliders:

Thinking level is the hidden multiplier. Google prices thinking at the output rate, and in Artificial Analysis's testing, Hydrogen at xhigh used close to double the output tokens of the default high level, for 3 extra Intelligence Index points (54 vs 51). On a run that outputs 8,000 tokens at high, xhigh is not a quality upgrade - it is roughly a second output bill. Google's own advice is the right discipline: evaluate all four levels and pick the lowest one that clears your quality bar.

The cost-per-task comparison cuts in Hydrogen's favor - on Google's cited numbers. Artificial Analysis measured a weighted average cost of $3.16 per Intelligence Index task for Hydrogen against $7.77 for 3.8 Flash, because a model that finishes in fewer turns spends fewer total tokens even at a higher rate. That is an independent lab's measurement, not mine, and your tasks are not their tasks - but the direction is the one that matters: per-token price comparisons systematically underrate models that end loops early.

Caching is where long-context agents win or bleed. A coding agent resends its system prompt, tool definitions and repo context on every turn. Implicit caching discounts repeat input by 95% (to $0.075 per 1M) on prompts of at least 4,096 tokens, automatically. In the calculator, drag the cached share up and watch the monthly number: at agent scale, cache hit rate is a bigger lever than the tier you pick.

Setting up Gemini 4 Hydrogen: one call, then a real agent loop

Start with the smallest honest thing - one call, with the thinking level set on purpose:

import { GoogleGenAI } from "@google/genai";

const client = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

const interaction = await 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" },
});

console.log(interaction.output_text);

That is Google's documented quickstart shape on the Interactions API. The agent version is the same call inside a tool loop. This is the module I wrote and typechecked for this post - two tools, a turn limit, and previous_interaction_id carrying the conversation (and the thought signatures you must not rebuild by hand) between turns:

import { execFile } from "node:child_process";
import { readFile } from "node:fs/promises";
import { promisify } from "node:util";
import { GoogleGenAI } from "@google/genai";

const execFileAsync = promisify(execFile);
const client = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

type ThinkingLevel = "low" | "medium" | "high" | "xhigh";

const tools = [
  {
    type: "function" as const,
    name: "read_file",
    description: "Read a UTF-8 text file from the project and return its contents.",
    parameters: {
      type: "object",
      properties: { path: { type: "string", description: "Project-relative file path" } },
      required: ["path"],
    },
  },
  {
    type: "function" as const,
    name: "run_tests",
    description: "Run the project test suite and return combined stdout/stderr.",
    parameters: { type: "object", properties: {} },
  },
];

async function runTool(name: string, args: Record<string, unknown>): Promise<string> {
  if (name === "read_file") return readFile(String(args.path), "utf8");
  if (name === "run_tests") {
    try {
      const { stdout, stderr } = await execFileAsync("npm", ["test"], { timeout: 120_000 });
      return stdout + stderr;
    } catch (err) {
      // A failing test run is information for the agent, not a crash.
      const e = err as { stdout?: string; stderr?: string };
      return (e.stdout ?? "") + (e.stderr ?? "");
    }
  }
  throw new Error(`Unknown tool: ${name}`);
}

export async function runCodingAgent(
  task: string,
  thinkingLevel: ThinkingLevel = "high",
  maxTurns = 8,
): Promise<string> {
  let interaction = await client.interactions.create({
    model: "gemini-4-hydrogen",
    input: task,
    tools,
    generation_config: { thinking_level: thinkingLevel },
  });

  for (let turn = 0; turn < maxTurns; turn++) {
    const calls = (interaction.steps ?? []).filter((step) => step.type === "function_call");
    if (calls.length === 0) return interaction.output_text ?? "";

    const results = [];
    for (const call of calls) {
      if (call.type !== "function_call") continue;
      let result: string;
      let isError = false;
      try {
        result = await runTool(call.name, call.arguments ?? {});
      } catch (err) {
        result = err instanceof Error ? err.message : String(err);
        isError = true;
      }
      results.push({
        type: "function_result" as const,
        call_id: call.id,
        name: call.name,
        result,
        is_error: isError,
      });
    }

    interaction = await client.interactions.create({
      model: "gemini-4-hydrogen",
      previous_interaction_id: interaction.id,
      input: results,
      tools,
      generation_config: { thinking_level: thinkingLevel },
    });
  }

  return interaction.output_text ?? "";
}

Three details in that code are load-bearing, and all three come from Google's migration notes rather than my taste. Tools are declared natively - prompt-invented JSON tool calls can come back as MALFORMED_FUNCTION_CALL. A failed tool call returns its output as a result with is_error, because Hydrogen is specifically tuned to adapt when tools fail instead of stalling. And the loop caps turns: an agent without a turn limit on a metered model is a billing incident with extra steps. If you use the Vercel AI SDK or AI Gateway instead, the model slug is google/gemini-4-hydrogen; the same thinking-level discipline applies wherever you set it.

Four thinking levels: a budget dial, not a quality dial

Google's guidance table, condensed:

My working rule for agent fleets: set the level per step type, not per app. Routing, classification and mechanical edits run at low or medium. The default workhorse steps run at high. xhigh is a targeted escalation for the step that failed at high - and Google explicitly warns it can overthink simple prompts, spending tokens to arrive slower at the same answer. The migration consequence is real too: 3.8 Flash defaulted to medium, Hydrogen defaults to high, so an unexamined model-string swap quietly raises both quality and cost on every call.

Where the launch claims need salt

Google's launch post makes three performance claims worth separating from the verified facts:

• "2.5x faster than 3.8 Flash" - Google's claim, at the default high setting. Plausible for the tier's purpose, unproven on your workload. Speed claims in this industry are measured on the vendor's happiest benchmark.
• Intelligence Index 51 at high, 54 at xhigh, versus Argon's 50 - this one is Artificial Analysis's index, cited by Google. It is the most interesting number in the launch: the fast tier edges the efficient frontier model on a composite index. It is also a composite - your coding tasks may not track it.
• The Orchestrator numbers - Carbon planning with Hydrogen executing reached near-Carbon success on Terminal-Bench with 24% less quota and 19% faster completion. Google-reported, exact gap unspecified ("near" is doing real work in that sentence). Treat it as a hypothesis worth testing on your own eval set, because if it holds even halfway, it reprices frontier-model agents.

What is not a claim: Google says Hydrogen cuts fabricated claims by more than 5x versus 3.8 Flash by flagging missing context instead of guessing, and batches read and search tool calls in parallel. Both are behaviors you can verify cheaply on your own tasks within an afternoon, and for agent work they matter more than index points - an agent that says "this file is not in the context" instead of inventing its contents is the difference between a tool and a liability.

The migration traps nobody puts in the launch post

Switching from 3.8 Flash is one model string - plus seven changes in Google's own migration checklist that break silently if you skip them. The checklist below is the interactive version; the three that bite hardest:

Explicit caching is gone. If your cost model leans on cachedContents, those requests fail on Gemini 4. Implicit caching is what remains, and it changes the math on long static contexts - recheck your per-run cost before migrating, not after the invoice.

Your output cap is now a thinking cap too. max_output_tokens counts thinking and output together. An old 8,192 cap that fit Flash answers will truncate Hydrogen answers mid-thought. Google's advice: raise caps to 65,536 and control spend with the thinking level instead.

Sampling parameters became errors. In-range temperature values are ignored, but out-of-range values return a 400. Somewhere in your config there is a top_k from 2024. Find it before the deploy does.

On zainvibes.com this section is interactive: a migration checklist - work through all seven changes from Google's migration guide and track your progress. Try it on the original post.

Gemini 4 Hydrogen vs Argon vs 3.8 Flash: which runs your agents?

Still undecided? Answer four questions and take the verdict the post argues for:

On zainvibes.com this section is interactive: a decision picker - answer four questions about your workload and take the pick the post argues for. Try it on the original post.

Tools mentioned in this post

My verdict: make Hydrogen the worker, keep a frontier model as the planner

If you build coding agents, my default is: Hydrogen runs the steps, a frontier model plans the work, and the thinking level is set per step type. Hydrogen alone is the right call for step-shaped workloads - issue fixes, test repair, codebase Q&A, subagent fan-out - where runs are many, latency matters, and no single step needs frontier reasoning. The flat price across the full window and the free tier for evaluation make it the cheapest serious agent model to adopt carefully.

The answer flips in three named conditions. If your workload is one long reasoning chain rather than steps, that is Argon or Carbon work - Hydrogen is the executor, not the brain. If your cost model depends on explicit context caching, you do not migrate until that is reworked, full stop. And if you are happily on 3.8 Flash with no agent ambitions, the rational move is unglamorous: ride the half-price promo to December 31, budget the January doubling, and migrate when the price gap closes to zero - because from January 1, staying on Flash buys you the older model at the same price.

If you are wiring a coding agent into a product and want the cost model reviewed before it scales, that is exactly the kind of system I build for clients - tell me about it here.

Frequently asked questions

What is Gemini 4 Hydrogen?

Gemini 4 Hydrogen is Google's fast model tier for everyday coding and agentic workflows, launched November 12, 2026. It takes over the role Gemini 3.8 Flash held, under the Gemini 4 family's element naming (Hydrogen, Argon, Carbon). It has a unified 1,048,576-token context window, four thinking levels, and costs $1.50 per 1M input tokens and $7.50 per 1M output tokens on the paid tier, with a free tier available.

How much does Gemini 4 Hydrogen cost per million tokens?

On the Standard tier, $1.50 per 1M input tokens and $7.50 per 1M output tokens, flat across the full 1M-token context window, with cached input at $0.075 per 1M. Batch and Flex processing halve that to $0.75 / $3.75. Priority processing costs $2.70 / $13.50. Output prices include thinking tokens, so the thinking level you pick directly sets your bill.

Is Gemini 4 Hydrogen free to use?

Yes. Unlike Gemini 4 Carbon and Argon, which are paid-tier only, Hydrogen is available on the free tier of the Gemini API and in Google AI Studio, with rate limits. Free-tier content may be used to improve Google's products; paid-tier content is not.

What are the four thinking levels in Gemini 4 Hydrogen?

Low, medium, high and xhigh. High is the default. Low spends the fewest tokens and suits high-throughput steps; medium fits interactive coding; high is the recommended default for complex coding and tool calling; xhigh spends the most tokens and is meant for hard multi-step problems where high falls short. Thinking tokens are billed at the output rate, so xhigh can roughly double a run's output cost.

Should I migrate from Gemini 3.8 Flash to Gemini 4 Hydrogen?

For coding agents and tool-using workloads, yes - it is Google's recommended upgrade and the code change starts with the model string. Three traps matter: Gemini 4 removed explicit context caching (implicit caching only), the default thinking level rises from medium to high, and old low max_output_tokens caps can truncate answers because the cap now counts thinking and output together. Also note the price crossover: 3.8 Flash is half Hydrogen's price until December 31, 2026, then doubles to exactly Hydrogen's rate.

Gemini 4 Hydrogen vs Gemini 4 Argon: which should I use?

Hydrogen for execution: fast, cheaper per token, built for many-step agent work. Argon is the efficient frontier reasoner - use it when a task is one long chain of hard reasoning rather than many steps, or pair them: Argon or Carbon plans, Hydrogen executes the steps. Carbon remains the strongest model for the hardest problems and costs the most thinking tokens per turn.