Gemini 4 Argon: Google Is Back, Just Don't Hand It Your Codebase

Gemini 4 Argon is the best model Google has shipped in a long time, and for spreadsheets, finance, legal and business automation it is arguably the best model anyone has shipped. For coding, it is a strong contender you should test, not a model you should trust blind. And the price on the label is a launch price that doubles later.

That's the short version. Here's the long one.

Google had something to prove

Let's be honest about where Google started. The last few Gemini launches left a bad taste.

Gemini 3.1 Pro looked brilliant on paper. AICodeKing's one-shot KingBench test gave it 96%. Then he put it to work as a coding agent, and it fell apart: it kept re-planning, fumbled its tools, and made beginner mistakes. On one Go task it wrote the same method twice and broke the build. That's the gap a reasoning score never shows you.

Gemini 3.5 Flash was a different letdown: price. It cost three times as much per token as Gemini 3 Flash, which is a lot to ask from something still wearing the Flash name.

And then there was Gemini 3.5 Pro. Google showed it at I/O in May and said it would roll out the next month. By Alphabet's July 22 earnings call, it was still in testing.

So when Google says Argon is "the next era of frontier intelligence," the fair response is: show me. The good news is that this time, a lot of the proof comes from people who don't work at Google.

This article pulls together two deep-dive breakdowns, AICodeKing's benchmark analysis and Wes Roth's launch coverage, which between them cover Google's announcement, its evaluation footnotes, and independent results from Artificial Analysis, Vals, Zapier, Surge, LMArena and the CWE-Bench team. Neither creator had hands-on access yet. Neither do most of us.

You probably can't use it yet

Argon is launching through Google's Fairwind program, which means selected cybersecurity partners get it first. Paid API customers and Google AI Ultra subscribers are next in line, but Google hasn't given a public release date.

So don't buy an Ultra subscription today expecting Argon tomorrow. Given the Gemini 3.5 Pro delay, waiting for real availability before getting excited is just common sense.

The price has a catch

Argon's launch price is $2 per million input tokens and $10 per million output tokens, with a 95% discount on cached input. Read the footnote, though: after an introductory period, it becomes $4 and $20. That's double, and Google hasn't said when the promo ends. Wes Roth's bet is that the launch price won't last long.

Here's how that sits next to the Gemini models that came before it (per million tokens):

At standard pricing, Argon costs 8x Gemini 3 Flash on input and nearly 7x on output. That's expected for a flagship, but it means Google is not competing on cheapness anymore. If you're building an app, budget at $4/$20 and treat the launch price as a bonus.

Price per token is the wrong number

The more important figure is what a whole task costs. Artificial Analysis ran its full intelligence index and got this:

So Argon is cheaper than Astra at launch and more expensive than Astra once the promo ends. Soul costs a fraction of either and scores only one index point lower.

The reason is verbosity. Argon generated around 62,000 output tokens per task, versus about 27,000 for Astra. A lower unit price doesn't help much if the model writes more than twice as much.

Vals tells a slightly different story. Even at the standard price, it puts Argon at roughly $15.68 per test, versus $21.34 for Sonnet 5.5 and $32.14 for Opus 5.5. Then again, Vals still ranks Argon below Sonnet and Opus on cost per test in other cuts of its data. Different workloads, different bills.

The practical lesson: measure the cost of the finished job. What does it cost to get one patch accepted, or one workbook checked, including retries?

Where it's genuinely great: professional work

This is the part of the launch that holds up, and it holds up because outside testers back it.

The overall picture

On Artificial Analysis's Intelligence Index, Argon at high reasoning scores 53. That ties GPT-6 Astra at max reasoning and beats GPT-6.1 Soul by a point. Anthropic still leads this one: Opus 5.5 scores 58 and Sonnet 5.5 scores 56, both at max with default fallback routing for refusals.

Keep in mind these are index points. A 53 doesn't mean it finishes 53% of your work, and a one-point gap won't be noticeable on most tasks.

On the Vals Index, Argon takes first place with 68.9%, ahead of Sonnet 5.5 and Opus 5.5 at about 67% each. Wes Roth's read of the chart puts GPT-6 Astra around 63% and Fable 5.1 around 66%. The catch: Vals weights finance, coding, legal and tax by their share of the US economy, and finance is a little over half the index. If you mostly write code, this headline overstates Argon's value to you.

Example 1: Running business workflows

Zapier's AutomationBench is the result I'd point to first. It drops an agent into simulated business apps and checks the records it actually leaves behind. Saying "done" earns nothing; every required check must pass.

Argon at high reasoning scores 51.29%, versus 44.75% for Sonnet 5.5 at max. In Google's own chart, the other competitors sit roughly between 31% and 42%. That's a clear lead.

But look at it from the other side: about half the tasks still fail at least one check. Think of Argon as a strong assistant for things like updating CRM records, moving data between tools, or processing tickets. Then verify the results. It is not ready to run a business unsupervised.

Example 2: Spreadsheets

On Surge's GDP.xlsx spreadsheet benchmark, Argon scores 38.3%, against 30.3% for Opus 5.5 and 29.1% for Sonnet 5.5. It's rubric-based, so this isn't "38% of spreadsheets done perfectly." It is an eight-point lead over the best of the rest.

The real test will be a messy financial workbook where the model has to chase references across sheets and explain how it got each number. Checking a few easy cells won't be enough.

Example 3: Finance

On Vals Finance Agent v2, Argon scores about 65%, versus roughly 53%, 58% and 58% for the competitors in Google's chart. Think analyst work: reading filings, pulling numbers, building comparisons.

Example 4: Legal, with a footnote

On Harvey's legal agent benchmark, Argon posts 19.6%. Against the models Google chose for its chart, which score roughly 3% to 6%, that looks like a blowout. But Vals' own Argon report lists it fifth on the Harvey evaluation. It's a real result, just not proof that Argon leads the whole field in legal work.

Put it all together and the professional-work pitch is credible. These wins come from Zapier, Surge, Vals and Artificial Analysis, not just from Google's slides.

Coding: don't trust it blind

Here's where the story gets messy. Argon isn't bad at coding. It's inconsistent, and inconsistency is exactly what you can't afford from a coding agent.

Google's own table contradicts itself

One coding test says Argon wins. Two say it trails by 7 to 10 points. Wes Roth also notes it wins Vibe Code Bench, while sitting mid-pack on Frontier SWE and Terminal-Bench. Which test you pick changes the answer, and that's the problem.

The headline win comes with an asterisk

Google ran Argon's Deep SWE score using the mini-SWE-agent harness. Astra's number came from the public leaderboard, and Claude's came from Anthropic's system cards. Those are separate setups. Until someone runs all three models in the same agent harness, you can't credit every point of difference to the model.

Independent coding results are close, not dominant

Vals puts Argon second on both its app-building and code-migration benchmarks, behind Sonnet 5.5. That's respectable. But on app building, the gap is under half a percentage point, inside the reported standard error. Calling one model first and the other second there is basically a coin flip.

What this means in practice

For debugging, terminal work and hard multi-file repository changes, nothing here says Argon will beat your current agent. Remember Gemini 3.1 Pro: great scores, then duplicated methods and broken builds in real agent runs.

Where Argon does deserve a real trial is migrations and app building, and anything your current model keeps failing on. Run it on that, then compare the final result and the total bill.

And don't just count how many rows Google wins. Better chart reading and better repository fixing are not interchangeable when you're choosing what writes your code every day.

The questions worth asking once access opens:

1. Does it finish changes without quietly dropping requirements?
2. Can it recover after an approach fails?
3. Does giving it more thinking time improve the patch enough to justify the extra tokens?

The most interesting result: it admits when it doesn't know

Artificial Analysis reports a 15% hallucination rate for Argon on its AA-Omniscience test. That's the lowest of any model scoring at least 45 on its index. GPT-6 Astra at max sits at 51%.

But Argon's knowledge accuracy on the same test is 50%, against Astra's 63%. Fewer right answers, far fewer made-up ones. How?

The definition explains it. The hallucination rate only looks at answers that weren't correct, then asks how often the model confidently gave a wrong answer instead of a partial answer or "I don't know." Correct answers aren't counted at all.

So 15% does not mean 15% of what Argon says is false, and Google hasn't solved hallucination. It means that when Argon doesn't know, it's much more likely to say so.

For research, that's a trade worth taking. A confident answer with an invented API or a fake citation can burn an afternoon. The open question is whether this honesty survives in browsing and coding, where the model can check things with tools.

The other signals

LMArena. On the September 30 text leaderboard, Argon (high) is number one with a score of 1525 from about 4,900 votes, marked preliminary. People like its answers. That also explains how a model can feel excellent in chat without topping every technical test. Human preference, factual knowledge and fixing a codebase are three different skills.

A 1 million token output limit. This is output, not input: roughly 16 times Gemini's previous output ceiling. It gives the model room to keep reasoning on hard problems. Artificial Analysis tested a feature called long decode continuation, which pauses a long response and resumes it through follow-up calls so reasoning can reach that limit without timing out. You don't need a million tokens for a small bug fix. For a hard optimization problem with a result you can verify, the extra time may be worth paying for.

Long context. On Google's GraphWalks test, covering 256,000 to 1 million tokens of context, Argon scores 84.2 F1 against Astra's 71.8. Promising for tracking relationships across huge inputs, though one graph benchmark can't prove it understands every large repo.

Video, with a footnote. Google reports 91.7% on LVBench. But Gemini was fed one frame per second while competitors got fixed frame caps because of their API limits. That's a practical edge for Gemini, not a fair test of visual reasoning.

Cybersecurity. On CWE-Bench v1, Argon ties Astra and Grok 4.7 at 68% on the programmatic single-attempt measure. On the separate judge-panel measure, Opus 5.5 wins, 67% to Argon's 62%. The benchmark lists about $63 per rollout for Argon and $79 for Opus, but with different agent harnesses and a cached-input price that differs from Google's launch discount. Don't treat that as a universal cost ratio.

Speed. Unknown. Artificial Analysis hasn't published an output speed for Argon, and Vals' task durations don't tell you how responsive the public service will feel in your editor.

What Google is already doing with it

Google's most interesting claims aren't benchmark scores. They're about work Argon is already doing inside the company.

Quantum algorithm optimization. Argon is helping researchers cut the space-time resources quantum algorithms need. In one case, it beat a published baseline by 40% in minutes. This fits Google DeepMind's track record: AlphaEvolve, an LLM-driven system, has already squeezed savings out of data center operations and job scheduling at Google's scale, where small gains add up to millions of dollars.

Memory efficiency. Google says Argon greatly improved memory efficiency in its systems.

Migrating C and C++ to Rust across Google. This is the claim that matters most for the coding debate. Teams of Argon agents are helping move Google's C/C++ code to Rust, a huge project where one subtle bug can break things. Google says it's backed by large-scale automated and manual auditing plus emulation testing, so nothing ships on faith. Still, trusting it with this job says something.

libgav1, the video decoder. Argon agents took an existing Rust port of Google's open-source AV1 decoder and replaced 32,000 lines of code. They ran repeated profile-guided experiments, studied the compiler output, and wrote safe Rust that the compiler could vectorize automatically.

The pattern is a swarm of agents forming hypotheses, testing them against a metric and keeping what works, much like Andrej Karpathy's auto-researcher idea. Give it a measurable target and it can grind around the clock.

One honest caveat from Wes Roth: we don't know if these are the three wins out of a hundred attempts, or if Argon succeeds at most things it touches. Note also that these are carefully supervised, measurable tasks, which fits the "test it, verify it" verdict on coding rather than contradicting it.

The secret weapon in the micro kitchen

Business Insider, citing eight current and former employees, reports that Sergey Brin has gained more influence over Gemini while working out of a converted micro kitchen in Mountain View. He holds no executive title and no office, and he's reportedly focused on improving the models, especially coding. Google hasn't commented.

It's a fitting image. Brin and Larry Page built Google's first servers themselves with a $10,000 check from Stanford's digital library project.

Why a strong Google is scary for rivals

Google doesn't just have a model. It has its own TPU chips, huge cash flow from Search, and Project Suncatcher, a test of putting TPU data centers in space: a two-satellite constellation linked by lasers and powered by solar panels, with the next milestone planned for 2027.

Wes Roth also points out that Google, as far as we know, hasn't been caught benchmaxing (training a model specifically to ace tests without improving it generally). It does choose flattering comparisons, as the legal and video footnotes show, but that's selective presentation rather than juiced scores.

Meanwhile, OpenAI went enterprise

Argon landed right after OpenAI's Dev Day, and the contrast is telling. Google pitched raw capability. OpenAI pitched becoming part of how work gets done. Nothing there was revolutionary, but almost all of it targets businesses.

• Dots. A persistent assistant in the cloud that knows your context, takes on responsibilities within limits you set, and keeps working while you're away. SMS support is coming, so you can text your Dot. It echoes OpenClaw, whose creator Peter Steinberger now works at OpenAI, and xAI's Grokbot. Elon Musk apparently bought dot.com, which now redirects to Grokbot.
• Specialist Dots for organizations, such as one that handles expense reimbursements, plus integration with Microsoft Agent 365.
• GPT-6.1 Soul. Fast, cheap and capable, part of a wider trend. Anthropic made Sonnet 5.5 its free tier, and it lands close to Opus 5.5, which itself lands close to Fable 5.1. For everyday grunt work like spreadsheets and analysis, you don't need frontier-class intelligence.
• Ultra Fast mode. Up to 8x faster than standard mode, available only on the new $500/month Pro 500 plan at launch, not on Pro 100 or Pro 200. Wes jokes that GPT-6 Astra on ultra at ultra-fast could burn a weekly allowance in an hour.
• Decisions API. Uses OpenAI's Luna model to pick from a fixed set of answers to user-defined questions, using text or images. Think classifying content, routing requests, or choosing an agent's next move. It's OpenAI's answer to Jev, a decision engine that outputs probabilities instead of text. Jev decides in about 40 milliseconds and costs pennies for thousands of calls; Wes had it play Tetris, Minesweeper (nearly 5,000 decisions in seconds, 474 cells cleared, 69 flags) and a resource-gathering game.
• Agents API with computer use. OpenAI-hosted agents with their own virtual computer that can click through interfaces, for example to stress-test a website.
• Bedrock managed agents powered by OpenAI, so AWS customers can run OpenAI agents where they already work.
• Codex in the cloud that runs 24/7 without your computer on.
• Private intelligence with zero data retention and private safety processing.
• ChatGPT Spaces to centralize an organization's knowledge for its agents, plus Pages for collaborative documents with sharing and comments, much like Google Docs.
• Plugins. A plugin creator, better discovery and MCP connections to tools like Blender, ElevenLabs, Unity and Unreal. It's essentially a relaunch of the GPT Store, which flopped, but now with models that can actually use software.

Wes's practical takeaway applies to any model: turn your repeated daily tasks into skills. A skill.md file is plain English, so it carries over when you switch models or a better one comes out.

The verdict

Google is back, at least on paper, and this time the paper isn't only Google's.

Gemini 4 Argon is a credible contender after a run of disappointments. What will actually win back trust is consistent results in the tools people use every day.

Sources

• AICodeKing, "Gemini 4 Argon (In-depth benchmark analysis): Did Google make a big comeback?" (YouTube transcript)
• Wes Roth, Gemini 4 Argon and OpenAI Dev Day coverage (YouTube transcript)

The transcripts were auto-generated and garbled some names and numbers. They've been corrected here where the meaning was clear.