How to Use Gemini 4 Hydrogen in AI Studio and the API

Google released Gemini 4 Hydrogen on November 12, 2026. The model ID is gemini-4-hydrogen. It targets fast everyday coding, debugging, and agentic workflows while matching or beating deeper models on key benchmarks at lower cost and latency.

It features a unified 1,048,576-token context window shared by input, thinking, and output. Default synchronous output is 65,536 tokens. Long decode extends this to the full 1M window via background execution or continuation. Pricing is flat: $1.50 per million input tokens and $7.50 per million output tokens (thinking included). Implicit cached input is $0.075 per million.

This guide shows how to access it in Google AI Studio, call it via the Interactions API in Python, JavaScript, and REST, set thinking levels, send multimodal inputs, and apply it to agentic coding.

Set Up in Google AI Studio and Get an API Key

Open Google AI Studio. Sign in with a Google account. Hydrogen is available on free and paid tiers.

In the model selector, choose Gemini 4 Hydrogen or use the direct link: https://aistudio.google.com/prompts/new_chat?model=gemini-4-hydrogen. In Run settings you can adjust the thinking level (low, medium, high default, xhigh) and other controls.

Create an API key from the API keys page. New keys are authorization keys. Store the key in an environment variable (GEMINI_API_KEY) and never commit it. Free-tier rate limits apply; move production traffic to a billed project so you control data retention.

Install the official SDK:

pip install -U "google-genai>=2.34.0"
# or
npm install @google/genai

The SDK uses the Interactions API by default for Gemini 4 models.

Call the Interactions API

The recommended endpoint is the Interactions API (client.interactions.create). It supports store, background execution, and continuation cleanly.

Python

from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-4-hydrogen",
    input="Build an interactive single-file HTML token-bucket rate-limiter simulator with live sliders for burst size and request traffic."
)
print(interaction.output_text)

JavaScript

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

const client = new GoogleGenAI({});

const interaction = await client.interactions.create({
  model: "gemini-4-hydrogen",
  input: "Build an interactive single-file HTML token-bucket rate-limiter simulator with live sliders for burst size and request traffic."
});
console.log(interaction.output_text);

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/interactions" \
  -H "x-goog-api-key: $GEMINI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemini-4-hydrogen",
    "input": "Explain how a token-bucket rate limiter works in three short paragraphs."
  }'

OpenAI-compatible clients also work by setting the base URL to https://generativelanguage.googleapis.com/v1beta/openai/ and the model to gemini-4-hydrogen. Sampling parameters (temperature, top_p, top_k) are ignored; the server controls them.

Thinking Levels

Hydrogen supports four thinking levels: low, medium, high (default), and xhigh. Higher levels increase reasoning depth, latency, and billable output tokens (thinking is counted as output). The model rejects minimal or thinking_budget.

Level	Typical use	Relative cost/latency
low	High-volume simple tasks, routing	Lowest
medium	Interactive coding, live prototyping	Moderate
high	Default for most coding, tools, multimodal	Balanced
xhigh	Hard multi-step debugging, architecture	Highest

Set it in the generation config:

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

Start with high. Drop to medium or low for high-throughput paths. Reserve xhigh for cases where high is insufficient. Evaluate your own tasks; Artificial Analysis measured roughly 27 / 41 / 51 / 54 index points across the four levels.

Multimodal Inputs

Hydrogen accepts text, images, audio, video, and PDFs. Output is text. It handles dense tables, charts, and long documents well.

Pass file data or URIs in the input. For local files the SDK handles upload; for public URLs you can reference them directly in many flows. Ask for structured extracts or cited summaries.

Example pattern (Python, conceptual):

# After preparing file part or upload
interaction = client.interactions.create(
    model="gemini-4-hydrogen",
    input=[
        {"type": "text", "text": "Extract key findings and any tables from this PDF. Cite page numbers."},
        {"type": "file", "file": pdf_file_reference}
    ]
)

Use it for document workflows, screenshot-to-code, or video frame inspection via agentic video understanding.

Long Outputs and Continuation

Synchronous responses stop at 65,536 tokens. For longer generations set background=True and a higher max_output_tokens (up to 1M minus input). The SDK or server handles continuation automatically in recent versions.

interaction = client.interactions.create(
    model="gemini-4-hydrogen",
    input="Generate a complete multi-module migration specification and test suite.",
    background=True,
    generation_config={
        "max_output_tokens": 262144,
        "thinking_level": "high"
    }
)
# Poll until status is complete, then join text from steps

Without background and an elevated limit the response stops at the default cap. Prefer background for long agent runs.

Pricing and Best Practices

Standard paid rates: $1.50 / 1M input, $7.50 / 1M output. Batch and Flex tiers are half price. Priority is higher. Free tier exists with limits; data may be used to improve Google products.

Implicit caching applies to prompts of at least 4,096 tokens and discounts cached input by 95 %. Explicit caching is not supported.

Tips:

• Keep system instructions concise and declare tools natively (function calling or structured output). Do not rely on raw-text JSON tool calls.
• Preserve conversation state and thought signatures across turns.
• Lower thinking level before raising max_output_tokens for cost control.
• Monitor usage in AI Studio or Cloud console and set budget alerts.
• For Android/Firebase integration see our Gemini 4 Hydrogen Firebase AI Logic guide.

Agentic Workflows

Hydrogen is designed for tool-using agents. It recovers cleanly when a tool call fails or a search returns empty, and it batches parallel tool calls effectively.

Typical loop:

1. Send the task plus tool declarations.
2. Execute any requested tools outside the model.
3. Return results (or errors) in the next interaction.
4. Continue until the goal is met.

It makes focused edits rather than rewriting entire files, which suits iterative repository work. Pair it with Gemini 4 Carbon for hard planning steps and Hydrogen for execution and verification. In Google Antigravity it is the default model for managed agents.

Conclusion and Next Steps

Gemini 4 Hydrogen gives developers a fast, capable default for coding and agentic work without routing every request to a frontier model. Open AI Studio, create a key, install the latest google-genai or @google/genai SDK, and start with the default high thinking level on the Interactions API.

Test thinking levels and long-decode settings on your own tasks. Move production traffic to a billed project. Official details are in the Gemini 4 Hydrogen model page, the what’s-new guide, and the Interactions API documentation.

Sources

• Blog.google: Introducing Gemini 4 Hydrogen for Agentic Workflows (12 November 2026)
• Google AI Studio: Gemini 4 Hydrogen model page and What’s new guide
• Google Cloud: Gemini 4 Hydrogen developer documentation
• Artificial Analysis Intelligence Index measurements (referenced scores)