Gemini 4 Argon Costs $2 Per Million Tokens. Your Real Bill Will Disagree.

Google announced Gemini 4 Argon on September 30, 2026, and the headline wrote itself: a frontier model at $2 per million input tokens and $10 per million output tokens, the same intro rate as models that cost half as much to run at the top end. Right now it sits at the top of Hacker News with hundreds of comments, most of them arguing about benchmarks. Almost nobody is arguing about the part that decides whether you can afford it.

Because the sticker price is not the price. The independent evaluation that has run Argon so far found it uses more than twice as many tokens per task as the model it ties with. At the promotional rate that makes it look cheap. At the standard rate, which Google says is coming and has not dated, the same behavior makes it more expensive than the model it beat.

Nobody outside Google's Fairwind Program for cyber defenders has API access yet, so this is not a review. I have not used it, and neither have you. What follows is the math you should run on any model launch before you rearrange your stack around it, using Argon's real published numbers.

What Google actually announced

Strip away the launch coverage and the verified facts are short:

• Output limit: 1 million tokens, up from 64,000 on earlier Gemini models. Google cites internal code migrations of up to 800,000 lines, including the Fuchsia Zircon kernel, as the target use case.
• Introductory price: $2 input / $10 output per million tokens, with cached input 95 percent off, which works out to $0.10 per million.
• Standard price: $4 input / $20 output once the introductory period ends. Google has not said when that is, and it has not said how reasoning tokens are billed.
• Access: nobody public. The first wave is trusted cyber defenders through the Fairwind Program. As of early October, no API model identifier appeared in Google's model list, Vertex AI catalog, or changelog. There is no general-availability date.
• Context window: not stated by Google. Some outlets report 1 million input tokens because Artificial Analysis lists that figure, but Google's own post only states the output ceiling. Treat the input window as unconfirmed.

That last group of missing details matters more than it looks. You cannot put a model on a budget if you do not know its input window, its reasoning-token billing, or when its price doubles.

The benchmarks, split by who ran them

The launch numbers come in two flavors, and they tell different stories.

Google's own reported scores put Argon first on DeepSWE v1.1 at 77.9 percent, ahead of Claude Opus 5.5 at 74.2 percent and GPT-6 Astra at 74.1 percent. It also leads the Vals Index at 68.9 percent, AutomationBench, and the GraphWalks long-context test at 84.2 percent on million-token inputs. But it loses where the work gets hard: 55.0 percent on FrontierSWE v2, ten and a half points behind GPT-6 Astra, and 57.4 percent on Terminal-Bench 4.0, nine points behind Opus 5.5. No third party had reproduced the Google-reported figures at launch.

The independent picture is narrower. Artificial Analysis ran Argon at high reasoning and scored it 53 on its Intelligence Index, tying GPT-6 Astra's max-context score and one point above GPT-6.1 Sol. Vals AI ran its own index and put Argon first of 41 models at 68.9 percent. So: genuinely frontier, at the top of the pack on overall scores, not a clean sweep, and not better than Opus at terminal-heavy agent work.

That is the honest benchmark summary. Now the part that changes the buying decision.

The 62,000-token problem

Artificial Analysis measured how many tokens each model burned to complete an average Intelligence Index task. Argon generated about 62,000 output tokens per task. GPT-6 Astra generated about 27,000 for the same work.

Same score, more than double the writing.

Run that through the price list and the promo vanishes:

• At introductory rates: 62,000 output tokens cost $0.62, and Artificial Analysis measured $1.99 per task all-in. GPT-6 Astra costs $3.26 per task. Argon looks 39 percent cheaper.
• At standard rates: every Argon rate doubles, so the same task costs $3.98. Astra still costs $3.26. Argon is now 22 percent more expensive for the same score.

The crossover is entirely the promotion. Google is subsidizing the verbosity, and the moment the subsidy ends, the model's habit of thinking out loud becomes your bill. The promotional rate is real and it is a good deal while it lasts. It is just not a durable price advantage, and Google has not told anyone how long it lasts.

There is a second lesson in the Vals data. Vals measured a cost per test of $15.68 for Argon against $21.34 for Claude Sonnet 5.5 and $32.14 for Opus 5.5, the lowest of its group. Different benchmark, different workload mix, opposite cost conclusion. That is not a contradiction. It is proof that cost per task is workload-specific, and any single number someone quotes you is only true for tasks shaped like theirs.

The calculator you should run on every model launch

Per-million-token prices are marketing units. You do not buy tokens, you buy tasks. Here is the whole decision framework in a few lines you can keep in your notes:

def cost_per_task(model, tokens_in, tokens_out):
    # model: (input $/M, output $/M, cached_input $/M, cache_hit_ratio)
    inp, out, cache, hit = model
    fresh_in = tokens_in * (1 - hit)
    return (fresh_in * inp + tokens_in * hit * cache
            + tokens_out * out) / 1_000_000

gemini_argon_intro = (2.0, 10.0, 0.10, 0.8)
gemini_argon_std   = (4.0, 20.0, 0.20, 0.8)
claude_opus_55     = (4.0, 20.0, 0.20, 0.8)
gpt6_astra         = (10.0, 50.0, 1.00, 0.8)

# A realistic agentic coding session: lots of re-sent context, verbose model
task_in, task_out = 600_000, 62_000

for name, m in [("Argon intro", gemini_argon_intro),
                ("Argon standard", gemini_argon_std),
                ("Opus 5.5", claude_opus_55),
                ("GPT-6 Astra", gpt6_astra)]:
    print(name, round(cost_per_task(m, task_in, task_out), 2))

Three habits fall out of this framing:

• Budget on standard rates, always. Google's own footnote doubles the price with no end date. If a model only makes sense at its intro rate, it does not make sense.
• Measure tokens per task, not per token. A model that writes twice as much to reach the same score needs to be half the price to break even. Argon at intro rates clears that bar; at standard rates it does not.
• Weight input heavily and cache aggressively. In agent workloads most input is the same files and instructions re-sent every turn. Argon's 95 percent cache discount is arguably a bigger deal for coding agents than the headline $2 rate.

The 1-million-token output is the real story, and it cuts both ways

The output ceiling jump from 64K to 1 million tokens is the most under-discussed spec of this launch. Google's pitch is that long tasks stop needing chunked, multi-pass workflows: one pass to migrate a kernel, one pass to draft a full report.

The cost side is already covered: a maximal response costs up to $20 at standard output rates. But the risk side is bigger. An agent that emits 800,000 lines in a single pass produces a diff no human reviews line by line. The bottleneck in your pipeline stops being the model's capability and becomes your review capacity. If you adopt a model like this, the engineering work shifts to guardrails: tests that gate the output, incremental delivery instead of one-shot writes, and acceptance criteria the agent has to satisfy before it is allowed to stop writing.

For security-sensitive use, Google claims a reported lead on Gray Swan's prompt-injection robustness test and a conservative streak, preferring to say it does not know rather than guess. That fits the Fairwind-first rollout, where cyber defenders get the model before developers do. But again, these are launch claims, not yet a track record.

What I would actually do

• Wait for a public API identifier. You cannot build against a model you cannot call, and Google has given no date. Anything you design today against unconfirmed specs, like the input window, may need rework.
• Pick your benchmark by workload. If your agents live in terminals, Opus 5.5's independent Terminal-Bench lead still stands. If you feed million-token documents, Argon's GraphWalks number is the most relevant data point anyone has published.
• Prototype pricing with the calculator above using your own token traces from the last month. Your cost per task is knowable before you spend a dollar, and it will not match anyone else's.
• Treat the intro window as a free trial with a deadline you do not know. If Argon reaches general availability at $2/$10, that is the moment to run a real bake-off on your workloads, not before.

The interesting question about Gemini 4 Argon was never whether the benchmarks are good. They are, independently confirmed at the top of the pack. The interesting question is whether a model that thinks in 62,000-token gulps is cheap or expensive, and the honest answer is: at a price Google controls and has not dated. That is not a reason to ignore it. It is a reason to do the math before you commit.

I write about AI infrastructure, model economics, and backend engineering every week. Subscribe, it is free.

Would you switch an agent stack to a model for a promo rate that doubles later? How do you budget model costs today, per token or per task?