The Price Gap Between gemini-4-argon and 3.8 Flash Widens to 5.3x for One Month: December

I was looking at the pricing table, trying to decide whether to try gemini-4-argon. Input is $2 per million tokens and output is $10. The gemini-3.8-flash I use every day is $0.75 for input and $3.75 for output. Do the division and both come out to 2.67x. "I could probably afford that, if the quality is there," I thought, and nearly moved on.

Then I reread the date column and stopped. Argon's price doubles on December 1. The Flash introductory price does not end until January 1, a month later. The two dates are offset.

Two offset price changes open a gap for exactly one month

Here are the unit prices from the Gemini API pricing page (Standard, paid tier, per million tokens).

In December only, Argon is on its new price while Flash is still on its introductory price. Both input and output open up to 5.33x. When Flash catches up in January, the ratio returns to 2.67x.

So the rule of thumb "Argon costs 2.67x more than Flash" only holds for November and for January onward. The gap is not constant; it peaks in December. That is the reading I took from the table.

A small script that lines up the monthly cost

A ratio alone does not show my own bill, so I wrote a script that takes monthly token volumes and prints the cost for all three months. It runs on the standard library only.

"""Line up Argon vs 3.8 Flash monthly cost across the price-change months."""
from datetime import date
 
# USD per 1M tokens. Standard paid tier on ai.google.dev/gemini-api/docs/pricing (checked 2026-10-25)
# (effective from, input, cached input, output [thinking included])
PRICES = {
    "gemini-4-argon": [
        (date(2026, 1, 1), 2.00, 0.10, 10.00),   # through 11/30
        (date(2026, 12, 1), 4.00, 0.20, 20.00),  # from 12/1
    ],
    "gemini-3.8-flash": [
        (date(2026, 1, 1), 0.75, 0.075, 3.75),   # through 12/31
        (date(2027, 1, 1), 1.50, 0.15, 7.50),    # from 1/1
    ],
}
 
def price_on(model: str, day: date):
    current = None
    for start, *p in PRICES[model]:
        if day >= start:
            current = p
    return current
 
def monthly_cost(model, day, input_m, cached_share, output_m):
    inp, cached, out = price_on(model, day)
    fresh = input_m * (1 - cached_share)
    return fresh * inp + input_m * cached_share * cached + output_m * out
 
# Assumed monthly volume (millions of tokens). Replace with numbers from your own logs
INPUT_M = 20.0
OUTPUT_M_FLASH = 4.0
ARGON_OUTPUT_FACTOR = 1.0   # use 1.5 or 2.0 if Argon's thinking inflates output
CACHED_SHARE = 0.0          # share of input that hits implicit caching
 
print(f"{'month':<8}{'Argon':>10}{'3.8 Flash':>12}{'ratio':>8}")
for y, m in [(2026, 11), (2026, 12), (2027, 1)]:
    d = date(y, m, 1)
    a = monthly_cost("gemini-4-argon", d, INPUT_M, CACHED_SHARE, OUTPUT_M_FLASH * ARGON_OUTPUT_FACTOR)
    f = monthly_cost("gemini-3.8-flash", d, INPUT_M, CACHED_SHARE, OUTPUT_M_FLASH)
    print(f"{y}-{m:02d}  {a:>9.2f}  {f:>11.2f}  {a / f:>6.2f}x")

I keep prices as a dated list and let price_on pick the row in effect, so the next price change is one added row. Burying unit prices inside a formula means finding out from an invoice after the date has passed.

With an assumed 20 million input tokens and 4 million Flash output tokens per month, it prints this.

month         Argon   3.8 Flash     ratio
2026-11      80.00       30.00    2.67x
2026-12     160.00       30.00    5.33x
2027-01     160.00       60.00    2.67x

With identical usage, Argon in December costs $160, double November. Flash stays at $30, so the gap grows from $50 in November to $130 in December. Those dollar figures come from an assumed volume, but the shape of the ratios does not depend on volume.

How thinking tokens and caching move the ratio

Argon's output price includes thinking. If it spends more thinking tokens than Flash on the same prompt, the output volume itself grows. Setting ARGON_OUTPUT_FACTOR to 1.5 lifts the ratio to 3.33x in November, 6.67x in December, and 3.33x in January.

Going the other way, a high cache-hit share lowers the ratio a little. With 60% of input hitting the cache (CACHED_SHARE = 0.6), I got 2.61x, 5.22x, and 2.61x. Argon's cached input is 5% of its normal input price, yet in an output-heavy workload the input discount barely moves the ratio.

Neither set of numbers comes from running Argon myself. The value for ARGON_OUTPUT_FACTOR has to come from your own call logs. Guess it, and the table becomes decoration.

Decide when to compare while it is still November

Here is how I decided to proceed, given the shape of this pricing.

• Finish the Argon-versus-Flash trial on one fixed question set within November. Both models are on introductory prices, so the gap is at its smallest (2.67x)
• In the trial, record output tokens (thinking included) next to answer quality, and use that as the measured ARGON_OUTPUT_FACTOR
• If Argon goes into production in December, put the 5.33x starting gap into the decision from the beginning
• Whether to keep Argon in January and later depends on whether the quality difference justifies a steady 2.67x

For writing an estimate that crosses Flash's own price change, see 値上げの日をまたぐ費用の見積もりを、はじめから二段で書く (Japanese). The checklist for finding what to remove from your code before switching is in gemini-4-argon へ model を替える前に、自分のコードから消すものを探します (Japanese).

Pricing pages do change, so the figures here are what I confirmed on October 25, 2026. Edit PRICES in the script and you can keep using it.

One sentence to take away: read the ratio by which month it is, not only by how many times. If you finish comparing before December 1, that month's invoice will not surprise you.