Benefits of Gemini 4 Argon for Long-Running Coding Agents

You can't run Gemini 4 Argon coding agents yet, but you can read the fine print. Google announced the model on 30 September 2026, and for now only trusted cyber defenders in its Fairwind Program have access. The announcement is still specific enough about long-running agent loops to plan around, so here are five benefits with the number behind each, then the case for waiting.

Five benefits of Gemini 4 Argon for coding agents

1. A top score on long-horizon software work. Argon scores 77.9% on DeepSWE v1.1, which Google says measures "real-world long-horizon software engineering tasks," and it calls the result a new state of the art. A long-horizon coding agent is exactly that: many steps toward one goal, where one wrong turn early can cost you the whole run. The score is vendor-reported, so use it as a reason to test, not as a result.

2. A 1M-token output limit, up from 64K. Argon's output cap rises from 64K tokens to 1M. A large refactor or a generated test suite can come back in one response instead of being split across turns. It's also easy to price: at the $10 per million introductory output rate, a full 1M-token response costs $10, or $20 at the standard rate.

3. Cached input at 95% off. Agent loops resend the same growing context every turn, so input tokens dominate the bill. Google prices cached input at 95% off the input price, which works out to $0.10 per million at the introductory $2 rate and $0.20 at the standard $4 rate (my arithmetic). The worked example below shows what that does to a loop.

4. A Rust migration workload with measurable feedback. Google says Argon agents are migrating C/C++ to Rust, "from tens of thousands of lines in core libraries like re2, libgav1 up to 800K+ lines for the Fuchsia Zircon kernel." In libgav1, agents replaced 32K lines of SIMD code in an existing Rust port through rounds of profile-guided experiments, and the decoder now runs 2.7x faster than that port with identical video output. The pattern worth copying is the feedback: profiling for speed, identical output as the correctness bar. Give your own migration agent the same kind of judge, such as a test suite or a byte-for-byte output comparison.

5. Teams of agents on fleet-scale analysis. A team of Argon agents analyzed fleet-wide profiling telemetry and applied memory optimizations across Google's data centers, freeing over 300 TiB once rolled out, with an estimated 500 TiB to 1 PiB in total savings. It's one internal case, but it shows the model driving a whole analyze-then-change chain instead of answering a single prompt.

What 95% off cached input does to a 100-turn coding loop

Assume a 150K-token repo and tool context loaded on turn one, then 5K tokens of new tool output and 2K tokens of model output per turn, for 100 turns. With caching on, every token the agent re-reads is billed at the cached rate. This is plain arithmetic on the published rates, not an API call.

INTRO = {'input': 2.00, 'output': 10.00}      # USD per 1M tokens
STANDARD = {'input': 4.00, 'output': 20.00}
CACHED_DISCOUNT = 0.95


def loop_cost(rates, cache, turns=100, base=150_000, new=5_000, out=2_000):
    cached_rate = rates['input'] * (1 - CACHED_DISCOUNT)
    context, total = 0, 0.0
    for turn in range(turns):
        fresh = base if turn == 0 else new
        reread_rate = cached_rate if cache else rates['input']
        total += (context * reread_rate + fresh * rates['input'] + out * rates['output']) / 1_000_000
        context += fresh + out
    return total


for name, rates in (('intro', INTRO), ('standard', STANDARD)):
    print(name, round(loop_cost(rates, False), 2), round(loop_cost(rates, True), 2))

The script prints about $101.30 uncached against $8.19 cached at introductory rates, and $202.60 against $16.38 at standard rates. Caching beats the price doubling: the cached loop at the standard rate is cheaper than the uncached loop at the introductory rate. I assumed every re-read token hits the cache, and I found no published detail on cache lifetime or cache fees, so expect a lower hit rate in practice.

When Gemini 4 Argon is not worth it yet

• No way in today. Only Fairwind cyber defenders have access, and there is no public model ID or API documentation yet, so there is nothing to point your agent at. Google says broader availability comes after it gathers feedback, with no date.
• The price doubles. The introductory $2 and $10 per million tokens move to $4 and $20 after the introductory period, and I found no end date. Budget at the higher rate.
• Unreplicated evidence. The DeepSWE score, the Rust work and the memory savings are all Google's own results, with no published methodology or independent replication.
• Short loops. If your agent finishes in a handful of turns and its output fits well inside 64K tokens, benefits 2 and 3 matter much less.

For production agents, the useful habit is to price your loop at the post-promo rate and to test any new model on a task with its own checker before a benchmark earns your trust.