Gemini 4 Hydrogen vs Carbon vs Argon: choosing and routing models
Compare Gemini 4 Hydrogen, Carbon, Argon and Gemini 3.5 Flash-Lite by task, token pricing and failure cost. Build a measured routing policy instead of picking by a leaderboard.
BY MEI LIN · FDEINTERVIEWS EDITORIAL · UPDATED NOVEMBER 15, 2026 · 4 MIN READ
PRACTICE THIS:Learn model routing ·Practise LLM design decisions ·Build an evaluation process
Start by evaluating Gemini 4 Hydrogen for everyday coding and agent work, then compare Carbon and Argon on tasks where deeper reasoning might reduce failures. Keep Gemini 3.5 Flash-Lite in the candidate set for narrow, high-volume extraction and routing. This is a testing order, not a universal ranking. Your decision should use cost per accepted task and latency under the same tool permissions, context and quality checks.
Google's Hydrogen guidance describes the intended model roles. Our Hydrogen integration guide covers SDK configuration and tool-call state; this article covers the separate question of which model should receive which work.
Compare roles before comparing scores
| Candidate | Start evaluating it on | Evidence needed to keep it |
|---|---|---|
| Gemini 3.5 Flash-Lite | Closed-label routing, small extraction tasks | Error rates within each important class |
| Gemini 4 Hydrogen | Routine code edits, document work, bounded tool use | Accepted task rate and p95 completion latency |
| Gemini 4 Argon | Longer reasoning tasks with a tight cost or time budget | Fewer failures than Hydrogen at acceptable total cost |
| Gemini 4 Carbon | Hard debugging, architecture and difficult verification | Enough avoided failures or rework to justify the spend |
These are evaluation hypotheses. Google calls Carbon its most capable reasoning model and positions Argon for lower token use and faster responses. That positioning does not establish which wins on your private codebase. Flash-Lite's model card targets throughput and low-cost execution; it does not promise a subsecond deadline for every request.
A deterministic rule may beat all four for a fixed permission decision. Keep the model where interpretation is useful, and keep the policy that authorizes an action in ordinary code.
Price the tokens the whole task consumes
The table is a dated snapshot of standard paid Gemini Developer API prices in USD per million tokens, checked November 15, 2026. These are not subscription quotas, enterprise regional prices or Batch rates. Output prices include thinking tokens. Official pricing is the source of record.
| Model | Input | Output | Scheduled change shown in the source |
|---|---|---|---|
| Gemini 3.5 Flash-Lite | $0.30 | $2.50 | None included here |
| Gemini 4 Hydrogen | $1.50 | $7.50 | None included here |
| Gemini 4 Argon | $2.00 | $10.00 | $4.00 / $20.00 from December 1, 2026 |
| Gemini 4 Carbon | $2.00 | $10.00 | $4.00 / $20.00 from December 1, 2026 |
This excludes cache discounts, grounding, other tools, infrastructure and human review. Recheck the rate card before budgeting a release.
For a synthetic task with 20,000 uncached input tokens and 4,000 billable output tokens, the listed model cost is $0.016 for Flash-Lite, $0.060 for Hydrogen and $0.080 for either Argon or Carbon at the introductory rate. The latter becomes $0.160 at the scheduled December rate. Equal token counts isolate price; real models will not necessarily consume equal tokens.
Run this small calculation locally; it makes no API call:
def token_cost(input_tokens, output_tokens, input_rate, output_rate):
if min(input_tokens, output_tokens, input_rate, output_rate) < 0:
raise ValueError("counts and rates must be nonnegative")
return (input_tokens * input_rate + output_tokens * output_rate) / 1_000_000
rates = {"flash-lite": (0.30, 2.50), "hydrogen": (1.50, 7.50),
"frontier-nov": (2.00, 10.00), "frontier-dec": (4.00, 20.00)}
for name, rate in rates.items():
print(name, f"${token_cost(20_000, 4_000, *rate):.3f}")
If a hypothetical Hydrogen pass succeeds on 80 of 100 tasks and every rejected task receives one $0.080 frontier attempt, spend becomes $7.60 before verification. Whether that is good value depends on how many of those 20 attempts actually recover the task. Our AI cost concept explains why dividing spend by successful outcomes is more informative than dividing by calls.
Route on evidence your application can check
Begin with a small, understandable routing policy: known extraction tasks go to an evaluated cheap path; ordinary coding tasks go to Hydrogen; difficult tasks enter an evaluated frontier path. Unknown or sensitive actions can require a person. Model confidence by itself is a poor escalation condition.
In the figure, verification is shared by every model. A more expensive model does not get a different permission policy.
A failed schema check can justify one repair attempt. Missing evidence may justify another retrieval step. A denied production write requires authorization, not a more capable model. Put a maximum on attempts and total spend, then return a useful failure when the budget is exhausted. The cascade design question develops that distinction.
Test the planner and worker as a combined system
A Carbon planner with Hydrogen workers is a reasonable experiment for decomposable work. Give each worker a precise input, an allowed tool set and a result contract. For a code migration, that might be one module plus its tests and compatibility conditions.
Compare it against Hydrogen alone and Carbon alone on the same task set. Count planner overhead, worker failures, duplicate exploration, merge conflicts and the final verification pass. A planner can produce a plausible decomposition that misses a shared invariant. More parallel tasks then produce the wrong result faster.
The harness engineering course treats task boundaries, receipts and verification as separate design choices. Apply the same discipline to routing: the worker's “done” message is evidence to inspect, not proof that the requested change is complete.
Hold the evaluation conditions steady
Build a versioned dataset with ordinary tasks, ambiguous requests and rare consequential failures. Keep input snapshots, tool versions, timeouts and grading rules fixed. Compare several runs where nondeterminism matters, and inspect paired regressions instead of celebrating a small average improvement.
Gemini 4's unified 1,048,576-token context includes input and output. Longer context can change cost and behavior; avoid silently giving one candidate a richer evidence packet. Thinking level also belongs in the configuration being evaluated. Test the supported settings for each model rather than assuming a level name means identical compute across models.
Record the selected route, model identifier, thinking setting, all attempts, measured latency and final outcome. Use model migration practice when changing the policy. Promote a route only after its important failure categories meet the quality floor and a rollback can restore the previous configuration.
Turn it into offers. Work the real questions and concepts this maps to:
FAQ
Evaluate Hydrogen first for everyday coding and tool-using workflows. Include Flash-Lite for narrow extraction or classification, and compare Argon and Carbon on the difficult cases. Choose the least costly configuration that meets your measured quality and latency requirements.
Their published standard Gemini API rates are the same at the time of this review. Google positions Argon as using less reasoning and responding faster. Total task cost can still differ because models consume different numbers of tokens, retries and tool calls.
Yes, as an application architecture. Define a bounded task for the worker, validate its result, and test the combined workflow against a single-model baseline. Delegation adds cost and can lose context, so it needs evidence of benefit.
No. Gemini 4 Hydrogen, Carbon and Argon share a unified input-and-output budget of 1,048,576 tokens. Reserve room for thinking, tool calls and the answer. Long decoding uses the remaining budget across segments.
Discussion (3)
A routing comparison needs the rejected attempts in its denominator. Looking only at successful requests can make a cheap model look inexpensive while a second model quietly does most of the repair work.
Keep unknown requests in a visible route. A router trained on familiar support intents should not confidently send an unseen administrative operation to the cheapest path.
A model's critique can be helpful evidence, but it cannot be the permission check for its own tool call. Changing the reasoning tier should leave the application's action boundary intact.
