Most launch charts I have seen show the new model winning everything, which is why the Gemini 4 Argon chart caught my attention. It wins plenty and loses in a few places that matter a lot to anyone who spends their day in a terminal, and I trust that kind of chart more.

I have a habit with launch posts that I am not especially proud of. I skip the headline number and hunt for the row where the model loses, because that row usually decides whether I am actually going to use it or not. A model gets picked for the one irritating kind of work that fills someone’s week, and the average of forty benchmarks says very little about how that work will go.

With Argon, the story is at the bottom of the table, and it is the reason this article exists. The same model that takes first place on repository-level software engineering sits well behind on terminal work, and it is also a model where one careless API call can run to $10 or $20. That kind of unevenness tells me more than a clean sweep would.

The rest of this piece follows that thread through the API, the pricing, the benchmarks and the case studies, and the two code samples include the guards I actually want in a script.

What shipped and where you can reach it

Google announced Argon on September 30, 2026, and for the first two weeks only vetted security defenders could use it, through the Fairwind Program, along with early testers such as Wiz. It reached developers on October 13 through the paid tier of the Gemini API and AI Studio, with Antigravity available to Google AI Ultra subscribers. The model ID is gemini-4-argon, and a second one, gemini-4-argon-cyber-permissive, is aimed at authorized defenders, so most readers can ignore it.

It is a sparse mixture-of-experts transformer with a March 2026 cutoff. Text, code, images, audio, video, and PDFs go in, and only text and code come out, so Argon cannot draw you a diagram, which I find mildly funny given the next section.

One pool of a million tokens

The change that interests me most is the output window. Older Gemini models took roughly a million tokens in and gave at most 64K back. Argon raises the output limit to 1M tokens, and the long decode docs describe a unified window of 1,048,576 tokens shared across input, thinking, and output, so a 100K prompt leaves room for almost 950K of answer.

The default output cap stays at 65,536 tokens, mostly so nobody wakes up to a surprise invoice. To go past it you raise max_output_tokens (up to 1,048,576 minus your input) and use long decode.

On the Interactions API that means background=True, and Google’s servers chain the 64K hops into one interaction for you, while on the GenerateContent API you handle the continuation yourself. Ask for more than the pool and you get an HTTP 400.

So why should you care? A huge generation used to mean chopping the job into chunks, feeding each result back in, and hoping the model still remembered what it had promised in chunk one. That workflow was never fun, and long decode is a fair reason to retire it.

The top lane resends a growing context on every turn and leaves the stitching to you, while the bottom lane lets the server chain the hops inside one shared pool.

One caveat from the same docs is that long decode can run for several minutes, so it belongs in background jobs.

Thinking levels and one breaking change

thinking_level takes three values, "LOW", "MEDIUM" and "HIGH". Low is for classification, summarizing, and pulling out metadata, medium (the default) covers everyday coding, tool use, document Q&A and video, and high is for multi-file engineering, proofs, architecture work and vulnerability hunting.

The one to watch for if you are migrating is that the old integer thinking_budget and the MINIMAL setting now return an HTTP 400, so grep for those two before anything else. Caching changed as well, since Argon only does implicit caching, with a 95 percent discount on cached input, and the explicit caching endpoints are gone.

Here is the standard call in the form worth keeping in a script. It validates the level up front, because a bad value only fails after the request has gone out, and it logs token counts at the end, since output tokens include thinking tokens and that is the number on the invoice.

import loggingimport osimport sysfrom google import genaifrom google.genai import typeslog = logging.getLogger("argon")logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")# Anything else (including the old "MINIMAL") comes back as an HTTP 400 after the# request has already gone out, so fail here instead of in the middle of a run.VALID_LEVELS = {"LOW", "MEDIUM", "HIGH"}# Stays at the default on purpose. Going past it is a decision for the long-decode path.OUTPUT_CAP = 65_536def stream_audit(prompt: str, level: str = "MEDIUM") -> str:    level = level.upper()    if level not in VALID_LEVELS:        raise ValueError(f"thinking_level must be one of {sorted(VALID_LEVELS)}, got {level!r}")    client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])    config = types.GenerateContentConfig(        thinking_config=types.ThinkingConfig(thinking_level=level),        max_output_tokens=OUTPUT_CAP,        temperature=0.2,  # low because I want the same audit twice, not a creative one    )    pieces = []    last_usage = None    for chunk in client.models.generate_content_stream(        model="gemini-4-argon", contents=prompt, config=config    ):        # Some chunks carry only usage metadata and have no text at all.        if chunk.text:            pieces.append(chunk.text)            sys.stdout.write(chunk.text)            sys.stdout.flush()        last_usage = chunk.usage_metadata or last_usage    if last_usage:        # Output tokens include thinking tokens, and that is what gets billed.        log.info(            "tokens in=%s out=%s thinking=%s",            last_usage.prompt_token_count,            last_usage.candidates_token_count,            getattr(last_usage, "thoughts_token_count", None),        )    return "".join(pieces)if __name__ == "__main__":    with open(sys.argv[1]) as fh:        source = fh.read()    stream_audit(        f"Audit this C++ module for memory safety, then port it to safe Rust:\n\n{source}",        level=os.environ.get("ARGON_LEVEL", "HIGH"),    )

The long-decode version needs more care. It clamps the output cap against the real prompt size, since asking for more than the pool minus the prompt is a guaranteed HTTP 400, and it refuses to start when the worst-case bill is above a limit you set. That check is a bit of belt and braces, but a refused run costs nothing.

import loggingimport osfrom google import genailog = logging.getLogger("argon.longdecode")logging.basicConfig(level=logging.INFO, format="%(asctime)s %(message)s")POOL = 1_048_576          # input, thinking and output all share thisINTRO_OUT_PRICE = 10.00   # USD per 1M output tokens until Nov 30, doubles on Dec 1client = genai.Client(api_key=os.environ["GEMINI_API_KEY"])def long_decode(prompt: str, want_tokens: int = 250_000, max_spend_usd: float = 5.00) -> str:    used = client.models.count_tokens(model="gemini-4-argon", contents=prompt).total_tokens    # Asking for more than the pool minus the prompt is a guaranteed HTTP 400,    # so clamp it here instead of finding out at 2am.    cap = min(want_tokens, POOL - used)    if cap <= 0:        raise ValueError(f"the prompt alone ({used} tokens) fills the {POOL} token pool")    # Worst case assumes the model burns the whole cap, thinking included.    worst_case = cap / 1_000_000 * INTRO_OUT_PRICE    if worst_case > max_spend_usd:        raise RuntimeError(f"worst case ${worst_case:.2f} is over the ${max_spend_usd:.2f} limit")    log.info("prompt=%d tokens, cap=%d, worst case $%.2f", used, cap, worst_case)    # Past 64K output the call has to run in the background. Google's long-decode    # examples spell the level in lowercase on the Interactions API.    stream = client.interactions.create(        model="gemini-4-argon",        input=prompt,        background=True,        stream=True,        generation_config={            "thinking_level": "high",            "thinking_summaries": "auto",            "max_output_tokens": cap,        },    )    out = []    for event in stream:        if event.event_type == "content.delta":            out.append(event.delta.text)    return "".join(out)

The worst-case estimate uses the introductory price, so that constant has to change on December 1. The loop also keeps everything in memory, which is fine for a few hundred thousand tokens, but write each delta to disk if losing the connection would hurt.

Pricing and the verbosity catch

Introductory pricing (as of mid-October 2026) is $2.00 per million input tokens and $10.00 per million output tokens, with thinking billed as output and cached input 95 percent off. The window closes on November 30, and from December 1 the standard prices of $4.00 and $20.00 apply.

At the introductory rate, that puts Argon level with Claude Sonnet 5.5, at half the price of Claude Opus 5.5, and far below GPT-6 Astra at $10 and $50.

Then comes the catch. Artificial Analysis found that Argon used 110M tokens on its evaluation suite against a field median of 82M, so it talks more than its rivals.

It still came out cheaper per task, at $1.99 against $3.26 for GPT-6 Astra and $5.98 for Claude Opus 5.5, so the savings are real but smaller than the rate card suggests. And one unconstrained 1M-token answer costs $10 at intro pricing or $20 at standard pricing, in a single call.

Where Argon wins and where it trails

Remember that row I talked about at the beginning? I went looking for it. On Terminal-Bench 4.0 Argon scores 57.4 percent while Claude Opus reaches 66.4 and Sonnet 70.6, and on FrontierSWE v2 it gets 55.0 against 65.5 for GPT-6 Astra.

It also trails on OSWorld 2.0 and on Agents’ Last Exam (39.5 against 59.3), and the blended Artificial Analysis Index puts it at 52.6, about level with GPT-6 Astra and five points behind Opus 5.5. If your day is mostly an agent reacting step by step to a shell or a desktop, these are the numbers that matter, and they are not flattering.

The wins come from a different kind of work. Argon takes first place on DeepSWE v1.1 at 77.9 percent, leads the Vals Index overall, and posts 84.2 percent on GraphWalks BFS in the 256K to 1M range against 71.8 for GPT-6 Astra and 66.8 for Opus 5.5. It also leads LVBench for long video at 91.7 percent.

Each of these rewards holding a large structure in your head at once, which a shared million-token pool is built for, so my read is that Argon suits a big problem you can hand over and walk away from, and gets less interesting once you want to steer it step by step.

What Google says Argon has done so far

The case studies show what that headroom is for. Google says Argon agents are migrating C and C++ to Rust at sizes from re2 up to more than 800,000 lines in the Fuchsia Zircon kernel.

In the libgav1 video decoder they replaced 32,000 lines of SIMD with safe Rust that the compiler vectorizes on its own, giving a decoder that runs 2.7 times faster than the previous Rust port with identical output, which is the result worth watching for an outside reproduction.

A team of agents reading fleet profiling data is expected to free 500 TiB to 1 PiB of memory across Google’s data centers, and Wiz used the model to find a critical vulnerability in hospital software that earlier frontier models had missed.

All of these are Google’s own numbers, so treat them as strong signals until someone outside the company reproduces a few of them.

···

Should you switch?

So should you switch? Probably not entirely. Send Argon the work with a big shape, such as repository-scale refactors, long documents, legal and financial analysis, and video review, and keep interactive terminal agents on Sonnet or Opus, where they currently lead.

Route by workload, set max_output_tokens on purpose, and remember that the pricing window closes on November 30 and the verbosity will show up on your invoice well before the benchmarks do.

···

Before you go!

I write about AI and ML engineering, and about what new model releases mean for the people who have to build with them. You can subscribe to my newsletter if you would like more of that.

Connect With Me