Gemini 4 Argon (gemini-4-argon) costs $2 per million input tokens and $10 per million output tokens until November 30, 2026, and $4 and $20 from December 1. Thinking tokens bill at the output rate, and implicitly cached input goes from $0.10 to $0.20 per million. Every token your agents send to Argon will cost twice as much in December, so the number to know now is your cost per agent run.
Key takeaways
- An agent run is many calls with a growing context, so one run can cost 20 times a single call.
- Cached input is 95% cheaper than fresh input, which can matter more than the price change.
- Tracium stores cost when a span arrives, so past costs stay as recorded.
What does Gemini 4 Argon cost now, and what changes on December 1?
Every token rate doubles, and Argon has no free tier. Google’s prices, as of October 2026:
| Rate (per 1M tokens) | Until Nov 30, 2026 | From Dec 1, 2026 |
|---|---|---|
| Input | $2.00 | $4.00 |
| Output, including thinking | $10.00 | $20.00 |
| Cached input (implicit caching) | $0.10 | $0.20 |
| Batch input / output | $1.00 / $5.00 | $2.00 / $10.00 |
Source: the Gemini Developer API pricing page and What’s new in Gemini 4 Argon. Argon has no long-context tier and supports only implicit caching.
Why is a model that is cheap per token expensive per task?
Because an agent loops. Each step resends the system prompt, tool definitions and everything so far, then adds a tool result, so input grows with every step, and thinking adds output you never see.
When I traced one feature of Aqtos, our own product, context grew exponentially across calls; fixing that took it from $0.1583 to $0.000099 per agent call.
What does one agent run cost before and after the change?
Here is an illustrative run, not a measured one: 10 model calls, an 8,000-token starting context, 2,500 tokens of tool output added per step, and 600 output tokens per call including thinking.
| Illustrative run (10 calls) | Until Nov 30 | From Dec 1 |
|---|---|---|
| 192,500 input + 6,000 output tokens, no caching | $0.445 | $0.890 |
| Same run, previous call’s context served from cache | $0.137 | $0.274 |
| Per 10,000 runs, no caching | $4,450 | $8,900 |
A single 8,000-token call with 600 output tokens costs $0.022 today; the run costs 20 times that.
How much does cached input change the math?
A lot. Implicit caching bills a repeated prompt prefix at 5% of the input rate; in the example it cuts the run cost by about 70%, more than December adds. Keep stable parts (system prompt, tool definitions) first and append new content at the end, so each call shares a long prefix with the previous one.
How do I measure tokens per run from my own traces?
Instrument the Gemini client with OpenTelemetry and send traces to a backend that groups spans by run. With Tracium:
- Install
opentelemetry-instrumentation-google-genaiand point the OTLP exporter at Tracium (OpenTelemetry setup). - Set
tracium.workflow.versionon your resource. The instrumentation writes the model and token counts on each call’s span, with thinking included in output. - Read cost and tokens per run in the workflow’s versions table (Workflows), and open a trace to see which step grows (Reading a trace).
from google import genai
from opentelemetry.instrumentation.google_genai import GoogleGenAiSdkInstrumentor
GoogleGenAiSdkInstrumentor().instrument() # after your TracerProvider is set up
client = genai.Client()
resp = client.models.generate_content(model="gemini-4-argon", contents="...")If you use OpenLLMetry’s Gemini instrumentation instead, its output count excludes thinking tokens, but it also sends gen_ai.usage.total_tokens. Tracium adds the gap between the total and the other counts to output, which recovers thinking on uncached calls. Gemini’s input count already includes cached tokens, so on cache hits the gap shrinks; for Gemini, prefer the instrumentation above.
What happens to my cost history when the price changes?
In Tracium, each span’s cost is computed once, when the collector receives it, from the price table loaded at startup. Past spans keep the price they were recorded with, so December’s increase will not rewrite October’s numbers.
Tracium’s bundled price table is a LiteLLM snapshot from July 2026 and does not list gemini-4-argon yet. Until it does, Argon spans are stored with their tokens and a cost of $0, and the dashboard’s setup checks flag them as an unpriced model. If you self-host, add the model to the collector’s pricing file now and change it again on December 1:
"gemini-4-argon": {
"input_cost_per_token": 0.000002,
"output_cost_per_token": 0.00001,
"cache_read_input_token_cost": 0.0000001
}[CHECK: when Tracium Cloud’s price table will include gemini-4-argon, and that it switches to $4/$20 on Dec 1]
Should you migrate now, wait, or route by task?
Decide from measured cost per run. If Argon runs are affordable at $4/$20, migrating now buys six weeks at half price. If not, route by task: send only the steps that need Argon’s reasoning to it. Tracium fits if you want per-run, per-model cost self-hosted on OpenTelemetry; for prompt management and evaluations, Langfuse or LangSmith cover more.
FAQ
How much will Gemini 4 Argon cost after December 1, 2026?
$4 per million input tokens and $20 per million output tokens, including thinking tokens. Cached input rises to $0.20 per million, and batch rates to $2 and $10.
Are thinking tokens billed for Gemini 4 Argon?
Yes, at the output rate. Check that your instrumentation counts them, because Gemini reports them separately from the visible output tokens.
Does Gemini 4 Argon have a free tier?
No. Google lists Argon as paid tier only, so every call in development and testing is billed too.
Will a price change rewrite my past cost data in Tracium?
No. Tracium stores each span’s cost when the span arrives, so earlier spans keep the price that applied when they were recorded. New spans use whatever the price table says when they arrive.
You have six weeks to learn your cost per run before Argon doubles. Tracium is open source: run it from the GitHub repo with one docker compose up, or sign up free at app.tracium.ai (pricing).