Google’s launch post for Gemini 4 Argon carries a 19-row benchmark table, and by our count of that table Argon leads 13 rows outright and ties one. The five it loses are not random. GPT-6 Astra takes FrontierSWE v2, Terminal-Bench Science and OSWorld-2.0; Claude Opus 5.5 takes Terminal-bench 4.0 and PostTrainBench. They are both Terminal-Bench rows, an agentic-coding row, the ML-engineering row and one of the two computer-use rows: much of the work a coding crew actually spends its runs on. And the question is no longer hypothetical. Since October 13, 2026, Argon has been generally available on the paid Gemini API as gemini-4-argon.
So “which model wins?” has three answers depending on the row, and for a team running several coding agents that is not trivia. If every Agent on the board runs on the same Runtime, the team inherits one lab’s losses along with its wins, and every launch reopens the argument. Which agent is on what, what finished, what needs review: none of that should depend on who topped a table this week.
TL;DR
No frontier lab owns every row, not even on its own table. Treat each launch as evidence for routing, not a reason to migrate: keep more than one Runtime connected, write the routing rule down (a default, the conditions that send a Task to a different Agent, and who reviews), and test it on three Tasks from your own codebase. Astra runs through Codex, Opus 5.5 through Claude Code, and Gemini models through Gemini CLI with a paid key. Google hasn’t said Gemini CLI supports Argon, so smoke-test gemini-4-argon before it takes real Tasks.
What Google’s table says, by task type
The rows that matter for coding agents, grouped by Google’s own categories:
| Task type (Google’s category) | Row | Leader on Google’s table | Caveat |
|---|---|---|---|
| Agentic coding | DeepSWE v1.1 | Argon 77.9% (Opus 5.5 74.2%, Astra 74.1%) | Argon self-computed |
| Agentic coding | FrontierSWE v2 | Astra 65.5% (Opus 5.5 62.3%, Argon 55.0%) | Proximal leaderboard |
| Agentic coding | Terminal-bench 4.0 | Opus 5.5 66.4% (Astra 58.2%, Argon 57.4%) | Argon self-computed |
| Agentic coding | Vibe Code Bench | Argon 91.9% (Opus 5.5 90.3%, Astra 89.6%) | 2.3 points separate all four models |
| ML engineering | PostTrainBench | Opus 5.5 49.3% (Argon 45.3%, Astra 44.3%) | Self-computed by Google for every model |
| Science and math | Terminal-Bench Science 0.1 | Astra 68.1% (Opus 5.5 63.3%, Argon 57.6%) | Argon run with a 6x verifier timeout |
| Computer use | OSWorld-2.0, offline subset | Astra 72.6% (Argon 69.2%) | No Opus 5.5 row |
| Computer use | Agent’s Last Exam | Argon 39.5% (Opus 5.5 38.2%, Astra 34.2%) | Argon self-computed |
| Long context | GraphWalks 256K to 1M | Argon 84.2% (Astra 71.8%, Opus 5.5 66.8%) | Self-computed for every model |
The agentic coding category alone has four rows and three different leaders. Argon’s clean sweep is in knowledge work, long context and multimodal rows, which matter less to a crew whose Tasks end in a diff.
Read it with one discount: this is Google’s table. Google ran Argon itself on several rows, the competitor numbers are mostly self-reported or taken from public leaderboards, and the harnesses differ. The evaluation methodology lists the source for every cell. Independent results since launch disagree with each other too: Scale AI’s Humanity’s Sixth Sense puts Argon first at 55.4% against GPT-6 Astra’s 53.6%, Cursor calls it on par with Opus 5.5 on its CursorBench, and Artificial Analysis ranks Argon (High) eighth of 216 listed variants as of October 15.
Price does not settle it either. Argon costs $2 per million input tokens and $10 per million output through November 30, 2026, then $4 and $20 from December 1. That later rate is exactly Opus 5.5’s. Astra lists at $10 and $50.
No lab owns every row, so no lab should own the whole board
The vendors’ data makes this argument, not ours. If Google’s own table, built by Google to show Google’s model, still hands five rows to two competitors, there is no single best model for coding agents. There is a best model for a kind of Task, for this quarter, on someone’s harness.
That changes launch day. The tempting move is a migration: switch the default Runtime, rewrite the setup, retrain everyone’s habits. The cheaper move is to treat the new model as one more candidate for the Tasks where its rows are strong, and leave the rest of the board alone. We have argued that the best coding agent matters less than how you manage the work; a table where three models each win something is that argument in numbers.
The honest decision pair:
- Keep one default Runtime when most of your Tasks look alike and one person reviews everything. A second Runtime is a second configuration to maintain, a second bill, and a second set of failure modes.
- Run two or three Runtimes when your Tasks split between shell-heavy work, UI verification and reading large codebases, because that is exactly where the table splits too.
Write the routing rule down
A routing rule in one engineer’s head is a habit, and habits do not survive a new hire or a launch week. Write it where the team can read it:
Routing rule v1 (re-test after every frontier launch)
Default
The Agent on your current default Runtime, until your own
comparison says otherwise.
Send the Task to the Claude Code Agent (Opus 5.5 set in Claude Code) when
- most of the work happens in a terminal: builds, CI repair, setup [Terminal-bench 4.0]
- it is training or evaluation plumbing for a model pipeline [PostTrainBench]
Send the Task to the Codex Agent (GPT-6 Astra set in Codex) when
- the change has to be verified by driving a desktop or browser UI [OSWorld-2.0]
- it is scientific or data work done mostly in a terminal [Terminal-Bench Science]
Send the Task to the Gemini CLI Agent (gemini-4-argon) when
- it needs a very large codebase or log read in one pass [GraphWalks]
- note: the 1M window is shared by input, thinking and output, and
Gemini CLI support is unverified. Smoke-test before this line routes work.
Escalate
If a run fails its acceptance checks twice, reassign the Task to the next
Agent in this rule. The failed runs stay on the Task as evidence.
Review
An Agent on a different Runtime from the author reads the diff and the
evidence. A person accepts the result.
Each condition names the row behind it and a Task shape you can recognize. The reviewer line matters most: a model checking a diff it did not write is a cheap second opinion, and the acceptance stays with a person.
Where the rule lives depends on who routes. If people pick the Assignee, it belongs in the Space’s written conventions. If a Crew leader routes, it belongs in the Crew instructions. Either way the result returns to the same Task, so the comparison history stays in one place. Which model for which coding task goes deeper on matching task shapes to model roles.
Test the rule on your own codebase before you trust it
A benchmark row puts a Task type on a candidate list; your repository decides the default. The method in how to compare coding agents on your own codebase fits this table well, because the table already tells you which three Tasks to pick:
- One terminal-heavy Task, such as a broken CI job.
- One Task whose change has to be checked through a UI.
- One question that needs a large part of the repository in context.
Give each Agent the same Task description and acceptance criteria, in Create temporary directory mode so each run gets its own worktree. Then score what returns to the Task, not what the agent claims: the diff, the checks and their results, the questions asked, and how long a person took to accept it.
Argon can enter this comparison now, once a one-line smoke prompt with gemini-4-argon passes in your Gemini CLI. Run the same three Tasks on it before changing anything else. The Opus 5.5 vs GPT-6 Sol default-runtime comparison walks through the cost-per-completed-task side of the same decision.
Where each model runs, as of October 15, 2026
| Model | Runtime | What it takes on a Computer | List price per 1M tokens (in / out) |
|---|---|---|---|
| GPT-6 Astra | Codex | Codex configured with Astra and an account or key that has access | $10 / $50 |
| Claude Opus 5.5 | Claude Code | Claude Code configured with Opus 5.5 and an account or key that has access | $4 / $20 |
| Gemini 4 Argon | Gemini CLI, unverified | A paid Gemini API key, gemini-4-argon as the model, and a passing smoke prompt |
$2 / $10 through Nov 30, then $4 / $20 |
| Other Gemini models | Gemini CLI | A paid Gemini API key, a Gemini Enterprise Agent Platform key, or a Code Assist Standard or Enterprise license | Varies by model |
The Gemini rows have a trap. Since June 18, 2026, Gemini CLI no longer serves Google AI Pro, Ultra or free Code Assist for individuals accounts, per Google’s transition notice. Pro and Ultra include Argon in the Gemini app, but a subscription is not an API key, and Argon has no free API tier.
Sharkly does not pick models. The Agents documentation says it directly: “The Agent follows the Runtime’s default model. It does not promise or display a specific model name.” You set the model through Custom arguments on the Agent or Runtime, or in the tool’s own configuration on the Computer. So “the Codex Agent” in the routing rule means an Agent on a Codex Runtime configured to use Astra.
The setup paths are in GPT-6 Astra in Sharkly, Claude Opus 5.5 in Sharkly, and, for the Gemini CLI configuration and the switch to Argon, Gemini 4 Argon for coding agents.
The table changes; the board shouldn’t
The next launch will redraw this table. What should stay put is everything around the model: the routing rule, the Tasks, the evidence each run returns, and the person who accepts the result. Agents research, execute, test, and report. People set direction, grant authority, and accept the result.
If you want to keep using multiple coding agents rather than committing to one ecosystem, that’s the problem Sharkly is designed around.
