Gemini 4 Argon is generally available at an introductory $2 per million input tokens and $10 per million output tokens through November 30, 2026, and $4/$20 from December 1. At those prices Artificial Analysis measures $1.99 per Intelligence Index task now and $3.98 from December, against $3.26 for GPT-6 Astra. On the Vals Index, run at the standard price, Argon costs $15.68 per test, rising to $193.78 on a long computer-use benchmark.
Those are the numbers to size budgets, spend caps and rate limits around, not the per-token headline. This post lays out the official price inputs, AIHubMix's rates, the measured per-task costs, why the per-token discount doesn't carry through, the billing failure modes that break a budget with a fix for each, and a small calculator fed by the usage field of a real call.
The price inputs
All Argon rows come from Google's Gemini API pricing page; the AIHubMix row from its Gemini 4 Argon model page. USD per million tokens, paid tier only. Output prices include thinking tokens.
| Gemini 4 Argon | Input | Cached input | Output |
|---|---|---|---|
| Standard, to Nov 30 | $2.00 | $0.10 | $10.00 |
| Standard, from Dec 1 | $4.00 | $0.20 | $20.00 |
| Batch or Flex, to Nov 30 | $1.00 | $0.05 | $5.00 |
| Batch or Flex, from Dec 1 | $2.00 | $0.10 | $10.00 |
| Priority, to Nov 30 | $3.60 | $0.18 | $18.00 |
| Priority, from Dec 1 | $7.20 | $0.36 | $36.00 |
| AIHubMix, now | $2.00 | $0.10 | $10.00 |
- No long-context surcharge: one price up to the 1M-token window.
- Implicit caching only. Explicit caching (
cachedContents) isn't supported on Argon, so there's no storage fee; repeated prefixes of at least 4,096 tokens get 95% off automatically. - Google Search and Google Maps grounding: 5,000 free requests a month each, shared across Gemini 3 and newer models, then $14 per 1,000.
- AIHubMix also lists video and audio input at $2 per million tokens and web search at $0.014 per request. It hasn't said whether its price changes on December 1.
For comparison:
| Model | Input | Cached input | Output |
|---|---|---|---|
| Gemini 3.1 Pro Preview | $2.00 | $0.20 | $12.00 |
| Gemini 3.8 Flash, to Dec 31 | $0.75 | $0.075 | $3.75 |
| Gemini 3.8 Flash, from Jan 1 | $1.50 | $0.15 | $7.50 |
| GPT-6 Astra | $10.00 | — | $50.00 |
Gemini 3.1 Pro Preview prices apply to prompts up to 200k tokens; above that, input is $4 and output $18. GPT-6 Astra's price is as reported by Engadget.
Measured cost per task
Figures in this section come from Artificial Analysis (its launch analysis and model pages) and Vals AI. Both ran Argon at high, its highest thinking level, not at the default medium. Neither is Google's own number.
Artificial Analysis: before and after December 1
Artificial Analysis runs every model through the same Intelligence Index tasks and reports the average cost of one task. It doesn't say how many tasks the index has.
| Model | Index score | Cost per task |
|---|---|---|
| Claude Opus 5.5 | 58 | $5.98 |
| Claude Sonnet 5.5 | 56 | $5.46 |
| Gemini 4 Argon (high), from Dec 1 | 53 | $3.98 |
| GPT-6 Astra (max) | 53 | $3.26 |
| Gemini 4 Argon (high), to Nov 30 | 53 | $1.99 |
| Gemini 3.1 Pro Preview | 30 | $1.30 |
- Until November 30, Argon's tokens cost a fifth of Astra's and its tasks three fifths: an 80% discount per token shrinks to 40% per task. From December 1, a 60% discount per token turns into a cost per task about 1.2 times Astra's.
- The reason is token count. Argon averaged about 62k output tokens per task against about 27k for Astra, roughly 2.3 times as many. Running the whole index it generated 110M output tokens; the median model generated 85M, Gemini 3.1 Pro Preview 67M. Artificial Analysis puts it this way: the saving "is driven by lower token prices, rather than reduced token use".
- The two Claude models score higher and cost more: from December 1, Argon's $3.98 is about two thirds of Opus 5.5's $5.98 and about three quarters of Sonnet 5.5's $5.46.
- Against Gemini 3.1 Pro Preview, Argon scores 23 points higher and costs about 1.5 times as much per task now, about 3 times from December.
Vals AI: standard prices
Vals AI ran Argon at the standard $4/$20 price with a 262,144-token output cap and reports the average cost of one test.
| Model | Vals Index | Cost per test |
|---|---|---|
| Gemini 4 Argon | 68.90% | $15.68 |
| Claude Sonnet 5.5 | 67.04% | $21.34 |
| Claude Opus 5.5 | 66.97% | $32.14 |
| Claude Fable 5.1 | 65.83% | $28.71 |
On this suite Argon costs less per test than the three Claude models just below it, even at the December price. The cost climbs on Vals' long agentic benchmarks:
| Vals benchmark | Argon score | Cost per test |
|---|---|---|
| CUA-bench | 4.83% | $193.78 |
| Code Migration | 68.17% | $57.82 |
| Terminal-Bench Science | 44.29% | $44.90 |
| SRE Bench | 44.28% | $30.45 |
CUA-bench, a computer-use benchmark, is the worst case: the most expensive of these tests and one of Argon's weakest results, 7th of the 8 models Vals ran.
Reading the two sets together
- Against GPT-6 Astra, the introductory price carries the saving. From December 1 Argon costs more per task than Astra. Against Claude, Argon is cheaper with both testers.
- Long agentic runs are where the bill grows: $30 to $194 per test on Vals' agentic benchmarks, against $15.68 on the Vals Index.
- These are high-thinking numbers. Argon defaults to medium, and Google says low and medium use fewer tokens, but nobody has published cost or accuracy at those levels.
- Compare models within one tester, not across them. Artificial Analysis quotes the introductory price with the standard figure alongside; Vals uses the standard price. Their tasks and harnesses differ too.
Failure modes and fixes
The monthly cap trips in half the expected time
Cause: the budget was set at the $2/$10 introductory price, which ends November 30. From December 1 every Google rate doubles.
Fix: budget at $4/$20 now, and treat the introductory weeks as savings.
The output line is much bigger than the visible answers
Cause: output prices include thinking tokens, and Argon writes long: about 62k output tokens per Artificial Analysis task at high, 2.3 times GPT-6 Astra's 27k.
Fix: start at the default thinking_level (medium) and drop to low where quality holds. Google recommends testing all three levels and picking the lowest that meets your bar.
A response comes back empty but still costs money
Cause: max_output_tokens caps thinking and output together. When a response hits it, the request ends incomplete, with truncated or empty output, and the thinking tokens are still billed.
Fix: don't save money with a small cap. Google recommends at least 32,768 for apps that used lower limits, and lowering the thinking level instead.
A long answer costs more than its length suggests
Cause: answers past 64K tokens use long decode, which generates in 64K hops. Every token in every hop is billed, including thinking-only hops, and each hop re-sends the prompt plus everything generated so far as input. Google's example: a 1,000-token prompt that produces 200,000 tokens takes four hops and reports about 397,000 input tokens for a context of about 201,000. Cancelled and failed runs bill the work already done.
Fix: use long decode only when one answer genuinely needs more than 64K tokens. Implicit caching discounts the repeated hop input by 95%, but chat, Q&A, summarization, classification and extraction finish well under 32K and don't need it.
Cached input gets billed at full price
Cause: implicit caching only applies to prompts of at least 4,096 tokens with an identical prefix. The AIHubMix Gemini guide notes that a hit needs the same content, model and parameters, with repeated context placed first.
Fix: put stable context first and keep it identical from turn to turn: system prompt, tool definitions and documents at the top, the user's new message last.
Search-heavy agents cost more than their tokens
Cause: grounding is billed per query. Google charges $14 per 1,000 after 5,000 free a month, and one request can trigger several queries. AIHubMix bills web search at $0.014 per request.
Fix: count search calls per task alongside tokens, and cap them in the agent loop.
Declined answers get paid for twice
Cause: Argon declines more often than other frontier models when it isn't sure. A declined answer still bills its input and thinking tokens, and retrying the same question on Argon pays again.
Fix: route declines to a person or another model rather than retrying Argon.
Easy steps billed at frontier rates
Cause: every step of the agent runs on Argon in real time, including extraction and formatting.
Fix: route by difficulty. Send extraction, classification and formatting to Gemini 3.8 Flash, and send work that can wait to Batch or Flex at half the standard price.
Estimate your own cost
Prices go in a dict; the token counts come from the usage field of a real Argon call through AIHubMix's OpenAI-compatible endpoint.
import os
from openai import OpenAI
PRICES = { # USD per 1M tokens; output includes thinking tokens
"intro": {"input": 2.00, "cached": 0.10, "output": 10.00}, # Google, through Nov 30, 2026
"standard": {"input": 4.00, "cached": 0.20, "output": 20.00}, # Google, from Dec 1, 2026
"batch": {"input": 2.00, "cached": 0.10, "output": 10.00}, # Google Batch or Flex, from Dec 1
"aihubmix": {"input": 2.00, "cached": 0.10, "output": 10.00}, # AIHubMix model page, now
}
def task_cost(uncached_in, cached_in, output, tier="aihubmix"):
p = PRICES[tier]
return (uncached_in * p["input"] + cached_in * p["cached"] + output * p["output"]) / 1_000_000
client = OpenAI(
base_url="https://aihubmix.com/v1",
api_key=os.environ["AIHUBMIX_API_KEY"],
timeout=900, # hard prompts can take several minutes
)
resp = client.chat.completions.create(
model="gemini-4-argon",
reasoning_effort="medium", # Argon's default level; try "low" too
max_tokens=32768,
messages=[{"role": "user", "content": "<one real step of your workflow>"}],
)
u = resp.usage
details = getattr(u, "prompt_tokens_details", None)
cached_in = (getattr(details, "cached_tokens", 0) or 0) if details else 0
print("thinking tokens:", getattr(getattr(u, "completion_tokens_details", None), "reasoning_tokens", None))
for tier in ("aihubmix", "standard"):
print(tier, round(task_cost(u.prompt_tokens - cached_in, cached_in, u.completion_tokens, tier), 4))
Run a handful of real steps, not one, at the thinking level you plan to ship. If a response doesn't report cached tokens, the script counts all input as uncached, which overstates the cost. Check that completion_tokens includes the thinking tokens printed above, since those bill as output. If you size things on Gemini 3.8 Flash or 3.1 Pro Preview instead, expect Argon's counts to be higher: on Artificial Analysis' index it generated 110M output tokens where Gemini 3.1 Pro Preview generated 67M.
What's still open
- AIHubMix's price from December 1 (above).
- Cost and accuracy at low and medium thinking: every published measurement is at high.
Running it on AIHubMix
Argon is live on AIHubMix as gemini-4-argon, served through Vertex AI and Google AI Studio, at $2 input, $10 output and $0.10 cached per million tokens. The script above is all it takes to start collecting real token counts. For the cheap steps in the same workflow, Gemini 3.8 Flash is still the lower-cost option.
Keep reading: the Gemini 4 Argon series
- Before you budget for Argon, check whether its benchmarks justify it for your workload: Gemini 4 Argon for Developers: Benchmarks, a 1M-Token Output Cap, and Your First API Call
- Every number here was measured at high thinking. How to set the level and when long decode is worth its bill: Gemini 4 Argon thinking_level and Long Decode: A Developer's Guide
- The caps, timeouts and routing above, built into a migration from Gemini 3.x: Moving Gemini 3.x Code to Gemini 4 Argon: Failure Modes and Fixes
Sources
- Gemini Developer API pricing (Google AI for Developers)
- Long decode (Google AI for Developers)
- Gemini 4 Argon: Google is back as one of the top three labs in intelligence achieved (Artificial Analysis)
- Gemini 4 Argon benchmarks, cost and capabilities (Vals AI)
- Gemini 4 Argon on AIHubMix (AIHubMix)
Top comments (0)