Gemini 4 Argon Real Cost Tested: From $1.99 Per Task

When Google launched Gemini 4 Argon, it advertised a $2/$10 promotional price tag — but the real bill goes far beyond that number. Two independent evaluators, Artificial Analysis and Vals AI, each ran the same set of tasks against it, and their per-task costs diverged wildly: from $1.99 to $193.78.

Understanding why those numbers differ is the prerequisite for budgeting, setting spend caps, and designing rate-limiting strategy.

Price Inputs: Promo vs. Standard

Argon's pricing comes from Google's launch blog; other Gemini model data comes from the Gemini API pricing page. Units are USD per million tokens.

Model	Input	Cached Input	Output
Gemini 4 Argon (promo)	$2.00	$0.10	$10.00
Gemini 4 Argon (standard)	$4.00	TBD	$20.00
Gemini 3.1 Pro Preview	$2.00	$0.20	$12.00
Gemini 3.8 Flash (through 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

A few easily overlooked details: Gemini 3.1 Pro Preview's pricing only applies to prompts under 200k tokens — beyond that, input jumps to $4 and output to $18. Google hasn't announced when the promo ends; Artificial Analysis says it has been running for at least a month since September 30. Whether the 95% cache discount survives the end of the promo is currently unstated — for reference, Gemini 3.8 Flash's cache discount is 90%.

Cached input refers to the portion of tokens for which a model provider offers discounted billing on repeated prompt prefixes. Mainstream providers (Gemini, Claude, GPT series) all support "prompt caching": when multiple requests share the same prefix — say, a fixed system prompt, tool definitions, or a long document — the provider can reuse the KV cache for that content, avoiding repeated prefill, and therefore charge far less than normal input. Under Argon's promo pricing, cached input is $0.10 per million tokens, i.e., 5% of the normal $2.00 input rate — a 95% discount. Caching is triggered two ways: implicit caching, where the provider automatically detects identical prefixes without any explicit declaration from the developer, and explicit caching, which requires calling the API to create a cache object and paying a storage fee. Implicit caching is sensitive to hit conditions — content, model, and parameters must be identical, and the stable context must appear near the front of the prompt, or it won't hit.

Measured Per-Task Costs

Artificial Analysis: Promo vs. Standard

Artificial Analysis tests each model on a unified Intelligence Index task suite and reports average per-task cost.

Model	Index Score	Cost Per Task
Gemini 4 Argon (high), promo	53	$1.99
Gemini 4 Argon (high), standard	53	$3.98
GPT-6 Astra (max)	53	$3.26
Gemini 3.1 Pro Preview	30	$1.30

A key phenomenon emerges here: Argon's promotional per-token price is only one-fifth of Astra's, yet its per-task cost is three-fifths of Astra's. The 80% unit-price discount shrinks to 40% at the task level, and at standard pricing Argon is actually about 1.2× more expensive than Astra.

The reason lies in token consumption. Argon averages roughly 62k output tokens per task versus Astra's 27k — 2.3× as many. Across the full index, Argon generated 110M output tokens, versus 85M for the median model and 67M for Gemini 3.1 Pro Preview. Artificial Analysis's conclusion: the savings are "driven by lower token prices, not by lower token usage."

Compared to Gemini 3.1 Pro Preview, Argon scores 23 points higher; at promo pricing it costs about 1.5× per task, and at standard pricing about 3×.

Vals AI: Standard Pricing Only

Vals AI ran Argon at the standard $4/$20 rate, with temperature set to 1 and an output cap of 262,144 tokens.

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

Even at standard pricing, Argon's per-test cost on this suite is lower than the three Claude models right behind it in the rankings. But cost climbs steeply on Vals's long-chain 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 is the worst case — the most expensive test among the computer-use benchmarks, and also Argon's weakest showing, ranking 7th among the 8 models Vals ran.

Cross-Reading the Two Datasets

Against GPT-6 Astra, the promo is what drives savings; against Claude, even standard-priced Argon is cheaper. Long-chain agentic runs are where the bill truly balloons: on Vals's agentic benchmarks, per-test cost ranges from $30 to $194, versus just $15.68 on the Vals Index. The two organizations use different task sets and frameworks — don't compare models across organizations; comparisons only make sense within a single evaluator.

Artificial Analysis Intelligence Index is a composite capability benchmark maintained by the independent evaluator Artificial Analysis. It spans math, science, code, reasoning, instruction-following, and other dimensions, normalizing subscores into a single 0–100 index for easy cross-model comparison. Vals AI uses a different methodology, leaning more toward real productized scenarios and agentic tasks, including long-chain benchmarks such as CUA-bench (computer use), Code Migration, Terminal-Bench Science (terminal science tasks), and SRE Bench (site reliability engineering). The two organizations differ in test task sets, scoring methods, and invocation frameworks, so only within-organization comparisons are meaningful; cross-organization comparisons are polluted by task-distribution differences. That's the underlying reason the two figures — $1.99 and $15.68 — seem contradictory but actually don't conflict.

Seven Billing Failure Modes and Fixes

Monthly Cap Hit Early

Cause: Budget was set at $2/$10, but the promo has no announced end date. Once it ends, the same traffic burns through budget twice as fast.

Fix: Budget at $4/$20 from day one and treat the promo as a bonus.

A Single Request Costs $10

Cause: Argon's output ceiling is 1M tokens. An open-ended answer that runs to the cap costs $10 at promo pricing, $20 at standard.

Fix: Set a task-scale-specific output cap on every request. Don't leave a 1M ceiling wide open.

Output Far Exceeds the Visible Answer

Cause: Argon writes a lot — roughly 62k output tokens per task in Artificial Analysis runs, 2.3× GPT-6 Astra's 27k. On the Gemini 3 series, Google also counts "thinking tokens" toward output billing. Argon isn't yet listed on Google's pricing page, so this is worth confirming.

Fix: Fix the thinking level per workflow and budget output tokens for the reasoning process, not just the answer.

Cached Input Billed at Full Price

Cause: According to AIHubMix's Gemini guide, an implicit cache hit requires identical content, model, and parameters, and the repeated context must be placed up front. Switching thinking levels mid-session or reordering prompts between turns sends cached input back to full-price input.

Fix: Put stable context first and keep it byte-identical turn to turn: system prompt, tool definitions, and documents at the top, new user messages last. Don't switch thinking levels mid-session.

Refusals Billed Twice

Cause: Argon refuses more often than other frontier models when uncertain. A refusal still bills its input and thinking tokens, and retrying the same question on Argon costs you again.

Fix: Route refused answers to a human or another model rather than retrying on Argon.

Long Answers Become Multiple Billed Calls

Cause: Long Decode Continuation pauses long answers and resumes them in subsequent calls. How those calls are billed, and whether prior output is re-counted as input, is undocumented.

Fix: No confirmed solution yet. A per-request output cap still constrains each call.

Simple Steps Billed at Frontier Rates

Cause: Every agent step runs on Argon, including extraction and formatting.

Fix: Route by difficulty. Send extraction, classification, and formatting to Gemini 3.8 Flash, and reserve Argon for steps that need deep reasoning. The Gemini 3 series also gets a 50% discount via the Batch API; Argon's batch rate isn't announced yet and will need re-checking when it appears.

Estimate Your Own Costs

The code below puts prices in a dict and passes the standard cached rate as a parameter — because nobody has published it yet. Pure Python, no dependencies. Plug in your own measured token counts.

PRICES = {  # USD per 1M tokens
    "promo": {"input": 2.00, "cached": 0.10, "output": 10.00},
    "standard": {"input": 4.00, "cached": None, "output": 20.00},  # cached rate TBD
}

def task_cost(uncached_in, cached_in, output, tier="promo", cached_rate=None):
    p = PRICES[tier]
    cached = p["cached"] if p["cached"] is not None else cached_rate
    if cached is None:
        raise ValueError("Pass cached_rate: Argon's standard cached price isn't published yet")
    return (uncached_in * p["input"] + cached_in * cached + output * p["output"]) / 1_000_000

Measure real token consumption on Gemini 3.8 Flash or 3.1 Pro Preview first, then feed it into task_cost. Expect Argon to be higher: on the Artificial Analysis index it generated 110M output tokens versus 67M for Gemini 3.1 Pro Preview. Treat the result as a floor, not a forecast.

Still Unknown

• When the promo ends
• Cached input rates under standard pricing, long-context surcharges, Batch and Flex rates, and cache storage fees
• How Long Decode Continuation is billed
• Whether Argon counts thinking tokens toward output billing the way Gemini 3 does
• How many tokens Argon consumes on your own workload

What It Actually Means for Developers

Argon's cost profile is counterintuitive: a cheap unit price doesn't mean cheap tasks. Four variables — output token volume, thinking-token billing, cache hit rate, and retry-on-refusal — affect the final bill far more than the token unit price itself.

While waiting for Argon's pricing information to fill in, running the same workflow on Gemini 3.8 Flash and collecting token data is the pragmatic move. Budget at standard pricing, save with promo pricing, and route each step by cost — that's the cost-control framework you can put into practice today.

Additional Context

None

Long Decode Continuation is a mechanism used by some reasoning models (especially those with long chains of thought or very long output capabilities): when a single answer needs to generate an enormous number of tokens, exceeding the time or context budget of one call, the system pauses the current generation and resumes from the breakpoint in subsequent calls, eventually stitching together the complete answer. From the user's perspective it's one continuous answer, but at the billing layer it may correspond to multiple API calls. If the continuation call sends already-generated output back into the model as input (which is often technically necessary for context reconstruction), then the same content is billed once as output and a second time as input — a hidden double charge. Google hasn't disclosed Argon's specific billing logic under this mechanism, so a per-request output cap remains the only reliable guardrail.

One-line Summary

Gemini 4 Argon starts at $1.99 per task on promo pricing, but heavy token consumption and multiple billing traps can make real costs spike a hundredfold.

Paragraph Summary

Google Gemini 4 Argon lists at a promotional $2/$10, but independent tests from Artificial Analysis and Vals AI show per-task costs ranging from $1.99 to $193.78. The core driver isn't the unit price but token consumption: Argon outputs roughly 62k tokens per task, 2.3× GPT-6 Astra, shrinking an 80% unit-price discount to 40% at the task level. Long-chain agentic benchmarks (like CUA-bench at $193.78) are where bills balloon. The article catalogs seven billing failure modes — monthly caps hit early, a single request burning the 1M output ceiling for $10, thinking-token billing, cache misses, double-billed refusals, long answers spanning multiple calls, and simple steps billed at frontier rates — and gives concrete fixes: budget at standard pricing, route by difficulty, and keep stable context up front.