Gemini 4 Argon Developer Guide: 1M-Token Output and Benchmarks

Google's Gemini 4 Argon ties GPT-6 Astra on the Artificial Analysis Intelligence Index while raising the Gemini line's maximum output from 64K to 1M tokens, priced at $2 per million input tokens / $10 per million output tokens. But most developers can't call it right now — as of October 13, 2026, Google hasn't published a model ID, it isn't in the Gemini API model list, AIHubMix lists gemini-4-argon but marks it "coming soon," and guessing that ID against Google's own API returns a 404.

So for most teams, the real engineering question isn't "how do I call Argon," but "what should I build today so that switching to Argon is just a config change," and what behavioral differences you'll hit after the switch.

Key Points at a Glance

• Access: Currently limited to Google's Fairwind program (cyber defense focus). Paying API customers and Google AI Ultra subscribers are next in line, but with no concrete timeline.
• Strengths: Knowledge-work agents (Harvey Legal Agent 19.6%, best rival 6.7%), ultra-long inputs (GraphWalks 256k–1M at 84.2%), DeepSWE.
• Weaknesses: Terminal-heavy coding (Terminal-bench 4.0: 57.4%, Claude Opus 5.5 at 66.4%), computer use, FrontierSWE.
• Behavior to design for: It refuses when uncertain. 15% hallucination rate, but only 50% accuracy on the same class of questions.
• Output volume: Artificial Analysis averages roughly 62k output tokens per task, versus about 27k for GPT-6 Astra.
• Pricing: Promotional $2 / $10, standard $4 / $20, with no announced end date for the promo. Budget at the standard rate.

Current Status: Visible but Not Callable

Item	Status as of October 13, 2026
Google model ID	Not published
Gemini API model list	Not listed
AIHubMix	gemini-4-argon, coming soon
Who can call it	Fairwind program
In queue	Paid API, Google AI Ultra
Max output	1M tokens (up from 64K)
Context window	1M, per third-party testers
Input / output	Text, image, video / text
Price per million tokens	$2 / $10, then $4 / $20

Google's launch post doesn't state an input cap, and the 1M context figure comes from third-party testers. Artificial Analysis also lists audio as one of the input types.

There's one more critical difference between today's users and future users: Fairwind members and Google internal teams get a version without network guardrails. The broader release will refuse harmful cyber, chemical, biological, radiological, and nuclear requests, so results Fairwind users share on safety tasks may not transfer.

Argon also drops the Pro / Flash labeling scheme (just a generation number and a codename remain), and replaces Gemini 3.1 Pro Preview as the lineup's top model. It's Google's first new model above the Flash tier in over seven months.

Benchmarks: Read Them by What You're Building

Google's figures come from its DeepMind benchmark table. Google ran Argon at its highest thinking setting, and mostly uses self-reported or public leaderboard numbers for competitors, so treat these as vendor data.

Benchmark	Argon	Best other model
DeepSWE v1.1	77.9%	Opus 5.5, 74.2%
FrontierSWE v2	55.0%	Astra, 65.5%
Terminal-bench 4.0	57.4%	Opus 5.5, 66.4%
OSWorld-2.0	69.2%	Astra, 72.6%
Vals Index	68.9%	Opus 5.5, 67.0%
Vals Finance Agent v2	65.4%	Fable 5.1, 58.9%
Harvey Legal Agent	19.6%	Fable 5.1, 6.7%
GraphWalks 256k–1M	84.2%	Astra, 71.8%
LVBench	91.7%	Astra, 87.5%
CWE-bench v1	68.0%	Astra, 68.0%

Google's full table has 19 rows, and Argon leads or ties in 14 of them.

Independent results match this picture. Artificial Analysis gives Argon (high) an Intelligence Index of 53: tied with GPT-6 Astra (max), 1 point above GPT-6.1 Sol (max), and 23 points above Gemini 3.1 Pro Preview. In its own Terminal Bench 4 run, Argon scores 57%, trailing Claude Sonnet 5.5, Claude Opus 5.5, and GPT-6 Astra. Vals AI ranks Argon first on the Vals Index, with Finance Agent v2 as its best single result, but places it seventh out of eight models on CUA-bench (computer use).

Reading it by workload:

• Terminal or desktop agents: Stick with Opus 5.5 or Astra. Both Google's table and independent runs show Argon trailing here.
• Agents that read contracts, documents, or long logs: Plan for Argon. This is where its lead is largest.
• Large-scale code migration: Plan for Argon. Coding scores are mixed (leads on DeepSWE, trails on FrontierSWE), but the 1M output cap eliminates the manual chunking these tasks used to require.

What the 1M-Token Output Cap Changes

Earlier Gemini models capped output at 64K tokens, so large migrations or long reports had to be manually chunked. Argon can write up to 1M tokens, enabled by a new Gemini API feature called Long Decode Continuation — it pauses long responses and resumes them in subsequent calls, avoiding timeouts.

Google's own examples are exactly this kind of work: its agent used Argon to migrate C and C++ to Rust, including the over 800,000-line Fuchsia Zircon kernel; another library replaced 32K lines of SIMD code with safe Rust and ran 2.7x faster than the previous Rust port.

For your client, this means long answers arrive across multiple calls rather than in one. Google hasn't published Long Decode Continuation's request parameters or response fields yet, so there's nothing concrete to code against today. Until there is, keep your chunking logic.

Technical background on Long Decode Continuation. Traditionally, LLM APIs follow a "one request, one response" paradigm: the client sends a request, and the server returns the complete output within a single HTTP connection, either streamed or all at once, constrained by a platform-set per-generation cap and a network timeout window. When output length far exceeds that window, the model either gets truncated or the connection times out and fails. Long Decode Continuation makes long-output generation stateful: the server pauses when a response hits an internal threshold and saves the decode state, returns a resumable handle, and the client resumes generation with subsequent calls until the full output is delivered. It doesn't simply raise the max_tokens ceiling — it changes the boundary definition of "one generation," making million-token output engineering-feasible without relying on client-side manual chunking. So for the client, the key change is that responses may arrive in multiple segments; parsing logic needs to stitch fragments across calls and support resuming from a checkpoint if a call fails midway.

Four Failure Modes to Design for Today

1. Guessed Model IDs Return 404

What you'll see: Calling a guessed ID (like gemini-4-argon) against Google's own API returns a 404 error.

Why: Google hasn't published the ID. AIHubMix lists Argon as gemini-4-argon but marks it coming soon.

Fix: Keep the model ID in config, default to a model that exists today (the client below falls back to gemini-3.8-flash), and switch to gemini-4-argon once AIHubMix opens it up.

2. No Idea Which Reasoning Levels Argon Accepts

What you'll see: There's no documented list of thinking levels for Argon. All published scores run at the highest setting: Google uses its highest thinking setting, and Artificial Analysis and Vals test at high too.

Why: The Gemini API docs don't list Argon at all.

Fix: Keep reasoning_effort in config, right next to the model ID. On AIHubMix's OpenAI-compatible route, it maps to Gemini's thinking setting.

3. "I'm Not Sure" Answers Have Nowhere to Go

What you'll see: More refusals than you're used to. On Artificial Analysis's Omniscience test (hard factual questions where confident wrong answers are penalized), Argon has a 15% hallucination rate versus GPT-6 Astra's 51%, but 50% accuracy versus Astra's 63%. It gets a low hallucination rate by refusing when uncertain, not by knowing more.

Why: It's a tradeoff the model makes. For legal and financial review, it's usually the right one: refusals are easy to spot, confident wrong numbers can slip past reviewers.

Fix: Ask the model to say when it's unsure (the prompt below does this), detect those answers, and route them to a human or another model. If your pipeline expects an answer every time, Argon is the wrong choice.

Why hallucination rate and accuracy should be read together. Usually hallucination rate and accuracy move in the same direction: the more a model knows, the less it fabricates. Argon shows an unusual combination — 15% hallucination rate alongside only 50% accuracy — suggesting its low hallucination comes not from improved knowledge coverage but from a calibrated abstention strategy: the model chooses to say "I'm not sure" when confidence is low rather than give a potentially wrong answer. This has an evaluation consequence: a refusal counts neither as correct nor as a hallucination, so both metrics look mediocre but don't contradict each other. For downstream systems, it means the usable-answer rate actually drops — half the questions get no usable response. So when evaluating this kind of model, alongside hallucination rate you should also look at "abstention rate" and "the cost of routing abstentions to a human or another model," otherwise a low hallucination rate masks the real throughput loss.

4. Output Volume Inflates Latency and Cost

What you'll see: Long responses. Argon averages roughly 62k output tokens per task on Artificial Analysis, versus about 27k for GPT-6 Astra. Google hasn't published speed data.

Why: Argon produces more output per task, and output is the expensive side (promotional $10 versus $2 per million tokens for input).

Fix: Budget at the standard rate. Artificial Analysis puts Argon at $1.99 per index task at the promo rate and $3.98 at standard, versus $1.30 for Gemini 3.1 Pro Preview. Set timeouts for long runs, and until speed data arrives, keep latency-sensitive paths on other models.

A Minimal Client That Runs Today and Switches Later

Argon has a model page on AIHubMix under the ID gemini-4-argon, but it's marked coming soon with no pricing.

The client below runs today on Gemini 3.8 Flash through AIHubMix's OpenAI-compatible endpoint, using the standard OpenAI SDK. The AIHubMix Gemini guide covers this route and the native Google SDK.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://aihubmix.com/v1",
    api_key=os.environ["AIHUBMIX_API_KEY"],
)

# AIHubMix lists Argon as gemini-4-argon (coming soon). Prototype on
# Gemini 3.8 Flash, then set ARGON_MODEL_ID=gemini-4-argon once it opens.
MODEL = os.environ.get("ARGON_MODEL_ID", "gemini-3.8-flash")

resp = client.chat.completions.create(
    model=MODEL,
    reasoning_effort="high",
    messages=[
        {"role": "user", "content": "List the termination clauses in the contract below. Say so if you are unsure about any of them.\n\n<contract text>"},
    ],
)
print(resp.choices[0].message.content)

Run it, and switch later without changing code:

pip install openai
export AIHUBMIX_API_KEY="your-aihubmix-key"
python argon_client.py   # runs on gemini-3.8-flash today

# Once Argon opens on AIHubMix:
export ARGON_MODEL_ID="gemini-4-argon"
python argon_client.py

Once Argon is live on AIHubMix, its pricing and supported parameters will appear on that model page.

What Can't Be Verified Yet

• Google's model ID. Not published; AIHubMix marks gemini-4-argon as coming soon.
• Context window. Third-party testers report 1M tokens; Google's launch post doesn't mention it.
• Thinking levels. No list, no default, and no published results below the highest setting.
• Long Decode Continuation. Described, but request parameters and response fields aren't public.
• Speed. Google provides no output speed or time-to-first-token data.
• Promo end date. Google hasn't said when $2 / $10 becomes $4 / $20.
• Competitor scores in Google's table. Mostly self-reported or pulled from public leaderboards.

Practical Advice for Developers

Argon's strengths cluster around "read long documents, write long documents, do knowledge work," and its weaknesses cluster around "operate terminals and desktops." If your team is building contract review, financial analysis, or large-scale code migration tools today, now is the time to extract the model ID and reasoning level into config, and design fallback routing for "refuses when uncertain" outputs. If your product depends on terminal automation or computer operation, there's no reason to migrate off Opus 5.5 or Astra for now.

The biggest uncertainty isn't Argon itself, but Google's slow release of the model ID, context window, Long Decode Continuation parameters, and speed data. Until those are public, any production plan built on Argon should be buffered for the possibility of a long wait.

Additional Background

On how to read the benchmark table. Most numbers in the table come from vendor self-reports or public leaderboard scrapes, and the reasoning budgets, thinking settings, and evaluation timing differ across models, so there are three things to watch when comparing horizontally. First, different thinking levels significantly change results: Google runs Argon at its highest thinking setting, while other models may not be running at an equivalent compute budget, so "tied" or "leading" is just a snapshot under specific settings. Second, benchmarks cover very different capability dimensions — DeepSWE and FrontierSWE test software engineering tasks, Terminal-bench and OSWorld lean toward system operation and desktop automation, Harvey Legal Agent and Vals Finance are vertical knowledge work, and GraphWalks and LVBench target ultra-long context. Merging them into one overall score masks the distribution of strengths and weaknesses across task types. Third, when single scores are close (like CWE-bench's 68.0% vs. 68.0%), that shouldn't be treated as a real difference; evaluation variance may be comparable. So selection should look at the rows closest to your actual workload, not the overall ranking.

One-line Summary

Gemini 4 Argon's intelligence matches GPT-6 Astra, but with no published model ID, selection must be workload-driven with switching built in.

Paragraph Summary

Gemini 4 Argon ties GPT-6 Astra on the Artificial Analysis Intelligence Index and raises max output from 64K to 1M tokens, priced at a promotional $2 per million input / $10 output, but as of October 13, 2026 Google hasn't published a model ID, it's absent from API lists, only the Fairwind program has access, and guessing the ID returns a 404. Its strengths are knowledge-work agents, ultra-long inputs, and large-scale code migration; weaknesses are terminal-heavy coding, computer use, and FrontierSWE. Its 15% hallucination rate is bought with active refusal, and accuracy is only 50%, so pipelines need routing for uncertain answers. Average output is about 62k tokens per task, significantly more expensive than rivals. For most teams, the realistic move is to extract the model ID and reasoning level into config, keep running on an existing model, and switch with one environment variable once Argon opens.