Gemini 4 Argon in Claude Code: Verified Claims, Real Costs, One Crash

Gemini 4 Argon reached general availability on October 13, and the independent numbers look good. Vals AI ranks it first on the Vals Index, above Claude Opus 5.5, at about half the cost per test.¹ So I gave it a real job on the day it shipped: build a 60-second Brain Bytes Short, end to end, inside Claude Code. It wrote the script, generated the narration, built the animation, rendered the video and passed all 30 of our QA checks. Then I watched it, and it wasn’t shippable. The benchmarks predicted Argon’s discipline. They didn’t predict its sense of space on a screen. And the route I used, Claude Code talking to Argon through OpenRouter with no proxy, works right up until one specific request shape kills the session.

This is the Short about Argon, made by Argon and then fixed by Opus 5.5. Its content is the verified-versus-vendor-reported picture in the next sections.

Hypothesis

I wrote the test plan down before running anything. It made two predictions.

1. The route works. Claude Code can drive google/gemini-4-argon through OpenRouter’s Anthropic-compatible endpoint with no translation proxy. The main risk is multi-turn tool use: Gemini attaches thought signatures (encrypted reasoning state) to its turns, and those have to survive the Anthropic-to-Gemini translation, or the second tool call fails.
2. Argon can produce a Short on our pipeline. Score it on whether it renders without manual fixes, fits the duration budget, matches the brand, and what it costs in turns, tokens and money. Run the same brief through the default Claude harness as a baseline.

One deviation up front: the baseline never ran. I stopped the test after Argon’s production run, and Opus 5.5 fixed Argon’s output instead. So the Opus comparison below is my judgment against the Shorts Opus normally produces for this site, not a controlled A/B.

Setup

What Argon is, and who says so

Google announced Argon on September 30 and limited it to “trusted cyber defenders” in its Fairwind Program.² Two weeks later it opened the model to paid Gemini API customers, enterprises, and AI Pro and Ultra subscribers.³ Most of what’s been written about it since mixes Google’s own figures with independent ones. Separated, they look like this:

Claim	Figure	Source
Price per 1M tokens	$2 in, $10 out; $4 / $20 after Nov 30	Google, OpenRouter, Artificial Analysis345
Context window	1,048,576 tokens, input and output shared	Google, OpenRouter, Vals615
Max output	1M; 262,144; 65,536; 943,718	Conflicting2315
DeepSWE v1.1	77.9%	Google only, no rivals listed2
Vals Index	68.90% (#1); Opus 5.5 66.97%	Vals AI1
Cost per Vals test	$15.68; Opus 5.5 $32.14	Vals AI1
Harvey’s legal benchmark	Google: “leading”; Vals: 19.58%, 5th or 6th	Disputed21
Intelligence Index	53 (median 27); 110M tokens (median 85M)	Artificial Analysis4

The output limit is the one to understand before you build on it. Google’s launch post says “1M output.” Its developer guide is more specific: a single request caps at 65,536 output tokens when streaming and 32,768 when not. Getting toward 1,048,576 means looping on a continuation token that the response hands back, and that loop exists only on the GenerateContent API. It isn’t on the newer Interactions API yet, and the guide says older SDKs and Google’s OpenAI compatibility layer can’t retrieve long completions.⁶ Through the route I used, OpenRouter lists a 65,536-token output cap on its Google endpoint, so plan for the per-request limit.⁵

The same guide lists changes that will break code ported from older Gemini models. Argon ignores temperature, top_p and top_k. It returns HTTP 400 for thinking_budget, for a MINIMAL thinking level, and for frequency and presence penalties. It doesn’t support explicit context caching, and a chat history can’t end with a model turn.⁶ That last rule matters later. One small conflict: the Interactions API reference still lists minimal as a valid thinking level.⁷

The harness

OpenRouter now exposes an Anthropic-compatible endpoint, so Claude Code can talk to it directly. Its documentation guarantees that only for Anthropic models.⁸ I wrote a small launcher that points every Claude Code model slot at Argon. Without that, background calls and subagents fall back to Claude. It also uses a separate config directory, so my normal login, memory and plugins stay out of the run:

: "${OPENROUTER_API_KEY:?Set OPENROUTER_API_KEY (use a key with an OpenRouter spend limit)}"
model="${ARGON_MODEL:-google/gemini-4-argon}"
export CLAUDE_CONFIG_DIR="${ARGON_CONFIG_DIR:-$HOME/.claude-argon}"
export ANTHROPIC_BASE_URL="https://openrouter.ai/api"
export ANTHROPIC_AUTH_TOKEN="$OPENROUTER_API_KEY"
export ANTHROPIC_API_KEY=""
export ANTHROPIC_DEFAULT_OPUS_MODEL="$model" ANTHROPIC_DEFAULT_SONNET_MODEL="$model"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="$model" CLAUDE_CODE_SUBAGENT_MODEL="$model"
export CLAUDE_CODE_MAX_CONTEXT_TOKENS="${CLAUDE_CODE_MAX_CONTEXT_TOKENS:-1048576}"
exec claude --model "$model" "$@"

The last export is there because Claude Code 2.1.296 doesn’t recognize Argon. It warned that it would assume a 200k context window and compact the conversation at that size. The Short pipeline is the one our Opus-built Shorts use: Kokoro-82M narration, faster-whisper word timings, captions from a pinned toolchain, Remotion 4.0.496 for the animation, and a QA script with 30 checks on loudness, sync, captions and pixels.

I ran the whole thing from a separate Claude Code session on Opus 5.5. That session built the harness, launched Argon headless (claude -p), reviewed its output and did the v2 fix. Argon never saw that session or my memory files.

Procedure

1. Dead ends before the first real call. The old proxy config on my machine turned out to be a tool that works in the opposite direction (it exposes a subscription as an API), so I dropped the proxy idea. A test with a fake key looked like a hang: Claude Code makes up to 11 attempts on a 401, backing off each time, before it gives up. A real but deleted key returned 401 User not found. And my first smoke run never reached the model: --allowedTools takes a variable number of values, and it swallowed the prompt as a tool name.

2. Smoke test. One prompt that needs three tools: write fib.py, run it, read it back, report the 30th Fibonacci number.

3. Proposal. With file tools only, Argon wrote a script and storyboard for a Short about itself. Its only source was my research brief, and its base was an existing Opus-built Short.

4. Revision. I sent five editor notes back, the way I would to a human writer, and it revised.

5. Production. Argon got shell access limited to Python, Node, Remotion, ffmpeg and the two speech environments, with git, network, installs and rm -rf blocked. It narrated, timed, captioned, animated, rendered and ran QA.

6. Stop and fix. I watched the result, stopped the test, and had Opus 5.5 fix the Short as v2.

Results

Stage	Turns	Time	Outcome
Smoke test	4	20 s	Pass: correct answer (832040), with two tool calls issued in parallel
Proposal	40	6.9 min	Grounded and well sourced; five editorial misses
Revision	6	3.0 min	All five notes fixed
Production	70	11.9 min	Both renders done and QA 30/30, then the session crashed

The crash came right after Argon read rendered PNG frames back to check its own work:

API Error: 400 Requests ending with a model turn are not supported.

The renders and QA were already done by then. Only Argon’s README update was lost.

OpenRouter billed $11.56 for 69 Argon requests and 5.35M tokens. That’s about $2.16 per million tokens blended, which means almost all of it was input billed at $2 per million: Claude Code resends a large context every turn. Claude Code’s own cost estimates for the four runs added up to $25.65, about 2.2 times the real bill, because it doesn’t know Argon’s prices. It also showed zero tokens on every message. One gap I haven’t resolved: Claude Code logged about 120 turns, against OpenRouter’s 69 requests.

On the proposal, Argon cited real files every time. Every theme color, layout rectangle, animation component and test it referenced existed in the base Short. It separated Google-reported figures from independent ones without being asked, and it left out a “leads 13 of 18 benchmarks” claim that I hadn’t verified. The five misses were a wrong date (“prices double November 30” when they double after it), a cryptic benchmark line, a sentence that made too much of my smoke test, a hook missing “per million tokens”, and a duration estimate that counted script words instead of spoken ones. That last one matters because “65,536” is six spoken words.

The v1 render passed every QA check and still had these problems:

• The header line wrapped into the title.
• A date pill ran past the right safe edge.
• One card overlapped the card below it, and two lines collided in another scene.
• The pauses between narration beats were cut to 0.2 seconds.

The pauses were a decision, not a rendering bug. Argon’s narration came out too long for the 60-second cap, so it removed the half-second holds after four of the six beats and halved the gap between beats, after I’d approved a script with those pauses in it. It recorded the change in one status field and nowhere else.

The v2 fix took one Opus session. Opus fixed the four collisions and three more overflowing lines it found in guide stills, and cut seven spoken words to bring back 0.4-second pauses. The result runs 58.3 seconds, passes 30/30 QA, and has no collisions on a frame-by-frame contact sheet. Opus also caught a factual error, the median token count on Artificial Analysis (82M in the first render, 85M on the live page). That error was mine. The figure came from search snippets in my brief, and Argon used it faithfully.

Analysis

Hypothesis result: the first prediction was partly confirmed; the second was refuted.

The route works. Tool calls, parallel calls and multi-turn reasoning all survived the translation, so the failure I predicted didn’t happen. The failure that did happen is one I didn’t predict. Claude Code sent a request whose history ended on a model turn, and Google documents that Argon rejects that shape.⁶ My guess is that image results from tool calls got translated into that shape, since the crash followed Argon reading PNGs back. I haven’t confirmed that. If you route Claude Code to Argon, keep sessions short and expect long agentic runs that look at images to break.

The creative test failed on my own criteria, because v1 needed fixes by hand. The failures follow a pattern. Argon was excellent at everything that can be checked against text: sources, file references, schemas, the existing pipeline, editor notes. It was weak at everything that needs a check it didn’t have. It sized text for an 888-pixel column without measuring it. It treated “fit 60 seconds” as a constraint to satisfy, not a trade-off to raise. And it estimated duration from a proxy (script tokens) instead of the real quantity (spoken words). QA’s 30/30 made that worse, because our checks test captions, audio and safe areas but not whether two elements overlap. A passing suite told Argon it was done.

The cost result is the one I’d generalize with the most confidence. Agent harnesses resend context every turn, so input price dominates the bill, and a model with a cheap input rate looks cheaper in a harness than its headline output price suggests. Argon’s introductory $2 per million input is the reason this run cost $11.56. Thinking tokens are priced together with output tokens, so a harder thinking level raises the other side of the bill.⁹ After November 30 the same run would cost about twice that.³ Read the real number from the provider’s dashboard. The harness’s own estimate was wrong by more than a factor of two.

If you’re putting Argon into your own stack this week:

• Treat 65,536 tokens as your per-request output ceiling unless you’re on GenerateContent with continuation tokens.⁶
• Remove temperature, penalties and thinking_budget from ported code before you debug anything else.⁶
• Don’t end a history on a model turn, and don’t prefill model turns.⁶
• Budget for the price doubling after November 30.³
• Add a check for visual collisions to any QA you hand to an agent. A suite that passes tells the agent it’s finished.

Reproducibility Notes

• Model/tool versions: google/gemini-4-argon via OpenRouter (listed 2026-10-13 16:04 UTC), default thinking level; Claude Code 2.1.296; Remotion 4.0.496; Kokoro-82M (kokoro 0.9.4, voice af_bella); faster-whisper small.en 1.2.1; shorts toolchain at commit 0b59d61; fixes by claude-opus-5-5.
• Random seed: none. Argon’s API ignores sampling parameters, and Kokoro isn’t bit-deterministic between runs.
• Hardware: local Linux workstation (Fedora), CPU narration and rendering; the model ran on Google’s infrastructure via OpenRouter.
• Dataset: research brief and claim ledger in the site repo at .planning/research/gemini-4-argon-claude-code-test-brief.md, with sources fetched 2026-10-13.
• Run count: one run per stage (smoke test, proposal, revision, production); one Opus fix session.
• Repo: launcher scripts/argon-claude.sh; Short source and README (including every change made after approval) at .planning/episodes/gemini-4-argon/short/.

Footnotes

1. Vals AI. “Gemini 4 Argon.” Evaluated September 30, 2026; accessed October 13, 2026. vals.ai/models/google_gemini-4-argon. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷

2. Koray Kavukcuoglu. “Gemini 4 Argon: our next era of frontier intelligence.” Google, September 30, 2026. blog.google/innovation-and-ai/models-and-research/gemini-models/gemini-4-argon. ↩ ↩² ↩³ ↩⁴

3. Google. “Gemini 4 Argon: Built to solve your hardest problems.” October 13, 2026. blog.google/innovation-and-ai/models-and-research/gemini-models/introducing-gemini-4-argon. ↩ ↩² ↩³ ↩⁴ ↩⁵

4. Artificial Analysis. “Gemini 4 Argon (High).” Accessed October 13, 2026. artificialanalysis.ai/models/gemini-4-argon. ↩ ↩²

5. OpenRouter. “Gemini 4 Argon” model listing and endpoints. Accessed October 13, 2026. openrouter.ai/google/gemini-4-argon. ↩ ↩² ↩³ ↩⁴

6. Google Cloud. “Developer’s guide to Gemini 4 Argon.” Accessed October 13, 2026. docs.cloud.google.com/gemini-enterprise-agent-platform/models/guides/gemini-4-argon. ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷

7. Google AI for Developers. “Gemini Interactions API.” Accessed October 13, 2026. ai.google.dev/api/interactions-api. ↩

8. OpenRouter. “Claude Code Integration.” Accessed October 13, 2026. openrouter.ai/docs/cookbook/coding-agents/claude-code-integration. ↩

9. Google AI for Developers. “Gemini thinking.” Accessed October 13, 2026. ai.google.dev/gemini-api/docs/thinking. ↩