Andy Garcia · freelance dev
FRENES
Back to the blog
AI & Pricing

Google's Gemini 4 Argon Launched at $2 and $10 per Million Tokens. On December 1, Its Price Card Doubles to Match Claude Opus 5.5

October 19, 2026 6 min read

On Tuesday, October 13, Google made Gemini 4 Argon generally available. Developers can call it through the paid tier of the Gemini API, Google AI Ultra subscribers get it in Antigravity, and Ultra and Pro subscribers get it in the Gemini app. Google had introduced the model on September 30, with early access for trusted cyber defenders in its Fairwind Program, as TechRepublic reported. October 13 is when any developer on the paid API tier could start using it.

And paying is the story. Argon launched at an introductory price of $2 per million input tokens and $10 per million output tokens, with cached input 95 percent off. That price holds through November 30. On December 1, it becomes $4 and $20.

I am CTO of a LegalTech built on Claude, and I built BidForge, an AI that reads French public tender files for small businesses. So I read a rival provider's launch the way a buyer reads a quote: price page first, migration guide second, benchmarks last. Here is what I found.

The price card, line by line

Google's pricing page lists Argon per million tokens:

  • Standard: $2 input, $10 output, $0.10 cached input through November 30. From December 1: $4, $20 and $0.20.
  • Batch and Flex: $1 and $5 through November 30, then $2 and $10.
  • Priority: $3.60 and $18, then $7.20 and $36.

Output includes thinking tokens. The Argon section lists no surcharge for long prompts and no storage fee for the cache. And Argon is not available on the free tier at all. Earlier in October I wrote about Google cutting free Gemini app accounts down to Flash-Lite. Its new flagship skips the free API tier entirely.

Seven weeks at Sonnet prices, then Opus prices

Put that next to the competitors' price pages, read on October 19.

Claude Sonnet 5.5 is $2 input and $10 output, with cache hits at $0.10 since Anthropic halved them on October 7. GPT-6.1 Sol is $2 and $10 up to 272K input tokens, with cached input at $0.10. Argon's introductory card matches both, to the cent, on all three lines.

From December 1, Argon's card reads $4, $20 and $0.20. That is Claude Opus 5.5's card: $4 input, $20 output, $0.20 cache hits.

There is one more comparison, on Google's own page. Gemini 3.1 Pro Preview, still listed there, costs $2 input and $12 output for prompts up to 200,000 tokens. Until November 30, the new flagship's output is cheaper than the older Pro model's.

Now a concrete call, the kind a tender reader makes: 100,000 tokens in, 10,000 tokens out, thinking included.

Without caching, that is 100,000 × $2 / 1M = $0.20, plus 10,000 × $10 / 1M = $0.10. Total $0.30 through November 30, and $0.60 from December 1.

Now say 90,000 of those input tokens are the same tender file, asked a second question. Through November 30: 90,000 × $0.10 / 1M = $0.009 for the cached part, 10,000 × $2 / 1M = $0.02 for the fresh part, $0.10 for the output. Total $0.129. From December 1: $0.018 + $0.04 + $0.20 = $0.258. A thousand of those calls a month goes from $129 to $258.

Two things fall out of that. Once the cache works, output is more than three quarters of the bill. And of the $0.129 the call gains on December 1, $0.10 comes from the output line.

The caching line in the migration guide

Google's migration guide says it plainly: explicit context caching is not supported on Gemini 4 Argon. Code that creates or references cached content has to go. What remains is implicit caching, on by default for prompts of at least 4,096 tokens, with the 95 percent discount on cache hits.

Implicit caching has a real upside: no write fee, no storage fee, nothing to configure. But Google's caching page only offers ways "to increase the chance" of a hit: put large, common content at the beginning of the prompt, send requests with a similar prefix close together. A chance is not a contract. On Claude, a five-minute cache write costs 1.25 times the input price, and the prefix is then cached for those five minutes. On Argon, the $0.129 call above becomes $0.30 when the cache misses, and $0.60 from December.

So a cost model for Argon needs a hit rate, and the hit rate has to come from production logs. The Interactions API reports cache hits in the usage object, as total_cached_tokens (cached_content_token_count on the GenerateContent API). That is the field I would chart first.

Thinking is billed as output, and Argon thinks more

Google's guide says Argon "can spend more of the limit on thinking than earlier models" and tells apps with an output limit below 32K to raise max_output_tokens to at least 32,768. To use fewer tokens, it says, lower the thinking level instead: low, medium or high, with medium as the default.

Then there is long decode, the feature behind the 1M figure. Input, thinking and output share one window of 1,048,576 tokens. A response longer than 64K tokens is generated in hops of up to 64K, and each hop sends the prompt plus everything generated so far back to the model as input. On the Interactions API, Google's servers run the hops in background mode. On the GenerateContent API, the SDK or your own loop runs them. Google's own example: a 1,000-token prompt that produces 200,000 tokens of thinking and output takes four hops and reports 397,216 input tokens, for a real context of about 201,000. You pay for every token in every hop, including hops that contain only thinking. On the Interactions API, a cancelled or failed run also bills all the work done before it ends.

The output on that example costs $2 through November 30 and $4 after. Google says the repeated input is discounted 95 percent by implicit caching, so input stays far below output. The trap is elsewhere: an agent framework that reads total_input_tokens (prompt_token_count on GenerateContent) will believe the context is about twice as full as it is. Google lists early context compaction in its own troubleshooting table.

Where the long answers are stored

Background mode needs storage. The long decode guide says background execution requires store: true. How long Google keeps the interaction depends on which page you read. The background execution guide says 7 days. The Interactions API page says 55 days by default on the paid tier, adjustable to 7, 14, 28 or 55 days in AI Studio, with deletion by interaction ID at any time.

The other route stores nothing. On the GenerateContent API, an encrypted continuation token carries the model's state from one hop to the next, "so nothing is stored on the server," according to Google's guide for that API.

In legal work, how long a provider keeps a client document is a question the client's contract answers, not the developer. One route, two pages, two numbers; the other route, no storage on the server. I would choose the route, and get the retention answer in writing, before sending a single real file through long decode.

The claims I would not budget on

Google says Argon ranks first on the Vals Index, scores 87 percent on the ERQA embodied reasoning benchmark, and holds attack success to 0.7 percent across 15 adaptive attempts on Gray Swan's indirect prompt injection benchmark. These are Google's numbers. The last one matters to anything that reads documents written by someone else, which is exactly what a tender reader does. It is still a measure of someone else's attacks on someone else's documents. I would run my own files and my own injection tests before relying on it.

What I would do before December 1

Build the cost model at December prices. The introductory price is a discount on your evaluation, not your baseline.

Log input, cached, output and thought tokens per feature from the first call. The cache hit rate and the thinking share are the two numbers that decide the bill.

Run your evals at all three thinking levels, as Google itself recommends, and keep the lowest level that passes.

Move anything that can wait to Batch. From December 1, Batch costs $2 and $10, the introductory Standard price.

Treat the migration as configuration, not code: new model ID, no cached content calls, temperature, top_p and top_k removed (Argon ignores them), client timeouts of at least 15 minutes.

And pick the long decode route before the first run, not after: client-side continuation on GenerateContent if nothing should stay on Google's servers, or background mode with the AI Studio retention window set first.

An introductory price is a sample, not a quote. The window runs to November 30: long enough to measure what Argon costs on your own traffic, and short enough to forget the date. Put December 1 in the calendar.

Sources

A project like this one?

I design and deploy products like this. Let's talk.

Let's talk