Gemini 4 Argon: Specs, Pricing, Migration Changes and How to Read Google's Benchmarks

Gemini 4 Argon is Google's current flagship model, listed in the Gemini API as gemini-4-argon and announced as generally available on 2026-10-13.^[6] Google describes it as built for complex software engineering, mathematical and scientific problem solving, autonomous multi-step agents and long outputs of up to 1M tokens.^[2] This Model Watch reads Google's announcement, model card and developer documentation to answer what decides adoption: what it costs and when that changes, what breaks when you migrate, and what the benchmark table does and does not show.

All facts below come from Google's pages, read on 2026-10-21. We did not run the model, so nothing here is our own testing; where we calculate or interpret, we say so. Prices and limits change, so confirm them on the linked pages before budgeting. For how the earlier generation compared with other vendors, see GPT-6.1 Sol vs Claude Sonnet 5.5 vs Gemini: API specs and pricing compared.

Quick answer

• What it is: a reasoning model with a 1,048,576-token window shared by input, thinking and output, accepting text, image, video, audio and PDF and producing text.^[2]
• What it costs: $2 input and $10 output per million tokens through 2026-11-30, then $4 and $20.^[3]
• The catch on migration: explicit caching is not supported and sampling parameters are ignored.^[4]
• The catch on benchmarks: the numbers are Google's, from a table whose settings are not given on the page.^[5]
• Where it fits: long-context, agentic and multimodal work worth evaluating now; budget at the December price, not the introductory one.

Specifications

Function calling, structured outputs, code execution, file search, URL context, Search and Maps grounding and the Batch, Flex and Priority tiers are listed as supported. Computer use is marked Preview.^[2] The model page does not state a knowledge cutoff or deprecation date; the cutoff above comes from the model card.

Pricing, and the date that matters

Google lists an introductory price that ends on 2026-11-30.^[3] Google's announcement says the higher rate applies to the public-access model.^[1]

Output includes thinking tokens. Cached input on Standard is $0.10, rising to $0.20.^[3] The Argon section lists flat prices with no separate long-prompt tier and no cache storage fee. Google's previous-generation Pro model on the same page, Gemini 3.1 Pro Preview, charges $2 input and $12 output up to 200,000 prompt tokens and $4 and $18 above that, plus $4.50 per million cached tokens per hour of storage.^[3]

Worked examples (our arithmetic, from the listed prices)

Output is billed at the listed rate including thinking, so we count thinking inside the output figure.

Sonnet 5.5 is shown at the $2 and $10 per million rates in Anthropic's launch table;^[7] check that page for any long-prompt terms before comparing seriously. The interpretation is ours: at the introductory price Argon costs the same as Sonnet 5.5 on these examples; from December it costs twice as much, and for very long prompts it lands about where Gemini 3.1 Pro's long-prompt tier already was. Whether that is good value depends on whether the extra capability shows up on your task, which only your own evaluation can settle. Our companion piece on model routing and cascades covers how to decide.

What breaks when you migrate

Google's migration checklist is short but contains two breaking items.^[4]

1. Explicit caching is gone. Calls using cachedContents, caches.create or cached_content must be removed. Implicit caching is on by default for prompts of at least 4,096 tokens, with a 95% discount on cache hits.
2. Sampling parameters are ignored. temperature, top_p and top_k are accepted but have no effect. Code that relied on temperature for determinism or variety will behave differently from what its config suggests.
3. Raise output limits. Google recommends at least 32,768 for any limit below that, because max_output_tokens is a hard cap covering thinking and answer together and Argon can spend more of it on thinking than earlier models.
4. Pick a thinking level deliberately. Google's advice is to run evaluations at all three levels and choose the lowest one that meets your quality bar. To cut token use, lower the level rather than the output limit.
5. Long outputs need background mode. Above 64K tokens, set background: true and max_output_tokens above 65,536; the model generates in hops of up to 64K tokens and you join the text from every model_output step. Without max_output_tokens, a background call stops at 64K.
6. Plan for time. Use background execution or set HTTP timeouts to at least 15 minutes.

The practical trade-off: a team with a large cached-context workload loses the explicit cache control it built, and in exchange gets automatic discounts it cannot tune. Check your cache hit rate on a sample before assuming the 95% figure applies.

Reading the benchmark table

Google's model card compares Argon with GPT-6 Astra, Claude Fable 5.1 and Claude Opus 5.5 across 19 rows, labelled vendor-reported.^[5] Counting from that table, Argon is highest on 13 rows, lower on five and tied on one (CWE-bench v1, 68.0% for both Argon and GPT-6 Astra).

The five rows where Argon trails are FrontierSWE v2, Terminal-bench 4.0, PostTrainBench, Terminal-Bench Science 0.1 and OSWorld-2.0.^[5] Our reading, not Google's:

• The broad index lead is narrow. On the Vals Index Argon is 1.9 points above Opus 5.5. Without the benchmark's variance or run count, we cannot say whether that is distinguishable from noise.
• The long-context result is the largest gap. On GraphWalks at 256k to 1M tokens Argon scores 84.2% against 71.8% for the next model in the table. That is the row most relevant to the 1M window, though a graph-traversal task does not stand in for your documents. See long context windows: capacity is not reliability.
• Agentic coding is mixed. Argon leads DeepSWE and Vibe Code Bench but trails on FrontierSWE v2 and Terminal-bench 4.0, so the coding label depends on which benchmark resembles your work.
• The page does not state settings. Thinking level, tool access, number of runs and the model versions of competitors are not given on the card, so the rows are not like-for-like by construction. Our guide to reading a benchmark claim lists what to ask.

Google's announcement adds further company-reported results, such as a 0.7% attack success rate on a Gray Swan indirect prompt-injection benchmark across 15 adaptive attempts.^[1] The post gives these as Google's figures, so treat the same caveats as above.

Safety and access

Under its Frontier Safety Framework, Google reports it cannot rule out reaching the biological or cybersecurity critical capability levels, and that its safety cases assess the risk as below those levels.^[5] A separate version without cyber guardrails is available to approved defenders through the Fairwind Program.^[1] The announcement also says the model is trained to pause for human confirmation before irreversible steps; the model card lists occasional slowness or timeouts and possible hallucinations among known limitations.^[1][5]

Which jobs to test it on first

• Long-document and multimodal analysis: the 1M window and the long-context row justify a trial; measure recall on your own files.
• Agentic and coding workloads: run your own tasks at medium and high; the vendor table does not settle it.
• High-volume simple work: probably not the right tier at $4 and $20 per million. A smaller model and a router will usually be cheaper; test before assuming.
• Cache-heavy pipelines: rework the caching design first, because explicit caching is unavailable.

What remains uncertain

We have not read independent evaluations of Argon, so every performance figure here is Google's. The model page states no deprecation timeline. We will update this article with a dated changelog line as these pages change.