Gemini 4 Argon Before the Cache Price Doubles: Developer Review and Cost Checklist

Google has set a countdown on the pricing of its cheapest frontier model. Gemini 4 Argon became generally available on October 13, 2026, priced at $2 per million input tokens and $10 per million output tokens; starting December 1, those rates double to $4/$20. That leaves developers roughly seven weeks of cheap access. The teams that truly benefit aren't the ones who just read the pricing page — they're the ones who build prototypes during the window, measure real per-task costs, and decide before the price doubles whether Argon belongs in their stack.

Key Takeaway: Measure First, Decide Later

Gemini 4 Argon (model ID gemini-4-argon) is Google's new-generation frontier model for deep multi-step tasks. It has been generally available since October 13, 2026, at $2 per million input tokens and $10 per million output tokens. On December 1, 2026, both rates double.

If you're building anything on it, there are just three core actions: validate your prototype before November 30, measure per-task token consumption with "thinking tokens counted as output," and re-run your workload economics at $4/$20 before committing to production.

This assessment comes from cross-verifying multiple independent sources. The pricing information is corroborated across reports from VentureBeat, Reuters, rundown.ai, and datanorth.ai between October 14 and 15. Google's official blog post did not prominently flag the December 1 increase, but multiple outlets reported it as confirmed.

What Actually Happened on October 13

Google announced Gemini 4 Argon on September 30, 2026, but public access was limited to cybersecurity partners in its Fairwind program. On October 13, Koray Kavukcuoglu — Senior Vice President at Google DeepMind and Google's Chief AI Architect — announced the model was "available globally today" through the paid Gemini API, Google AI Studio, Antigravity (for Ultra subscribers), the Gemini app and AI Mode in Search (for Pro and Ultra subscribers), Android Studio, Firebase AI Logic, and Gemini Enterprise. It is not available on the API free tier.

Argon is the first model in the Gemini 4 generation, aimed at long-horizon multi-step tasks in coding, finance, legal, cybersecurity, and science. Its core specs include a unified 1 million token context window (shared across input, thinking, and output), output decoding up to 1 million tokens, and adjustable thinking levels (low, medium, high).

One point of honesty about data sources: the benchmark figures in this article come from two channels. Google's launch claims (Vals Index, ERQA, prompt-injection resistance) are vendor-reported and have not been independently reproduced; scores from Artificial Analysis and Terminal Bench 4 come from independent testing cited by outlets covering the launch.

Pricing Breakdown: Three Levers You Must Understand

All figures below are Gemini API prices in USD per million tokens, before and after the increase:

Tier	Input	Output	Cached Input	From December 1 (Input/Output/Cached)
Standard	$2.00	$10.00	$0.10	$4.00 / $20.00 / $0.20
Batch & Flex	$1.00	$5.00	$0.05	$2.00 / $10.00 / $0.10
Priority	$3.60	$18.00	$0.18	$7.20 / $36.00 / $0.36

Three key points determine the cost structure. First, output costs five times input, and output billing includes thinking tokens — the model's internal reasoning. A reasoning-intensive agent run is billed almost entirely on the output side. Second, cached input gets a 95% discount: repeated system prompts, retrieved context, and conversation history can be billed at $0.10 per million tokens instead of $2. Third, Batch and Flex halve all rates, at the cost of latency flexibility.

A simple example: a workload of 10 million input tokens plus 2 million output tokens costs $40 at launch pricing (10 × $2 + 2 × $10) and $80 at December pricing (10 × $4 + 2 × $20). With fixed tokens, 20,000 uncached input tokens plus 5,000 billed output tokens totals $0.09 before the increase and $0.18 after. Multiply that number by your request volume and you have the answer to whether Argon fits your stack.

What Are Tokens, and Why Are You Billed by Them?

Large language models don't process "text" directly — they process tokens, fragments of text that fall somewhere between characters and words. In English, one token roughly corresponds to 0.75 words; in Chinese, one character often maps to one or two tokens. The API splits text into token sequences before feeding them to the model, and the model generates output token by token, so billing naturally uses tokens as its smallest unit. This also explains two common confusions: why the same passage is "more expensive" in Chinese than English, and why long contexts and long answers accumulate costs quickly. Understanding token granularity is the first step in estimating any workload's cost — you can't budget for a unit you can't see.

What Are Thinking Tokens (Reasoning Tokens)?

Thinking tokens are the tokens a new-generation reasoning model generates internally — reasoning, planning, self-checking — before producing its final answer. They're usually invisible to users or shown only in collapsed form, but for billing purposes they count as output tokens just like the final answer. This is precisely why this article repeatedly stresses that "output is five times input" and "agents are billed almost entirely on the output side": a multi-step reasoning task might return just one sentence to you while burning hundreds or thousands of thinking tokens internally. Adjustable thinking levels (low/medium/high) thus become a direct cost knob — turning it up improves quality on complex tasks and proportionally inflates the bill.

What Is Cached Input?

Cached input is when the model provider temporarily stores context you send repeatedly (system prompts, retrieved documents, conversation history) and bills subsequent requests that hit the cache at a steep discount. Argon's cached input is $0.10 per million tokens — just 5% of the standard $2 input rate, a 95% discount. It's not simply a "discount" but an architectural optimization: it only hits when your request prefix is highly repetitive across calls. For agents with fixed system prompts and RAG retrieval flows, caching often shrinks the actual bill to a fraction of list price; by contrast, workloads that assemble fresh context every time get almost no discount.

What Are the Batch and Flex Tiers?

Batch and Flex are "time-for-money" pricing models: you accept longer queuing and processing latency in exchange for halved rates ($1/$5). Batch targets offline, non-real-time bulk tasks like overnight jobs, large-scale data labeling, or offline evaluation; Flex targets scenarios that are latency-insensitive but still want some interactivity. They stack with cache discounts, making them the two most direct levers for lowering unit costs. The rule of thumb is simple: if users aren't staring at the screen waiting for results, route that task to Batch or Flex.

Real Cost Model for 100,000 Requests per Month

Looking at per-token rates is meaningless until you know your token profile. Here's an annotated customer-support agent model: assume each ticket consumes 2,500 input tokens (the ticket, retrieved documents, system prompt) and 400 output tokens, processing 100,000 tickets per month.

• Per ticket at launch pricing: 2,500 × $2/million + 400 × $10/million = $0.005 + $0.004 = $0.009
• Per ticket from December 1: 2,500 × $4/million + 400 × $20/million = $0.01 + $0.008 = $0.018
• Monthly bill (100,000 tickets): $900 → $1,800

This is what the price increase really looks like: not a single line of code changed, and the bill doubles.

In practice, two factors push this number down: the 95% cached-input discount can substantially compress the 2,500-token portion (if most of it is repeated context), and Batch/Flex pricing halves everything (for tasks that don't need immediate responses). Two factors push it up: thinking tokens are billed as output, so reasoning-intensive agents quickly blow past the 400-token assumption; retries, tool calls, and guardrail loops generate charges for every additional request.

Methodology for Per-Task Cost Accounting

To judge whether Argon fits your stack, you need to build a "token profile" — how much a typical task consumes across three sides: input, cached input, and output (including thinking). The method has four steps: first, pick representative real tasks rather than demo samples; second, log all three token counts per task; third, multiply the counts by the corresponding rates to get per-task cost; finally, multiply by monthly request volume for the monthly bill. The key pitfalls are two: first, omitting thinking tokens, which severely understates the output side; second, ignoring extra requests from retries, tool calls, and guardrail loops, which silently double or more the true cost per task. Only by measuring both do you get a cost model close to production reality.

Where Argon Competes After the Promo Period

The December price isn't arbitrary: it puts Argon exactly level with Claude Opus 5.5 and Meta Muse Wonder. From December 1, the selection criterion becomes task fit, not price.

Model	Input/Million	Output/Million	Positioning
Gemini 4 Argon (before November 30)	$2	$10	Launch price
Claude Sonnet 5.5	$2	$10	Matches Argon launch price
GPT-6.1 Sol	$2	$10	Matches Argon launch price
Gemini 4 Argon (from December 1)	$4	$20	Standard price
Claude Opus 5.5	$4	$20	Matches Argon standard price
Meta Muse Wonder	$4	$20	Matches Argon standard price
GPT-6 Astra	$10	$50	The expensive end of frontier models

Datanorth.ai's analysis nails it: a business case built on $2/$10 has a shelf life of only seven weeks. Any contract, quote, or unit-economics model you sign now must be able to survive $4/$20.

Where Argon is worth keeping: Deep multi-step tasks where the 1 million unified context adds value (repo-scale refactoring, long legal or financial documents, multi-file agent runs); workloads dominated by cached context (the 95% discount keeps the actual bill far below list price); offline tasks that can be batched (Batch and Flex halve all rates); projects that prototype before November 30, pass acceptance criteria at the low price, and still pass at $4/$20.

Where you should route tasks elsewhere: Short one-off tasks that a $0.10/million-input model handles fine (Haiku-class models do classification, extraction, and summarization for a fraction of the cost); output-dominated token profiles (five-times output billing penalizes heavy thinking runs — compare against models with cheaper reasoning first); anything still on the API free tier (Argon isn't on the free tier, and no launch date has been announced); budgets signed on $2/$10 economics that no one re-ran at December costs.

Why Frontier Model Pricing Is Converging

When multiple vendors' frontier models all land at $4/$20, it's not coincidence — it's a signal of competitive convergence: compute costs for training and inference set a price floor, and vendors are reluctant to lose customers by pricing noticeably higher, so standard prices converge. This carries an important strategic implication — price is no longer a differentiator; task fit, cache friendliness, tool ecosystem, and reliability are. For developers, that means "pick the cheapest" stops working in the high-price tier, replaced by controlled comparisons: benchmark quality, retry rates, and actual bills on your own representative workload, and let data — not list price — make the decision.

Benchmarks: A Sober View

Google's claims for Argon are strong: first place on the Vals Index (finance, coding, legal, tax), 87% on the ERQA embodied-reasoning test, only 0.7% success rate for prompt-injection attacks with 15 adaptive attempts in Gray Swan testing, and the lowest benchmark-cheating rate among all Gemini models at 2%. Google also cites internal engineering results: a 6-million-line Chromium refactor completed in weeks, and agent code commits in Antigravity up 35% while rollbacks dropped by a third. These are all vendor figures and should be treated as directional only.

Independent data is more sober. Argon scores 53 on the Artificial Analysis Intelligence Index — level with GPT-6 Astra and Claude Fable 5.1, behind Claude Opus 5.5's 58 and Sonnet 5.5's 56. On Terminal Bench 4 it scores 57%, behind Sonnet 5.5's 64%, Opus 5.5's 60%, and Astra's 59%. These scores don't mean "stay away from Argon" — they mean it's a genuine frontier contender that hasn't yet proven an advantage over rivals. That's exactly why the launch price exists, and exactly why you should test your own tasks rather than trust any leaderboard.

Build-and-Measure Checklist (Complete Before November 30)

Here's a framework to execute in order. Finish it before November 30 and you'll enter December knowing exactly what Argon costs you — not guessing.

1. Confirm Your Access Path and Billing Surface

Decide where you'll run Argon: the paid Gemini API in AI Studio, or through GitHub Copilot (billed in AI credits at the provider's list price, 1 credit = $0.01). The Copilot page labels its rates as promotional until December 1 but doesn't say what happens after. Don't assume Copilot follows Google's schedule — budget for a possible increase on both surfaces.

2. Lock In Baseline Numbers Today

Write down the model you currently run, its price, and your best estimate of monthly input/output tokens. Without a baseline, launch pricing feels cheap and December pricing feels expensive — neither feeling is data.

3. Build a Per-Task Token Log

From day one, record input, cached input, and output tokens per task. If the API exposes it, split output into thinking and final answer, because thinking tokens are billed as output and that's where agents' hidden costs live. You can't optimize what you can't measure.

4. Prototype at Launch Price Before November 30

This is what the seven-week window is for. Build the representative workflow — the one with real retries, real tool calls, realistic context sizes — and run it at production scale at $2/$10. A benchmark demo is not a measurement.

5. Run the Same Workload at December Rates

Re-price the token profile from step 4 at $4/$20. If the December bill still beats your baseline model at equivalent quality, commit. If it only works at launch pricing, your business case expires on November 30 — decide now, not in January.

6. Pull the Three Cost Levers

First, caching: put repeated system prompts and retrieved context into the 95%-discount cache layer. Second, batching: move background agents to Batch or Flex for halved rates. Third, compression: shrink prompts, cap thinking levels (low/medium/high are adjustable), and watch the thinking-token line — it's billed at output rates.

7. Benchmark Two Alternatives on Your Own Tasks, Not Leaderboards

Run your representative workload on at least one cheaper option (Sonnet 5.5 or GPT-6.1 Sol at $2/$10); if quality is the key question, also run it on Opus 5.5 at $4/$20. Record errors, retries, review time, and total billed usage. From December 1, Argon and Opus cost exactly the same — buy the one that does the job best.

8. Set Budget Alerts and a November 29 Decision Day

Set spending alerts on your projects now, and put a calendar reminder on November 29. That slot is your decision meeting: keep Argon, migrate the workload, or renegotiate. The teams hurt by the increase are the ones that never scheduled a decision.

Why You Must Prototype Instead of Reading Leaderboards

Leaderboards measure average performance on standardized benchmarks, while your workload has a unique prompt structure, context length, toolchain, and failure modes. A model a few points behind on Terminal Bench might be cheaper on your specific task because of higher cache hit rates or more frugal thinking tokens — and vice versa. So the correct meaning of "benchmarking" on your own tasks is: run real workflows at production-scale token profiles, record error rates, retry counts, human review time, and total billed usage, then convert that into per-task cost and monthly bill. Only this kind of end-to-end self-testing can give you a credible "stay or migrate" answer before the price doubles.

FAQ

What is Gemini 4 Argon, and when did it launch?

Gemini 4 Argon is the first model in Google's Gemini 4 generation, aimed at deep multi-step work in coding, finance, legal, and science. Google announced it on September 30, 2026 (limited to Fairwind program cybersecurity partners) and made it generally available on October 13. The API model ID is gemini-4-argon.

How much does Gemini 4 Argon cost?

As of November 30, 2026, standard API rates are $2 per million input tokens and $10 per million output tokens, with cached input discounted 95% to $0.10. From December 1, these double to $4/$20, with cached input at $0.20. Output billing includes thinking tokens, and the model is not on the API free tier.

Why does the price double on December 1?

$2/$10 is a launch promotional price. Reuters and VentureBeat reported that Google confirmed the increase; from December 1, Argon matches Claude Opus 5.5 at $4/$20. This gives developers a seven-week evaluation window.

Is Argon better than Claude Opus 5.5 or GPT-6?

Google's self-reported data includes first place on the Vals Index and 87% on ERQA, but independent scores are more sober: 53 on the Artificial Analysis Intelligence Index and 57% on Terminal Bench 4, behind Sonnet 5.5, Opus 5.5, and GPT-6 Astra. From December 1, Argon and Opus 5.5 cost exactly the same, so the choice depends on which model fits your work best — not on price.

How do I measure real per-task cost before the increase?

Log tokens per task, billing input, cached input, and output separately (thinking tokens count as output). Prototype before November 30 so the baseline is measured at launch price, then re-price the same workload at December rates. Use Batch or Flex for background tasks, take advantage of the 95% cached-input discount, and set a November 29 decision day.