Gemini 4 Hydrogen vs Claude Sonnet 5.5 vs GPT-6.1 Terra for everyday coding
Compare Hydrogen, Sonnet 5.5 and GPT-6.1 Terra on Google's benchmarks, official prices, effort defaults, free-tier access and 30 rerunnable test calls.
For everyday coding and small agent tasks, all three models are capable enough that price, latency and token habits decide more than raw ability. Start with GPT-6.1 Terra when cost and response time dominate, Claude Sonnet 5.5 when you want compact, predictable output, and Gemini 4 Hydrogen when you need Google’s free tier, native video and audio input, or the agentic and reasoning results on Google’s card. Then confirm the choice on a sample of your own tasks.
That recommendation rests on three kinds of evidence, labelled separately throughout this article:
- Vendor documentation from Google, Anthropic and OpenAI, checked on November 19, 2026: prices, context windows, output limits and effort defaults.
- Published measurements: the benchmark table on Google’s Gemini 4 Hydrogen model card and Artificial Analysis pages read on the same date.
- Our own small test: 30 calls (five tasks × three models × two runs) through one OpenAI-compatible endpoint, with every check written before the first call. All 30 passed. The test therefore separates the models on latency and token use, not on correctness.
Ofox publishes this article, and all three models are callable through Ofox. The test used Ofox’s endpoint because one request format reached all three models. We do not quote Ofox prices here; each model page shows the current rate.
Quick decision by task
This table combines our measured runs with each vendor’s documentation. “Our run” means two calls per model per task, so treat the latency figures as illustrations, not service levels.
| If your main workload is… | Start with | Why (and the evidence type) | Switch when |
|---|---|---|---|
| Small bug fixes, SQL, short functions from a spec | GPT-6.1 Terra | Passed every check here with the fewest output tokens in total and the lowest median latency; lowest list price of the three. Sonnet was slightly faster on the SQL and spec-to-code tasks (our run + OpenAI pricing) | Your own failures cluster on multi-file or long-context edits |
| Structured extraction (JSON from messy text) | Terra or Sonnet 5.5 | Both answered in roughly 80–85 output tokens; Hydrogen used 416 and 1,145 tokens for the same result (our run) | A schema needs reasoning across several documents |
| Multi-step planning without tools | Terra first, Sonnet 5.5 as the second opinion | All three found the optimal schedule; Terra was fastest, Sonnet’s output was mid-sized (our run) | Plans need tool calls or long constraints that you have not tested |
| Agent loops and repository work at default settings | Hydrogen or Sonnet 5.5, chosen by your eval | Google’s table shows Hydrogen ahead on SWE-sweep and AutomationBench-AA, Sonnet ahead on Terminal-Bench 4.1 and OSWorld-2.1 (vendor-reported) | Your own agent runs disagree with the vendor numbers |
| Video, audio or mixed-media inputs | Hydrogen | Accepts text, image, audio and video inputs; Sonnet 5.5 and Terra take text and image input (Google model card, Anthropic models overview, OpenAI’s Terra model page) | You only send text and images |
| Prototyping with no budget | Hydrogen on Google’s free tier | Only one of the three with a standing free API tier; Anthropic offers one-time credits to new users (Google and Anthropic pricing pages) | You need predictable throughput; free-tier limits apply |
If you are choosing a default model inside Google’s own family rather than across vendors, read our Gemini 4 Carbon vs Hydrogen vs Argon guide. For the wider three-vendor ladder from small to flagship models, see the Gemini 4 vs Claude vs GPT model tiers overview.
What Google’s Hydrogen model card compares
Google chose these exact opponents. Its Hydrogen model card, published November 12, 2026, lists Gemini 4 Hydrogen next to Claude Sonnet 5.5 and GPT-6.1 Terra. We rebuilt the table from a snapshot taken on November 19, 2026, keeping Google’s “Notes” labels because they change what each number means.
| Category | Benchmark (Google’s note) | Gemini 4 Hydrogen | Claude Sonnet 5.5 | GPT-6.1 Terra |
|---|---|---|---|---|
| Agentic coding | SWE-sweep | 13.5% | 3.1% | 5.8% |
| Agentic coding | Terminal-Bench 4.1 (cheating-adjusted) | 57.0% | 63.9% | not listed |
| Knowledge work | Agents’ Last Exam v1.1 (score) | 71.6% | 60.4% | 69.8% |
| Knowledge work | AutomationBench-AA | 76.1% | 71.8% | 60.2% |
| Knowledge work | Vending-Bench 2 (bank balance) | $14,549 | $11,165 | $9,107 |
| Computer use | OSWorld-2.1 (offline subset) | 77.6% | 83.9% | 74.2% |
| Multimodal understanding | MKA (Climb WSR accuracy) | 53.4% | 52.0% | 43.8% |
| Multimodal understanding | Chartography | 66.6% | 61.6% | 63.2% |
| Science and math | Terminal-Bench-Science 0.1 | 51.4% | 59.9% | 58.3% |
| Reasoning | HLE-Diamond | 58.8% | 53.3% | 47.3% |
Source: Google DeepMind, Gemini 4 Hydrogen model card, “Results as of November, 2026”. These numbers are vendor-reported and were not reproduced by Ofox.
Read it in two parts. Hydrogen leads on seven of the ten rows, including the largest relative gap on SWE-sweep. Sonnet 5.5 leads on three: Terminal-Bench 4.1, OSWorld-2.1 and Terminal-Bench-Science. Terra leads no row here and has no Terminal-Bench 4.1 entry. Several cautions apply before you treat this as a ranking:
- The rows that favor Sonnet are terminal and computer-use work. If your agent mainly drives a shell or a desktop, those rows are more relevant to you than a reasoning exam.
- The snapshot does not say which effort or thinking settings each model used, nor whether rival scores came from Google’s runs or from the other vendors. Google points to a methodology page for details; we have not audited it.
- SWE-sweep scores are low for all three. A 13.5% versus 3.1% gap is large in relative terms but still describes a benchmark that each model mostly fails.
- “Cheating-adjusted” and “offline subset” are specific scoring variants. Compare them only with numbers that use the same variant.
Google positions Hydrogen as its model for “everyday coding and agentic workflows”. The card also lists known limitations: hallucinations, occasional slowness or timeouts, and higher token use at higher thinking levels. Our runs are consistent with the token point: Hydrogen used the most output tokens on every task, although we could not see which thinking level the route applied.
Prices, context, output limits and effort controls
All figures below come from each vendor’s own documentation, checked on November 19, 2026. Prices are Standard tier list rates in USD per one million tokens.
| Gemini 4 Hydrogen | Claude Sonnet 5.5 | GPT-6.1 Terra | |
|---|---|---|---|
| Native model ID | gemini-4-hydrogen | claude-sonnet-5-5 | gpt-6.1-terra |
| Input | $1.50 | $2.00 | $1.00 (≤272K context) / $2.00 (>272K) |
| Output, including reasoning | $7.50 | $10.00 | $5.00 (≤272K) / $7.50 (>272K) |
| Cache hits | $0.075 (implicit caching only) | $0.10 | $0.05 (≤272K) / $0.10 (>272K) |
| Cache writes | none listed (implicit) | $2.50 (5-minute) / $4.00 (1-hour) | $1.25 (30-minute) / $2.50 (12-hour), ≤272K |
| Long-context surcharge | none: flat across 1M | none: full 1M at standard rates | yes, above 272K tokens |
| Context window | 1,048,576 shared by input, thinking and output | 1M | 1,050,000 |
| Max output | 65,536 per synchronous request; long decode to 1M in background mode | 128K | 128,000 |
| Effort / thinking control | thinking_level: low, medium, high (default), xhigh | effort: low, medium, high (default), xhigh, max | reasoning effort: none, low, medium (default), high, xhigh, max |
| Free API tier | Yes, rate-limited | No; free credits for new users | No free tier listed |
| Batch price | $0.75 / $3.75 | $1.00 / $5.00 | $0.50 / $2.50 (≤272K) |
Sources: Google pricing and the Hydrogen developer guide; Anthropic’s pricing, models overview and effort guide; OpenAI’s pricing and GPT-6.1 Terra model page.
Three practical consequences follow from this table.
The defaults are not equal. Hydrogen and Sonnet 5.5 default to their “high” setting, while Terra defaults to “medium”. Comparing models without setting effort, as most people do on day one, compares Terra one level lower. Anthropic recommends medium as a starting point for well-specified agentic coding on Sonnet 5.5. Google recommends running evaluations at all four Hydrogen levels and choosing the lowest that meets your quality bar. Our guides on Sonnet 5.5 effort levels and Gemini 4 thinking levels cover those sweeps.
List price is not task cost. Hydrogen’s output rate is 25% below Sonnet’s, but output tokens include thinking. In our runs Hydrogen produced about 2.7 times as many output tokens as Sonnet for the same passing answers, so its estimated cost was higher. The Sonnet 5.5 task-cost guide shows how to account for cache, retries and output across a full task.
Long prompts change Terra’s price. Above 272K tokens of context, Terra’s input and output rates rise to $2.00 and $7.50. Hydrogen and Sonnet 5.5 charge the same rate across their full windows. For repository-scale prompts, compute the cost at your real prompt length instead of the headline rate.
The Hydrogen free tier
Google lists Hydrogen as “free of charge” on the free tier of the Gemini API and AI Studio, subject to rate limits. Google’s pricing table also marks free-tier data as used to improve its products, which is not the case on the paid tier. Neither Anthropic nor OpenAI lists a free API tier for Sonnet 5.5 or Terra. Anthropic’s pricing FAQ says new users receive free credits to test the API, which is a one-time trial rather than an ongoing free tier.
That free tier belongs to Google’s own API only. It does not cover requests sent through Ofox or any other gateway; those are billed by the gateway. Our Hydrogen API setup guide walks through both routes, and the Gemini 4 free API tier explainer covers eligibility and limits.
Independent measurements: Artificial Analysis at each model’s default
Artificial Analysis publishes an Intelligence Index plus speed, token-use and cost data for each effort setting. Its headline figure uses each model’s top setting, which is not what most applications run. The table below reads each model at its documented API default. We took the values from the data embedded in the three model pages on November 19, 2026; they change as Artificial Analysis reruns its evaluations.
| Artificial Analysis metric | Hydrogen at high (default) | Sonnet 5.5 at high (default) | Terra at medium (default) |
|---|---|---|---|
| Intelligence Index | 50.8 | 41.5 | 38.2 |
| Output speed (tokens/s) | 164.7 | 135.8 | 60.4 |
| Time to first answer token | 19.4 s | 9.4 s | 5.1 s |
| Output tokens per index task | 84,978 | 58,421 | 10,875 |
| Time per index task | 8.6 min | 7.2 min | 3.0 min |
| Cost per index task | $1.87 | $1.64 | $0.17 |
| Headline index (top setting) | 53.9 at xhigh | 54.5 at max | 51.3 at max |
Source: Hydrogen, Sonnet 5.5 and GPT-6.1 Terra pages on Artificial Analysis, read November 19, 2026. Cost per task is Artificial Analysis’ own calculation at list prices.
At default settings, Hydrogen scores highest and generates tokens fastest. It also produces about 1.5 times Sonnet’s output tokens and nearly eight times Terra’s per task, and it has the longest wait before the first answer token. Terra generates tokens most slowly but needs so few that it finishes an average task in less than half the time of the other two, at roughly a tenth of their cost. At the top settings, Sonnet 5.5 edges ahead of Hydrogen on the index. However, Artificial Analysis measured a time to first answer token of about 264 seconds for Sonnet at max, so that setting does not suit interactive work.
These are aggregate evaluations. Our small test, next, shows the same pattern on concrete tasks.
We ran five everyday tasks through one endpoint
Setup. On November 19, 2026, we sent each task as a single user message to https://api.ofox.ai/v1/chat/completions with model IDs google/gemini-4-hydrogen, anthropic/claude-sonnet-5.5 and openai/gpt-6.1-terra. Each request contained only model, messages and max_tokens: 32000: no system prompt, no sampling parameters and no reasoning or effort field. We do not know which effort or thinking level each Ofox route applied when none is sent. It may match the vendor’s documented API default (high, high and medium), but the responses do not report it, so we cannot confirm that. Each task ran twice per model, with the model order rotated between tasks and rounds. Latency is wall-clock time for a non-streaming response from our client, so it includes network time. Token counts come from the usage object returned with each response.
Checks. Every check was written and validated against a reference answer before the first model call. A run passes only if the program’s check passes; we did not grade by eye.
| Task | What the model had to do | Objective check |
|---|---|---|
| T1 Fix a failing function | Repair merge_intervals (unsorted input, touching intervals) | Execute the returned function on the given test plus four held-out cases: empty list, touching, nested, point intervals |
| T2 SQL from a schema | Customers with ≥2 paid 2026 orders, total paid, fixed ordering | Run the query on seeded SQLite data and compare rows exactly; data includes refunds, a 2025 order and a tie |
| T3 JSON extraction | Invoice fields from a messy forwarded email with a self-correction and European number format | Parse JSON; exact keys; values must equal the expected record (corrected total 1420.5, due date computed from terms, PO null) |
| T4 Planning without tools | Two-worker release schedule with dependencies and a shared-resource rule | Validate all dependency, worker and no-overlap rules, then require the minimum finish time (68 minutes) |
| T5 Code from a spec | retry_delay_seconds() for HTTP Retry-After, seconds or HTTP-date | Nine held-out cases, including whitespace, negative, unparseable and past dates |
Results
| Task | Hydrogen: pass, latency, output tokens | Sonnet 5.5: pass, latency, output tokens | Terra: pass, latency, output tokens |
|---|---|---|---|
| T1 fix function | 2/2 · 4.3 s, 4.5 s · 551, 603 | 2/2 · 4.2 s, 4.2 s · 270, 282 | 2/2 · 1.9 s, 2.9 s · 106, 144 |
| T2 SQL | 2/2 · 8.2 s, 7.0 s · 1,160, 901 | 2/2 · 3.4 s, 3.1 s · 190, 190 | 2/2 · 3.7 s, 4.7 s · 311, 333 |
| T3 JSON extraction | 2/2 · 3.6 s, 8.5 s · 416, 1,145 | 2/2 · 3.1 s, 3.3 s · 85, 85 | 2/2 · 4.2 s, 2.1 s · 83, 79 |
| T4 planning | 2/2 · 9.3 s, 10.3 s · 1,318, 1,373 | 2/2 · 9.1 s, 8.3 s · 755, 840 | 2/2 · 3.9 s, 3.6 s · 224, 265 |
| T5 spec to code | 2/2 · 14.9 s, 23.8 s · 2,154, 3,532 | 2/2 · 9.9 s, 9.1 s · 1,132, 1,013 | 2/2 · 10.7 s, 10.6 s · 941, 1,001 |
| Totals over 10 calls each | Hydrogen | Sonnet 5.5 | Terra |
|---|---|---|---|
| Passed | 10/10 | 10/10 | 10/10 |
| Median latency | 8.4 s | 4.2 s | 3.8 s |
| Slowest call | 23.8 s | 9.9 s | 10.7 s |
| Input tokens (reported) | 2,372 | 2,874 | 1,916 |
| Output tokens (reported) | 13,153 | 4,842 | 3,487 |
| Estimated cost at official list rates | $0.102 | $0.054 | $0.019 |
Measured on November 19, 2026, n = 2 per cell. The cost row is our calculation from reported tokens and each vendor’s Standard list rates, not an invoice; Ofox bills at the rate shown on each model page. All 30 calls together came to about $0.18 at list rates.
What the runs show:
- Correctness did not separate the models on these tasks. Each model passed every held-out case in both runs, including the European decimal format, the corrected invoice total and the C/D scheduling conflict. This is a useful finding about everyday tasks of this size, but it says nothing about harder work.
- Hydrogen, as routed with no thinking level set, spent the most tokens on every task. Most of its output was reasoning: for example, 3,361 of 3,532 output tokens on the slower T5 run. It also had the widest spread between runs (T3: 3.6 s and 8.5 s for the same prompt). That matches Google’s warning that higher thinking levels use more tokens.
- Sonnet 5.5 was the most consistent. Its two runs were within a second of each other on every task, and its JSON answer was 85 tokens both times. On the three shortest tasks, its usage object contained no reasoning-token breakdown, so we cannot say how much it thought there.
- Terra was cheapest on all five tasks and had the lowest median latency. It was clearly fastest on the bug fix and the planning task and roughly tied with Sonnet on extraction; Sonnet was faster on SQL and spec-to-code. Terra’s short output compensates for the lowest token generation speed of the three in Artificial Analysis’ data.
The obvious follow-up is to rerun Hydrogen at medium or low and Sonnet at medium. We did not do that here because the Ofox mapping for each route’s effort field needs its own verification. Treat the Hydrogen numbers as a measurement of whatever setting the route applied when none was sent, not of its best cost-quality setting.
Rerun it yourself
The prompts below are the exact text we sent. Replace the endpoint and model IDs with your provider’s, keep max_tokens high, and run the same checks. Save the raw response so you can inspect usage later.
import json, os, time, urllib.request
def ask(model: str, prompt: str) -> tuple[str, dict, float]:
body = {"model": model, "messages": [{"role": "user", "content": prompt}], "max_tokens": 32000}
req = urllib.request.Request(
"https://api.ofox.ai/v1/chat/completions",
data=json.dumps(body).encode(),
headers={"Authorization": "Bearer " + os.environ["OFOX_API_KEY"],
"Content-Type": "application/json"},
)
t0 = time.monotonic()
resp = json.load(urllib.request.urlopen(req, timeout=600))
return resp["choices"][0]["message"]["content"], resp.get("usage", {}), time.monotonic() - t0
The base URL and request shape follow Ofox’s Chat Completions reference. Run the checks with Python 3.10 or newer: two models returned type hints such as str | None that Python 3.9 cannot evaluate without a __future__ import.
T1 prompt
This function fails its test. Fix the function. Return only the corrected function in one ```python block.
```python
def merge_intervals(intervals):
"""Merge overlapping or touching closed intervals [start, end].
Input may be unsorted. Return a new sorted list of [start, end] lists."""
merged = []
for start, end in intervals:
if merged and start < merged[-1][1]:
merged[-1][1] = end
else:
merged.append([start, end])
return merged
```
Failing test:
```python
def test_merge():
assert merge_intervals([[5, 7], [1, 3], [2, 4]]) == [[1, 4], [5, 7]]
```
Held-out cases: [] → [], [[1,3],[3,5]] → [[1,5]], [[1,10],[2,3]] → [[1,10]], [[4,4],[1,2]] → [[1,2],[4,4]].
T2 prompt (seed data for the check: five customers and twelve orders, including a refunded order, a December 2025 order and three customers tied at 2,000 cents; the expected rows are ana@, cy@ and di@example.com, each with 2000)
SQLite schema:
```sql
CREATE TABLE customers (id INTEGER PRIMARY KEY, email TEXT NOT NULL);
CREATE TABLE orders (id INTEGER PRIMARY KEY, customer_id INTEGER NOT NULL REFERENCES customers(id),
status TEXT NOT NULL, -- 'paid', 'refunded' or 'pending'
created_at TEXT NOT NULL, -- ISO 8601 UTC, e.g. '2026-03-01T09:30:00Z'
amount_cents INTEGER NOT NULL);
```
Write one SQLite query that returns, for every customer with at least 2 orders whose status is 'paid' and whose created_at falls in calendar year 2026 (UTC), two columns: email and total_paid_cents (the sum of amount_cents over those same orders). Order by total_paid_cents descending, then email ascending. Return only the query in one ```sql block.
T3 prompt
Extract the invoice details from the message below. Reply with only a JSON object with exactly these keys:
"vendor" (string), "invoice_number" (string), "issue_date" (YYYY-MM-DD), "due_date" (YYYY-MM-DD or null), "currency" (ISO 4217 code), "total" (number), "po_number" (string or null).
Use the corrected values if the message corrects itself. Compute due_date if the payment terms make it determinable. Do not guess values that are missing.
---
fwd: pls process asap!!
> From: billing@northwind-supplies.example
> Hi team, attached is inv. NW-2026-0419 from Northwind Supplies Ltd, dated 3 Nov 2026.
> Amount due: EUR 1.240,50 (incl. VAT). Payment terms: 30 days from invoice date.
> Sorry, correction: the total should read EUR 1.420,50, the first figure had a typo.
> PO: we don't have one from you yet, please send it.
--
Sent from my phone
---
Expected: NW-2026-0419, issue 2026-11-03, due 2026-12-03, EUR, total 1420.5, PO null.
T4 prompt
Plan a release. Steps and durations (minutes):
A build=10, B unit tests=15, C integration tests=20, D database migration=12, E deploy canary=8, F smoke test=5, G full rollout=10, H notify customers=3.
Rules:
1. B and C need A finished. D needs B finished.
2. E needs C and D finished. F needs E finished. G needs F finished.
3. H must start only after G finished.
4. Two workers are available; a worker does one step at a time and a step is never split.
5. D must not run at the same time as C (they share the staging database).
Find a schedule with the smallest possible finish time. Reply with only a JSON object {"steps": [{"id": "A", "start": 0}, ...]} listing all eight steps with integer start minutes.
The optimum is 68 minutes: C runs from 10 to 30, so D must wait until 30.
T5 prompt
Write a Python function `retry_delay_seconds(header: str | None, now: datetime.datetime) -> float | None` for an HTTP client.
- `header` is the raw Retry-After header value (may be None, may have surrounding whitespace).
- If it is a non-negative integer number of seconds, return it as a float.
- If it is an HTTP-date (IMF-fixdate, e.g. "Wed, 21 Oct 2026 07:28:00 GMT"), return the seconds from `now` (timezone-aware UTC) until that date; return 0.0 if the date is in the past.
- Return None for None, empty, negative or unparseable values.
Use only the standard library. Return only the code (imports plus the function) in one ```python block.
With now = 2026-10-21 07:00:00 UTC, the held-out cases are: "120" → 120.0, " 7 " → 7.0, "0" → 0.0, None, "", "-5" and "soon" → None, "Wed, 21 Oct 2026 07:28:00 GMT" → 1680.0, and a date one day earlier → 0.0.
Limits of this comparison
- Small sample. Two runs per cell show direction, not stable rates. A model that passed 2/2 can still fail on the third run.
- Easy tasks. All 30 calls passed, so these tasks cannot rank the models on correctness. Use your own failure cases, especially multi-file edits and long contexts, before trusting any ranking.
- One route. We measured through Ofox’s OpenAI-compatible endpoint from one client location. Native APIs, other regions, streaming and time of day can change latency. Ofox’s catalog notes that Terra’s tool calling uses the Responses API, so tool-using agent tests on Terra need that endpoint rather than the Chat Completions call above.
- No tools, no images, no long context. None of the tasks exercised function calling, computer use, multimodal input or prompts above a few hundred tokens. Those are exactly the areas where Google’s table shows the largest differences.
- Unknown, unmatched effort. We did not set effort, and the effort each Ofox route applied is not visible in the responses. If the routes follow the vendors’ documented defaults, Terra ran one level lower than the other two. Either way, our results measure each model as it answers a request with no effort field, not at matched effort.
When a call fails
If a test call errors rather than answering, the cause is usually the route or a parameter, not the model’s ability. For Hydrogen, check the Gemini 4 API errors guide. In multi-turn tool use, also check the missing thought signature fix. For Sonnet 5.5, the Sonnet 5.5 migration 400 errors guide covers requests rejected after an upgrade, such as disabled thinking and forced tool use. For GPT-6.1 tool calls, see the Responses API tool-calling fix, written for Sol but covering the same request format. Retry 429 responses with backoff as described in our 429 retry guide. Ofox’s error-handling and rate-limit docs list the gateway’s own codes and default limits.
Related comparisons and setup guides
- One tier down: Gemini 4 Hydrogen vs Claude Haiku 5.5 vs GPT-6 Luna.
- One tier up: Gemini 4 Neon vs Claude Opus 5.5 vs GPT-6.2 Sol.
- Hydrogen in a coding agent: use Hydrogen in Cline and OpenCode; moving from Flash: Gemini 3.8 Flash to Hydrogen migration.
- Sonnet 5.5 against OpenAI’s larger model: GPT-6.1 Sol vs Claude Sonnet 5.5.
- Sonnet 5.5 in practice: Claude Code setup and Sonnet 5.5 vs Opus 5.5 for coding.
Related Docs
- Ofox Chat Completions API reference
- Ofox error handling and rate limits
- Ofox tool integrations
- Model pages with current Ofox prices: Gemini 4 Hydrogen, Claude Sonnet 5.5, GPT-6.1 Terra


