Gemini 4 Argon Developer Guide: Pricing, Migration, and Benchmarks Compared

Google's new flagship reasoning model, Gemini 4 Argon, is now available to developers. In the paid Gemini API, the model is identified as gemini-4-argon. For the previous two weeks it was limited to cybersecurity experts through the Fairwind program. This article covers the pricing changes, benchmark data, and API migration points, and honestly labels which data comes from Google's own claims and which comes from independent third-party evaluations.

Key Points at a Glance

• The model is priced in the paid Gemini API at $2 per million input tokens and $10 per million output tokens until November 30; from December 1 it doubles to $4 and $20.
• Artificial Analysis measured it tied with GPT-6 Astra on the Intelligence Index (53 points), with a hallucination rate of just 15%, far below GPT-6 Astra's 51% and GPT-6.1 Sol's 54%.
• Output is extremely long: according to that organization, an average of 62,000 tokens per task, more than double GPT-6 Astra's 27,000.
• Migration has costs: temperature and thinking_budget no longer work, explicit cache calls throw errors, and Google recommends an HTTP timeout of at least 20 minutes.
• There is no free tier for the API, and interactive rate limits are undisclosed.

Model Positioning and Release Timeline

Gemini 4 Argon is Google's flagship reasoning model, rolled out in two phases. On September 30, Google's chief AI architect Koray Kavukcuoglu positioned it as a model for "real-world code, enterprise intellectual work, and cyber defense," initially available only to trusted defenders through the Fairwind program.

A broader release followed. On October 13, the paid Gemini API opened through Google AI Studio and Android Studio, and Google AI Ultra subscribers gained access in AI Studio and Google Antigravity. The same day, the Gemini app opened to Google AI Pro and Ultra subscribers, and Google Cloud was connected on October 14. From December 1 it fully transitions to standard pricing.

Official specs show: input supports text, images, video, audio, and PDF; output is text only; the unified window of 1,048,576 tokens is shared between input and output. The model card sets the knowledge cutoff at March 2026.

Target Use Cases Google Set for It

Google is aiming at multi-step, long-horizon tasks. The developer blog post mentions "long-horizon workflows," "including code migration and frontier research." Four recurring use cases stand out:

Code migration. Google claims Argon agents internally converted C and C++ to Rust, migrating more than 800,000 lines of the Fuchsia Zircon kernel. This is an internal report, not a public test.

Ultra-long output. According to the same blog, the output ceiling was raised from a previous "64K" to one million tokens, but Google did not specify which model it was comparing against. For reference, the spec page for Gemini 3.1 Pro Preview shows an output limit of 65,536 tokens.

Defensive cybersecurity. The model card notes that Google "cannot rule out" that Argon reaches a critical threshold for cyber capabilities, and that safeguards have been deployed.

Agentic capabilities. The spec page lists function calling, code execution, Google Search grounding, and computer use (preview).

Pricing: Pay Close Attention to December 1

The price doubling is the most important fact in this article. The Gemini API pricing page shows two columns: before November 30 and from December 1.

Per million tokens	Through Nov 30	From Dec 1
Input (standard)	$2.00	$4.00
Output (standard)	$10.00	$20.00
Context caching (implicit)	$0.10	$0.20
Input (batch)	$1.00	$2.00
Output (batch)	$5.00	$10.00

Three details significantly change budget estimates:

No free tier. The model guide explicitly states that Argon is not available on the free tier or Google AI Pro. Developers who want to test with zero budget need to look elsewhere.

Implicit caching only. The pricing page notes on the caching line: "implicit caching only (explicit caching not supported)." The $0.10 rate applies only to implicit caching; developers cannot create their own caches.

The model is verbose. Artificial Analysis recorded an average output of 62,000 tokens per task, versus 27,000 for GPT-6 Astra. Output is precisely the most expensive line.

Take a mid-sized application: consuming 50 million input tokens and 10 million output tokens per month costs $100 + $100 = $200 at the launch price; from December 1 it becomes $200 + $200 = $400. This calculation does not account for caching and batch processing.

Artificial Analysis also calculated cost per task by Intelligence Index: Argon at $1.99 at the launch price, GPT-6 Astra at $3.26, about 61% lower (the organization rounds to 60%). After the promotion ends, it predicts $3.98 per task, about 1.2x GPT-6 Astra.

A budget built on October prices covers only half of December's per-token price. Start budgeting at standard pricing now.

Independent Evaluations: Who Measured What

In the tests cited in this article, Gemini 4 Argon is either first or tied for first, except for second place on Vals AI's CyberBench. But these results come from three different kinds of sources: Google, Artificial Analysis, and Vals AI. Note the naming differences: GPT-6 Sol and GPT-6.1 Sol are two different OpenAI models, and the sources tested different things.

Google's own data. The September 30 blog claims 77.9% on DeepSWE v1.1 (long-task software engineering test), 91.7% on LVBench (long-video understanding), and first place at 51.3% on Zapier's AutomationBench. Methodology was not disclosed in detail.

The most-cited safety number is 68% on CWE-bench v1, which Google calls a tie for first. That test was designed by Collinear AI and includes 120 vulnerability-fixing tasks across open-source repositories, covering six language families. Task success is determined by automatic verification confirming the vulnerability is no longer exploitable and the code still works. However, no record of Argon is found on Artificial Analysis's CWE-Bench-AA page: the 68% remains a Google-only figure.

Artificial Analysis's measurements. With Argon using high reasoning settings and OpenAI models using maximum ("max") settings, Argon scored 53 on that independent organization's Intelligence Index, tied with GPT-6 Astra and one point ahead of GPT-6.1 Sol. On the AA-Omniscience hallucination test, its hallucination rate was 15%, the lowest among all models scoring above 45 on the Intelligence Index, compared to GPT-6 Astra's 51% and GPT-6.1 Sol's 54%. These measurements were taken before the public release.

Vals AI's measurements. Argon ranked first among 41 models with a Vals Index of 68.90%, ahead of Claude Sonnet 5.5 (67.04%) and Claude Opus 5.5 (66.97%). It ranked second on CyberBench at 77.86%, just behind GPT-6 Sol (note: not GPT-6.1 Sol) at 77.98%.

Both third parties place Argon at or near the top, with clear progress on hallucination control. But ultimately you should validate with your own data.

Python Calls and Migration Pitfalls

Calling is similar to previous Gemini models, but several parameters have changed. Google's minimal example uses the identifier gemini-4-argon (no suffix), and the google-genai SDK requires version 2.30.1 or later.

pip install -U "google-genai>=2.30.1"

from google import genai
from google.genai import types


**The difference between implicit and explicit caching** deserves a separate note, because it is mentioned repeatedly in the text without explanation. Explicit caching (the `cachedContents` API) lets developers proactively write a fixed block of context (for example, a long document, codebase, or system prompt) into the cache and reuse it across multiple requests, with the hit portion billed at the cache rate, and with explicit creation and expiration times. Implicit caching, by contrast, is automatically identified by the model side, which reuses repeated portions of the request prefix; developers cannot control what gets cached or query cache hit status. Argon supports only implicit caching, meaning teams cannot do explicit prewarming for stable long contexts as with previous generations. Cost savings from long system prompts become more uncertain, and you must rely on a stable request prefix to get the $0.20 cache rate.

**The mechanics of automatic_continuation** are also easy to misunderstand. When a single response reaches the output limit, the SDK by default automatically issues a continuation request and stitches the generated content back into the result. What developers see is continuous text, but underneath multiple billed calls have occurred. This differs from explicit pagination: continuation is handled internally by the SDK, and callers should note that `max_output_tokens` counts both the thinking process and the final answer, so setting the limit too high lets the thinking phase consume a large number of tokens while producing very little visible text. The difference between the streaming and non-streaming limits of 65,536 and 32,768 also stems from this: in streaming mode the SDK can stitch continuation fragments more efficiently.
# Read GEMINI_API_KEY; 20-minute timeout (milliseconds)
client = genai.Client(http_options=types.HttpOptions(timeout=1_200_000))

response = client.models.generate_content(
    model="gemini-4-argon",
    contents="Write a Python function to validate an IBAN account.",
    config=types.GenerateContentConfig(
        max_output_tokens=32768,
        thinking_config=types.ThinkingConfig(thinking_level="medium"),
    ),
)

print(response.text)

The following migration items need close attention:

• Sampling parameters. Remove temperature, top_p, top_k, and candidate_count; they are ignored.
• Thinking config. thinking_budget is replaced by thinking_level, with options low, medium, and high; default is medium.
• Explicit caching. Calling cachedContents or caches.create returns an error.
• Thinking signatures. In multi-turn conversations, the full history must be passed back, including signatures.
• Timeout settings. At least 20 minutes per HTTP call.

Long output has its own mechanism: streaming requests return up to 65,536 tokens, non-streaming requests 32,768. This is why the example above limits output to 32,768, while Google's official example requests 65,536. When the limit is exceeded, the SDK automatically continues (automatic_continuation, enabled by default), and max_output_tokens counts both the thinking process and the final answer.

This migration is real engineering work, not just changing the model name.

Side-by-Side Comparison with GPT-6 and Claude

At launch pricing, Gemini 4 Argon's per-token price is the same as GPT-6 Sol, GPT-6.1 Sol, and Claude Sonnet 5.5; at standard pricing it aligns with Claude Opus 5.5.

Model	Input	Output	Context	Max output
Gemini 4 Argon (before 11/30)	$2.00	$10.00	1,048,576	Google claims up to 1,048,576 (Vals AI shows 262,000)
Gemini 4 Argon (from 12/1)	$4.00	$20.00	Same	Same
GPT-6 Luna	$0.10	$0.50	1,050,000	128,000
GPT-6 Sol	$2.00	$10.00	1,050,000	128,000
GPT-6 Astra	$10.00	$50.00	Not listed	Not listed
Claude Sonnet 5.5	$2.00	$10.00	1,000,000	128,000
Claude Opus 5.5	$4.00	$20.00	1,000,000	128,000

Three traps make direct row-by-row comparison impossible:

OpenAI's tiered pricing. Input above 272,000 tokens raises GPT-6 Sol and GPT-6.1 Sol to $4 and $15. Anthropic bills the entire million-token window for Opus 5.5 and Sonnet 5.5 at standard rates.

Tokenization differences. Anthropic's pricing page notes that its recent models produce about 30% more tokens for the same text.

Max output. This is Argon's real differentiator: Google claims up to one million tokens (Vals AI shows 262,000), while competitors are generally at 128,000.

With per-token costs on par, Argon's distinction comes from its ultra-long output and lower evaluated hallucination rate.

OpenAI's tiered pricing and Anthropic's tokenization are the two easiest traps in a side-by-side comparison. Tiered pricing means that once input tokens exceed a threshold (here 272,000), the excess is billed at a higher unit price rather than the whole amount at a single price, so with long contexts GPT-6 Sol's actual input cost can be far above list price. Tokenization differences stem from different vendors' tokenizers splitting the same text differently; Anthropic states its recent models produce about 30% more tokens, meaning that even at the same list price, using Claude on the same text may cost more in practice. Together these two factors severely distort a simple per-million-token price comparison.

Known Limitations

Google itself documents some blind spots.

Undisclosed rate limits. The rate limits page does not give interactive quota numbers for Argon, pointing only to AI Studio. Only batch queue limits are listed: from 5 million tokens at the T1 level to 1 billion at T3.

Known to be slow. The model card mentions potential hallucinations and "occasional slow responses or timeouts."

Sensitive model. The cybersecurity critical threshold Google could not rule out explains the restricted access in the first two weeks.

Google claims a 0.7% attack success rate on Gray Swan's indirect prompt injection tests. This is a vendor-reported figure; safeguards are still needed, especially grounding answers in controllable sources via RAG.

How Different Developers Should Choose

Profile	Verdict	Reason
Code migration, large file generation	Test first	Google says output can reach one million tokens
Agents that need to avoid making things up	Worth testing	Artificial Analysis measured a 15% hallucination rate
Security teams	Test with caution	The 68% on CWE-bench is still a Google claim
High volume, small budget	Stay on smaller models	GPT-6 Luna is only $0.10/$0.50, and Argon has no free tier
Already using GPT-6 Sol or Claude Sonnet 5.5	Compare before switching	Same price during the promotion, then double, and 62,000 tokens output per task
Just curious	Gemini app (AI Pro/Ultra) or enable billing in AI Studio	No free tier for the API

Gemini 4 Argon is worth a serious try—if you generate a lot of code, or if hallucinations are costly for you. For simple, budget-sensitive applications, there is no rush.

Details Not Yet Verified

A few days after the public release, the following remain uncertain:

• API availability in France; none of the official sources consulted detail it.
• Whether it appears in Google Search's AI Mode; Clubic reports it but the official blog does not mention it.
• Max output: Google claims one million tokens, Vals AI shows 262,000, and the discrepancy is unexplained.
• The methodology of Google's tests (DeepSWE, LVBench) is undisclosed, and the CWE-bench v1 score is absent from the Artificial Analysis page.
• The 10% surcharge for European access points is mentioned by ActuIA but not listed on the Gemini API pricing page.
• Taxes are not mentioned on the pricing page.
• No tests were run for this article; the model's actual quality still needs to be verified by developers themselves.