Gemini 4 Argon on the API: 1M output tokens, thinking levels only, and a price that doubles on December 1

Google rolled Gemini 4 Argon out worldwide on the Gemini API on October 13, 2026, two weeks after it first handed the model to a small group of cyber defenders. Google's Logan Kilpatrick announced the wider release the same day: the API, Pro and Ultra subscribers in the Gemini app, and Ultra subscribers in Antigravity. The launch thread topped the Hacker News front page that day.

The model ID is gemini-4-argon. Google's cookbook calls it a frontier reasoning model for software engineering, long-horizon agents, knowledge work and scientific problems. Neither Argon nor Gemini 3.1 Pro has a free tier.

The benchmark table got the headlines. For developers, the cookbook's migration checklist matters more, because a Gemini 3 request copied over to Argon can fail with a 400 or stop halfway through its own thinking.

1. Sep 30, 2026

   Google introduces Argon to a limited group of cyber defenders at $2 in and $10 out.

2. Oct 13, 2026

   Global rollout on the Gemini API, the Gemini app (Pro and Ultra) and Antigravity (Ultra). Simon Willison ships llm-gemini 0.35 with the model the same night.

3. Oct 14, 2026

   google-genai 2.31.0 adds gemini-4-argon to its Model enum.

4. Nov 30, 2026

   Last day of introductory pricing.

5. Dec 1, 2026

   Price doubles to $4 input and $20 output per million tokens.

What changed in the request

Argon accepts three thinking levels: low, medium and high. The default is medium. Gemini 3 defaulted to high, so a straight model swap makes Argon think less than your Gemini 3 code was tuned for.

The thinking budget error reads "Thinking budget is not supported by gemini-4-argon." If you were on Gemini 2.5 with thinking_budget=0, the cookbook maps that to low. A budget around 4,096 to 8,192 maps to medium, and the maximum or dynamic budget maps to high.

max_output_tokens covers thinking and output combined. The cookbook puts typical thinking at 1K to 4K tokens on low, 4K to 16K on medium and 16K to 64K or more on high. A classifier that used to run with an 8K cap can spend the whole budget thinking and return nothing. Google recommends a floor of 32,768, or 65,536 for synchronous calls, and tells you to lower thinking_level to save money instead of lowering the cap.

Here is the minimal Interactions API request with the SDK version Google requires:

# pip install -U "google-genai>=2.30.0"
from google import genai

client = genai.Client()

interaction = client.interactions.create(
    model="gemini-4-argon",
    input="Review this migration plan for data loss risks: ...",
    generation_config={
        "thinking_level": "medium",   # "low" | "medium" | "high"
        "max_output_tokens": 65536,   # thinking + output combined
    },
)
print(interaction.output_text)

Google also tells you to raise client timeouts to 15 to 20 minutes for high thinking, and to pass previous_interaction_id on later turns so the model keeps its thought signatures across tool calls.

Long decode and 1M output tokens

Argon shares one 1,048,576-token window across input, thinking and output. A normal request still stops at a per-request cap: 65,536 tokens on the Interactions API and streaming generateContent, 32,768 on non-streaming generateContent. To go past it, you run the request in the background and poll.

interaction = client.interactions.create(
    model="gemini-4-argon",
    input="Write a reference implementation of a Raft consensus engine...",
    background=True,                  # required above 65,536 output tokens
    generation_config={
        "max_output_tokens": 131072,  # defaults to 65,536 if you omit it
        "thinking_level": "medium",
    },
)

while interaction.status in ("in_progress", "queued"):
    time.sleep(10)
    interaction = client.interactions.get(id=interaction.id)

Google calls this long decode. The server writes across several internal passes and reuses earlier passes through implicit caching at a 95% discount. You get one Interaction with the full text and token usage summed across passes. Passing max_output_tokens above 65,536 with background=False returns INVALID_ARGUMENT, and store=False breaks it, since the server keeps checkpoints between passes. You can stream a background run and reconnect with last_event_id after a dropped connection, or cancel it with client.interactions.cancel().

If you stay on generateContent, google-genai 2.30.0 and later resend the request with a continuation_token for you whenever max_output_tokens exceeds 65,536.

Price per token, price per task

per million input / output tokens until Nov 30

$2 / $10

per million input / output tokens from Dec 1

$4 / $20

discount on implicit cache hits, prefixes of 4,096+ tokens

95%

The per-token price looks low next to its peers. Artificial Analysis measured something else. Argon used 61,558 output tokens per task on its Intelligence Index, against 27,206 for GPT-6 Astra. Running the whole index cost about $2,407, or $1.99 per task, at the introductory rate. At December prices the same run doubles.

On that index Argon scores about 52.6, level with GPT-6 Astra at 52.7 and about five points behind Claude Opus 5.5 at 57.6. Google's own table, by VentureBeat's count, has Argon leading 12 of 18 benchmarks. Tech Times pointed out that Google ran those numbers on high, while the app and the API default to medium.

Coding is the weak column. Third-party tallies of Google's table have GPT-6 Astra ahead on FrontierSWE v2 and OSWorld-2.0, and Claude Opus 5.5 ahead on Terminal-Bench 4.0.

Feedback from around the internet

The reaction split along familiar lines: people who had early access liked it, people who tried to get access complained, and people who ran benchmarks argued about cost.

Ethan Mollick, the Wharton professor, spent time with Argon ahead of release. In his write-up on X he called it a big jump over earlier Gemini models and the first model from outside OpenAI and Anthropic to pass the bar set by Fable, Mythos and Astra. He found it more pleasant and more agentic than Gemini 3, creative, and a good writer. His complaints: it trails on complex multi-agent work, sounds too sure of its conclusions, and can be a little lazy. On September 30, the day Google first announced Argon, he posted that it's a three-way race again.

Simon Willison added gemini-4-argon to his llm-gemini plugin on the night of the launch. He ran his pelican-on-a-bicycle SVG test at low, medium and high thinking and rated all three excellent. Hacker News commenters noted that even the low-thinking pelican beat what they'd seen from other labs. His launch post also flagged the December 1 price doubling and the $2,407 index cost, which he called cheaper than several rivals.

Artificial Analysis summed up its run in one line: Argon matches GPT-6 Astra's index score at 60% of the cost per task with discounted prices. The output token count above is the catch. Each Argon task writes more than twice as many tokens, so the cheaper rate carries the comparison. Double that rate in December and the same run would cost about 20% more than Astra's.

gertlabs, a team that tests models in 100 competitive and cooperative coding environments, posted results on Hacker News. They put Argon about two months behind the coding frontier. They also wrote that older Google models struggled to work in an agent harness, and that Argon seems to have fixed it. Other commenters reported runs that got stuck in reasoning loops, the failure the cookbook ties to leftover temperature settings.

Logan Kilpatrick answered access complaints himself. Replying to a user on X, he said Argon is a large model that Google can't yet serve to everyone who wants it, and that smaller Gemini 4 versions for billions of users are in the works. He also said more than 100,000 people inside Google tested the model in the month before launch. Varun Mohan of Antigravity followed up that paid Pro subscribers get Argon in Antigravity with a separate weekly quota, so it doesn't eat into their Flash allowance.

The critical reviews focused on access. XDA Developers covered the first announcement under a headline saying you weren't allowed to use the model. An eesel.ai reviewer got 404s on the model IDs during the gated period and called it a great model you couldn't use yet. The global rollout on October 13 answered most of that for API users. Consumer access still depends on your plan.

This week

1. Grep for thinking_budget, "minimal", temperature, top_p, top_k and cached_content in any code you plan to point at gemini-4-argon. Each one fails or degrades on Argon.
2. Upgrade to google-genai 2.30.0 or later. Version 2.31.0 adds the model to the SDK enum.
3. Raise max_output_tokens to at least 32,768 and your HTTP timeout to 15 minutes, then run your eval set at low and medium before you try high.
4. Log total output tokens per task, not per request. Argon's bill depends on how long it thinks, and that number doubles in price on December 1.
5. If you need output past 64K tokens, prototype the background=True flow now, including the polling loop and a cancel path.

If your workload is coding agents and you already run GPT-6 Astra or Claude Opus 5.5, Argon's own benchmark table gives you no reason to switch this month. If you generate long reports, audits or specifications in one pass, long decode is the feature to test, and you have until November 30 to test it at half price.