Gemini 4 Argon Opens Its API: $2 Pricing Doubles in December

Google has opened Gemini 4 Argon to all paid API customers, with pricing at $2 per million input tokens and $10 per million output tokens—but that price comes with a hard expiration date: on December 1 it doubles to $4 and $20.

From closed testing to full general availability

Google initially showed Argon on September 30 only to safety teams in the Fairwind program, and only opened it to global developers and enterprises via API on October 13. According to VentureBeat, Reuters interpreted this as Google's move to catch back up to OpenAI and Anthropic after months of delays.

The model ID is gemini-4-argon, marked as stable on its model page. It offers a unified 1,048,576-token context window and three thinking levels: low, medium, and high. Input supports text, images, video, audio, and PDF, with text output. Function calling, structured output, code execution, search grounding, and computer use (preview) are all supported. Interestingly, the pricing page shows no free tier.

Thinking level is a reasoning-control parameter introduced with Gemini 4 Argon, offering three settings: low, medium, and high. It determines how many "internal reasoning tokens" the model spends before producing a final answer, similar to OpenAI's reasoning effort or Claude's extended thinking. Higher levels usually improve accuracy on tasks like arithmetic, multi-step planning, and code debugging, but latency and cost per call rise accordingly. The key point is that Argon bills thinking tokens as output tokens, so the high setting significantly inflates per-call cost even on simple questions. A common practice in production is to allocate levels by task type: low for routing and classification, high for complex agent loops, and to set a cap on the amount of thinking within a single response.

Computer use (preview) means the model can directly control graphical interfaces—moving the cursor, clicking, typing, reading screenshots—without needing a custom API integration for each application. It drives the browser or desktop as a tool, a key capability for building general-purpose automation agents. A preview label means the interface and behavior may change at any time, and it usually comes with higher failure rates and prompt-injection risk, so irreversible operations such as deletion, payment, or deployment must be wrapped in human approval or sandbox constraints.

The $2/$10 price has an expiration date

The pricing page lists every Argon rate twice: once before November 30, and once after December 1:

Tier (per million tokens)	Before Nov 30	From Dec 1
Standard input	$2.00	$4.00
Standard output (incl. thinking)	$10.00	$20.00
Batch/Flex input	$1.00	$2.00
Batch/Flex output	$5.00	$10.00
Cached input (implicit)	$0.10	$0.20

At launch pricing, Argon sits level with Claude Sonnet 5.5 and GPT-6.1 Sol, both at $2/$10. After December 1 it rises to $4/$20, the same price as Claude Opus 5.5 and Meta's Muse Wonder. GPT-6 Astra sits at $10/$50.

Note the "incl. thinking" on the output line. Thinking tokens are billed as output, so a high thinking level adds cost to every call, even short answers. Price your features against December rates. If the margins only work at $2/$10, the December bill will tell you.

Implicit caching is a cost-optimization mechanism in the Gemini API: when consecutive requests share a highly repeated input prefix (for example, the same long document being queried repeatedly, or conversation history resent in an agent loop), the system automatically detects and reuses already-computed KV cache, billing only the new portion at standard rates and the reused portion at a discount. Argon's implicit cached input price is $0.10 per million tokens, just 5% of the standard input price. Unlike "explicit caching," which requires explicitly creating a cache object, implicit caching is transparent to developers and needs no changes to calling code, but cache hits are not user-controlled. In long-decode background tasks, implicit caching not only saves money but also shortens per-hop latency by reducing redundant computation, making it a core tool for controlling multi-turn, long-context costs.

Rankings beyond Google's own charts

Google's launch post relies mainly on results reported by itself or its partners. Two independent indexes offer a second view.

On the Artificial Analysis Intelligence Index, Argon (high) scores 53, ranking 8th out of 216 models. According to VentureBeat, this ties GPT-6 Astra and Claude Fable 5.1, and trails Claude Opus 5.5 (58) and Claude Sonnet 5.5 (56). On the Vals Index as of October 12, the order flips: Argon leads at 68.90%, ahead of Sonnet 5.5's 67.04% and Opus 5.5's 66.97%.

Google's own coding numbers also diverge, and VentureBeat notes they have not yet been independently reproduced. Argon leads on DeepSWE v1.1 at 77.9% versus Opus 5.5's 74.2%. On Terminal-Bench 4.0, Opus 5.5 leads at 66.4% versus 57.4%.

Sam Witteveen of Red Dragon AI told VentureBeat: "It's a very, very, very good model. But is it the best model right now? I don't actually think so." Leaderboards disagree on Argon, so test it on your own tasks before switching.

The 1M output tokens come with conditions

Google calls it "the industry-leading 1M unified input-output token limit available through the Gemini API." But before planning around it, read the model page. By default, synchronous requests cap output at 65,536 tokens. The 1M figure requires "long decode."

The long decode documentation lays out the rules. You need to set background: true via the Interactions API and set max_output_tokens above 65,536. Background interactions require store=true. If a request exceeds 65,536 tokens without background mode, you get a 400 error. Background runs can last up to 24 hours, and every token in every hop is billed, including purely thinking hops.

The Python example in the docs creates a call like this:

from google import genai

client = genai.Client()  # reads GEMINI_API_KEY

interaction = client.interactions.create(
    model="gemini-4-argon",
    input="Port this C module to Rust: ...",
    background=True,
    store=True,
    generation_config={
        "max_output_tokens": 262144,
        "thinking_level": "high",
    },
)

Then poll the interaction until its status leaves queued or in_progress, and concatenate text from its output steps. The docs provide polling loops for Python, JavaScript, and REST.

Do the math at list price. A full 1M-token decode costs about $10 in output at launch pricing, or $20 from December 1, thinking included, plus the input resent on every hop (implicit caching discounts the repeated portion). This is a task for a queue and a budget check, not for a request handler with a 30-second timeout.

Long decode is a special execution mode for bypassing the default output limit and enabling ultra-long generation. By default, Argon caps synchronous request output at 65,536 tokens, returning a 400 error beyond that. To generate output approaching 1M tokens, you must set background: true through the Interactions API and raise max_output_tokens, while requiring store=true because background interactions rely on persistence. The task then runs asynchronously for up to 24 hours, with the client polling the interaction status (until it leaves queued or in_progress) to assemble output steps. This mode suits batch scenarios that don't need immediate responses, such as whole-repo code porting or long-document generation, essentially turning an HTTP request into a recoverable job queue.

Before you swap the model ID in your agent

Google says Argon was trained to "pause for human confirmation before taking irreversible steps." It also reports that Argon leads on the Gray Swan indirect prompt-injection benchmark, with an attack success rate of 0.7% across 15 adaptive attempts. These are Google's numbers, and they are no substitute for your own approval gates on any deletion, payment, or deployment action. If your agent does security work, note the public model "has network mitigations that block offensive tasks like penetration testing and exploit development."

For a coding agent, the fair test is to hand it the same ticket you gave your current agent. The author builds Hermes IDE, so weigh this with that context in mind. Hermes runs each agent's own CLI in a real terminal, with each task on its own hermes/<name> branch and worktree. Its agent list includes Antigravity CLI alongside Claude Code and Codex. Launch the same task in both agents with ⌘N (Ctrl+Shift+N on Windows and Linux), then open each agent's changes round by round in the Review Desk (⌘G or Ctrl+Shift+G) and compare for yourself.

Two notes: the author has not confirmed which Google plans will see Argon in the CLI's model list, and has not personally run Argon. Hermes is free to download with visible source (BSL 1.1), runs on macOS, Windows, and Linux, and is unaffiliated with Google, Anthropic, OpenAI, or Nous Research.

Indirect prompt injection is one of the most realistic security threats in agent scenarios: the attack content does not come from the user, but is hidden in external data the model reads, such as web pages, PDFs, code comments, or tool return values. When an agent runs with tool permissions, these hidden instructions can induce it to delete files, initiate payments, or leak data. The Gray Swan benchmark measures a model's success rate in resisting such attacks across 15 adaptive attempts (lower is better), and Argon reports 0.7%. But benchmark scores are obtained in controlled environments and cannot cover the specific permission combinations of your own toolset. The truly effective defense is an approval gate: force a pause for human confirmation before irreversible operations, and apply least-privilege principles to tool capabilities.

One-line Summary

Gemini 4 Argon is open to all paid API customers, with launch pricing of $2/$10 doubling on December 1, and performance rankings that disagree.

Paragraph Summary

On October 13, Google opened Gemini 4 Argon via API to all paid customers. The model ID is gemini-4-argon, offering a unified 1,048,576-token context window, three thinking levels, support for text, image, video, audio, and PDF input, and features including function calling, code execution, and computer use preview—but no free tier. The original article stresses that its pricing has a clear shelf life: before November 30, standard input/output is $2/$10, and from December 1 all rate tiers double to $4/$20. Independent evaluations give inconsistent rankings: it places 8th on Artificial Analysis, trailing Claude Opus 5.5, but leads on the Vals Index. Additionally, the advertised 1M output tokens require enabling long decode background mode, while the default synchronous output cap is only 65,536 tokens.