Gemini 4 Argon Cost Benchmarked: Same Price as GPT-6.1 Sol, 3x the Cost per Correct Answer

Google's latest flagship model, Gemini 4 Argon, is priced identically to GPT-6.1 Sol — $2 per million input tokens, $10 per million output tokens — yet on a 13-question reasoning benchmark, Argon costs 3.1x more per correct answer than GPT-6.1 Sol ($0.0063 vs $0.0020). At the same score, it wrote 3.3x more output tokens. Behind this seemingly contradictory conclusion lie two different cost curves — and a price hike on the horizon.

The Core Difference Between Argon and Its Same-Priced Rival

The two share identical unit prices, but their cost structures are worlds apart. GPT-6.1 Sol at the medium setting wrote just 7,032 output tokens across 39 calls; Argon wrote 22,980. Both scored 38/39, but Argon pays 3x more for each correct answer.

The most striking comparison comes from the hardest single problem — computing 13 to the power of 1001 modulo 10007. Argon's median output at medium was 1,523 tokens, and 6,108 at high; GPT-6.1 Sol's were 524 and 901 respectively. The two scored identically on the hard set (14/15 each at medium, 15/15 each at high), but at vastly different costs.

This leads to a key judgment: when two models are comparable in capability, the cost difference is driven entirely by "thinking redundancy," not unit price.

Comparison with Top-Tier Models: Cheap for Now, But the Window Is Limited

Google officially positions Argon against GPT-6 Astra, Claude Fable 5.1, and Claude Opus 5.5. On the Artificial Analysis Intelligence Index, Argon scores 52.6, roughly on par with GPT-6 Astra (52.7) and Fable 5.1 (53.4), and four to five points behind Opus 5.5 (57.6).

But its cost advantage is clear: Argon spends $0.0063 per correct answer, 0.76x that of Opus 5.5 ($0.0083) and 0.6x that of GPT-6 Astra ($0.0102). Artificial Analysis's per-task cost ranking confirms this: GPT-6.1 Sol $0.72, Argon $1.99, GPT-6 Astra $3.26, Opus 5.5 $5.98.

But this pricing window will close on December 1. Argon's API price will then double to $4/$20, matching Opus 5.5. At the same price, Opus 5.5 consumes fewer tokens (15,414 vs 22,980) and gets all 39 calls correct. After December, Argon's cost per correct answer will be $0.0125, 1.5x that of Opus 5.5.

thinking_level: The Only Effective Cost Lever

Argon's cost control hinges on the thinking_level parameter, which determines how long the model reasons before answering. The three settings are low, medium (default), and high, and reasoning tokens are billed at output prices even when the reasoning process is hidden from the response.

The measured results vary dramatically:

• low: zero reasoning tokens reported across 39 calls, with all outputs just 5-11 tokens. It handles one-step calculations and format conversions (15/15 correct), but multi-step reasoning collapses entirely — 0/3 on the 40-step rule problem, 0/3 on four-digit counting, and only 1/15 on the hard set.
• medium: median output 383 tokens, easy set 24/24, hard set 14/15.
• high: median output 1,455 tokens, hard set 15/15, but the cost per correct answer is 3.4x that of medium, for just one additional correct answer — a difference that is statistically indistinguishable from random.

One detail worth noting is the default setting's adaptive behavior. Under simple prompts, Argon's medium default often uses zero reasoning tokens; Gemini 3.1 Pro's high default reasoned on every single query. On tasks like tool calling and JSON extraction, Argon consumed 0 reasoning tokens, while 3.1 Pro used 173 and 353 respectively.

This means that for agent steps, tool calls, information extraction, and JSON output, Argon's default setting is already in a "barely thinking" state, delivering high cost efficiency.

Why reasoning tokens are billed at output prices: Most large models split token billing into input and output. The chain-of-thought a reasoning model generates before its final answer, though not shown to the user, is content the model actually generates, so it falls under output token billing. Gemini 4 Argon's thinking_level controls the length of this hidden reasoning. This also explains why "hidden reasoning" isn't free — if the model internally writes 1,000 extra thinking tokens, the bill charges 1,000 more at output prices. Understanding this is the prerequisite for judging the cost-effectiveness of each setting: what the high setting consumes more of is not reply length, but an invisible thinking process.

Five Pitfalls to Watch for When Migrating

Migrating from Gemini 3.1 Pro to Argon is not seamless. Here are the compatibility issues found in testing:

1. Prefilled assistant replies will error out. Requests ending with a model turn now return HTTP 400 ("Requests ending with a model turn are not supported"), which 3.1 Pro accepted. The workaround is to move the instructions into the prompt.
2. Explicit caching has been removed. The cachedContents object is no longer supported, leaving only implicit caching — repeated prompt prefixes are automatically billed at 5% of the input price. In testing, a 6,935-token repeated prompt had 4,881 tokens read from cache 4 seconds later.
3. Randomness parameters are ignored. temperature, top_p, and top_k return HTTP 200 but have no actual effect.
4. Fixed prompt overhead has increased. The same text costs about 30 more input tokens than 3.1 Pro, adding $0.00006 per request at current prices.
5. Exceeding the 1M context window errors out directly, rather than silently truncating.

Additionally, outputs beyond 64K require switching to the background execution mode; regular requests return at most 65,536 tokens.

About prefilling assistant replies: "Prefill" means setting the last message of a conversation to a partial assistant-role reply when submitting a request, forcing the model to continue generating from that point. It's commonly used to lock output formats, skip pleasantries, or construct JSON prefixes. It relies on the API accepting requests that "end with a model turn." Argon now returns HTTP 400, meaning this trick for saving output tokens and precisely controlling format no longer works. Developers must instead specify format requirements in the prompt or use structured output schemas to achieve a similar effect, which slightly increases prompt length and input cost.

Changes in Long Context and Caching

Argon brings two notable improvements over 3.1 Pro in long context. First, the long-context surcharge is gone. 3.1 Pro jumps to $4/$18 beyond 200K tokens, while Argon stays at $2/$10 across the full 1,048,576-token window. In testing, a 709K-token prompt cost Argon $1.42, versus $2.84 for 3.1 Pro.

Second, implicit caching actually kicks in below the documented threshold. Google's docs say caching starts above 4,096 tokens, but in testing even a 3,006-token prompt got a 952-token cache hit.

The difference between implicit and explicit caching: Explicit caching requires developers to actively create a cachedContents object, uploading a fixed prefix (such as a system prompt, knowledge base, or long document) to obtain a cache ID. Subsequent requests reference that ID, and the hit portion is billed at a heavily discounted input price; the cache usually has an explicit time-to-live (TTL) and manual management overhead. Implicit caching is fully automatic — as long as multiple requests share the same token prefix at the start, the server may hit already-cached KV in the background, with no API call required. Argon removes explicit caching and keeps only implicit caching. The upside is zero configuration and no TTL headaches; the downside is that developers lose precise control over what gets cached and when, with hits depending on the server's automatic judgment.

Choosing a Setting by Scenario

Based on the measured data, here are recommendations for different workloads:

Workload	Risk	Recommendation	Supporting Data
Agent steps, tool calls, extraction, JSON output	Paying reasoning fees for simple steps	Argon medium	Lookup, extraction, schema output, and tool steps all show 0 reasoning tokens
Hard math, algorithms, multi-step code	Wrong answers	Argon medium; self-test before using high	14/15 vs 15/15, high costs 3.4x
High-volume reasoning, cost-sensitive	Reasoning redundancy	GPT-6.1 Sol	Same score, $0.0020 vs $0.0063
Top-tier tasks after December	Argon price hike	Re-evaluate Opus 5.5	Same $4/$20, $0.0083 vs $0.0125
Long documents over 200K tokens	Long-context surcharge	Argon instead of 3.1 Pro	$1.42 vs $2.84
Lookup and format conversion only	Unnecessary reasoning	Argon low	15/15 on one-step tasks, 7 output tokens

There's also one easily overlooked money-saving tip: after December 1, Batch and Flex pricing ($2/$10) will equal the current standard price. Moving offline tasks to these modes lets you keep using Argon at current prices.

Key Takeaways

Gemini 4 Argon's pricing strategy is essentially a limited-time window. Before November 30, it delivers near-top-tier performance at GPT-6.1 Sol's price, and in long-context scenarios it even beats the previous-generation 3.1 Pro. But once the price doubles, it stands on equal footing with Opus 5.5, and its disadvantage in token efficiency translates directly into a cost disadvantage.

For teams currently evaluating options, two things should be done now: first, use November pricing to complete a round of your own benchmark data collection; second, test Opus 5.5 in advance to prepare for the December switch. The thinking_level parameter is currently the only effective cost lever, medium is the best value in the vast majority of scenarios, and low is only suitable for lookup and format conversion.

One-line Summary

Gemini 4 Argon is priced the same as GPT-6.1 Sol but costs 3.1x more per correct answer, and its advantage disappears after the December 1 price hike.

Paragraph Summary

Gemini 4 Argon launches at the same $2/$10 pricing as GPT-6.1 Sol, but on a 13-question reasoning benchmark, Argon costs $0.0063 per correct answer — 3.1x Sol's — driven by 3.3x more output tokens. It is temporarily cheaper than top-tier models like GPT-6 Astra and Claude Opus 5.5, but on December 1 its API price doubles to $4/$20, at which point its cost per correct answer surpasses Opus 5.5 by 1.5x. The article walks through the measured cost differences across the three thinking_level settings, five migration compatibility pitfalls, and changes such as the removal of the long-context surcharge and an implicit caching threshold below the documented figure.