Gemini 4 Argon vs Opus 5.5 vs GPT-6 Astra: Same Prompt, Real Bills

Gemini 4 Argon, Google’s new frontier model (generally available October 13, 2026), built a 3D car in Blender from one picture, by itself. Then I gave Argon, Claude Opus 5.5 and GPT-6 Astra the exact same prompts: a Lamborghini in pure code, a one-shot 3D kart game, an animated SVG and 82 labelled questions. Argon made the best-looking cars and was the fastest and 2.3x cheaper on the kart game; the Blender job cost $22.13. This is the written companion to my video, with every number and the two settings that make Argon work in opencode.

Watch the video: Gemini 4 Argon vs Opus 5.5 vs GPT-6 Astra: I Gave Them the SAME Prompt.

Key facts (quick answer)

Fact	Measured result
Image to 3D car in Blender	Argon: 43 objects, working lights, turntable rig, 240 frames; $22.13 on my API key
Same Lamborghini prompt, 3 agents	Argon (opencode) 2,540 lines; Opus 5.5 (Claude Code) 1,166 lines in 14 min 39 s; Astra (Codex) 193 lines in 9 min 17 s
One-shot 3D kart game (OpenRouter)	Argon 220.6 s, $0.306, works; Astra 323.4 s, $0.704, 10/10; Opus cut off at 32,000 tokens
82 labelled questions	Argon 82/82, Astra 82/82, Opus 81/82 (1 format miss)
Price	$2 in / $10 out per 1M tokens until Nov 30, 2026, then $4 / $20
Context	1,048,576 tokens; text, image, video, audio, PDF in; text out

TL;DR

• Argon turned one reference sheet into a 43-object 3D car in Blender, with lights and a turntable rig.
• That Blender session cost $22.13: 10,203,143 input tokens, only about 4% from cache.
• On the Lamborghini test, Argon wrote 2,540 lines for one car; my pick for car design, weakest on driving feel.
• One-shot kart game: Argon 220.6 s and $0.306, Astra 323.4 s and $0.704 (10/10), Opus cut off.
• In opencode, set headerTimeout 1800000 and OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX=65536.
• On 82 one-word questions Argon and Astra scored 82/82; Argon was the slowest (3.355 s median).

How did Gemini 4 Argon build a 3D car in Blender?

One image, then Argon did the modelling itself. Codex made a single reference sheet of a lime supercar from the front, side, back and top. I gave that one image to Argon running in opencode, connected to Blender through an MCP server.

Argon read the picture, built the body, wheels, wing and glass part by part with Python, checked snapshots against the sheet, and ended with 43 objects. When I asked for working lights it added headlights and taillights; then a turntable rig and a 240-frame camera move, rendered in Blender.

What did it cost?

$22.13 on my Gemini API key, counted by opencode: 61 steps, 10,203,143 input tokens, 126,819 output tokens, 41,620 reasoning tokens and 419,360 tokens read from cache (about 4%). Every step resent the whole conversation, images included. Keep agent sessions short and keep the start of the prompt the same so implicit caching can help (Google applies it to shared prefixes of 6,144 tokens or more).

The Lamborghini test: three coding agents, one prompt

Same prompt, three agents side by side in AnvilTerm: Argon in opencode, Opus 5.5 in Claude Code, Astra in Codex. The prompt: a detailed 3D Lamborghini-style supercar made entirely in three.js code (no model files) driving down an endless neon highway, with a chase camera, speedometer, turbo with exhaust flames, 6 paint colours and an orbit mode.

Agent	Time	Lines	Billing
GPT-6 Astra (Codex)	9 min 17 s	193	subscription (about $3.30 at OpenRouter list prices)
Claude Opus 5.5 (Claude Code)	14 min 39 s	1,166	subscription (about $14.14 at list prices)
Gemini 4 Argon (opencode)	first file in about 7 min, then 17 min of self-testing	2,540	$2.45 charged on my API key

My pick for car design is Argon: the wedge, the Y-shaped lights and the wing. Its driving feel is where it is weakest.

Two opencode settings for Gemini 4 Argon

Argon did not work in opencode on the first try, and both fixes are one line.

1. Argon can think for more than 5 minutes before its first token, and opencode gave up with ProviderHeaderTimeoutError. In ~/.config/opencode/opencode.json: "provider": {"google": {"options": {"headerTimeout": 1800000, "chunkTimeout": 1800000}}}.
2. opencode (1.19.0) caps every reply at min(model limit, 32000) output tokens. Argon writes the whole file in one reply, so three runs ended with finish: length at exactly 32,000 tokens and the file was silently dropped. Start it with OPENCODE_EXPERIMENTAL_OUTPUT_TOKEN_MAX=65536 opencode -m google/gemini-4-argon.

With both settings the next run wrote the 2,540-line car.

Update for opencode v2: in opencode v2 (I checked the 2.0.28 code) the reply limit is the model’s own limit.output (capped at 256,000) instead of a fixed 32,000, so the environment variable is no longer needed: set "gemini-4-argon": {"limit": {"output": 65536}} under provider.google.models in opencode.json. Google’s default output limit for Argon is 65,536.

Gemini 4 Argon vs Opus 5.5 vs GPT-6 Astra on a one-shot kart game

Argon was the fastest and cheapest; Astra was the most complete. One API call each through OpenRouter, reasoning on, max 32,000 tokens, cost from OpenRouter’s own usage.cost.

Model	Seconds	Cost	Result
Gemini 4 Argon	220.6	$0.306	works, 9.5/10
GPT-6 Astra	323.4	$0.704	10/10
Claude Opus 5.5	307.6	$0.641	cut off at 32,000 tokens (20,770 of them reasoning)

For long one-shot code with Opus, give it a smaller thinking budget so the answer fits.

Which model drew the best Lamborghini SVG?

Argon, at high thinking. Opus drew a clean retro wedge and Astra a tidy sports coupe; Argon’s drawing had the sharp cut lines and a blue exhaust flame (263.7 s, 16,271 output tokens).

How accurate is Gemini 4 Argon on simple decisions?

82 out of 82. 82 labelled questions, one exact word expected, same harness as my decision-model video.

Model	Correct	Median time	Cost for 82
Gemini 4 Argon	82/82	3.355 s	$0.220
GPT-6 Astra	82/82	1.701 s	$0.105
Claude Opus 5.5	81/82	2.410 s	$0.069

Opus’s one miss was format, not logic: it explained the answer before giving it.

What does Google’s own table say?

Google reports Argon ahead on agentic coding and long context, not everywhere. These are vendor-reported numbers from Google’s launch page.

Benchmark (Google)	Argon	Opus 5.5	Astra
DeepSWE v1.1	77.9%	74.2%	74.1%
GraphWalks 256k-1M	84.2%	66.8%	71.8%
Terminal-bench 4.0	57.4%	66.4%	58.2%
FrontierSWE v2	55.0%	62.3%	65.5%

Caveats

• The three agents ran in different tools (opencode, Claude Code, Codex) with each tool’s own system prompt, so the Lamborghini test compares agent setups, not bare models.
• Claude Code and Codex ran on subscriptions; their dollar figures are the same tokens at OpenRouter list prices. Argon’s costs are what my API key was charged.
• Argon needed 6 fresh opencode sessions before a file landed: 2 hit the timeout and 3 hit the 32,000-token cap described above.
• One run each per test; model outputs vary from run to run.

My take

For anything visual (3D scenes, Blender, drawings) Argon gave me the best-looking results, and it was the fastest on the one-shot game. For a complete, polished app in one reply, Astra was the most reliable. Opus in Claude Code was the one that just worked with no settings. If you run Argon as an agent, watch the bill: the same session that made the Blender car resent ten million tokens.

Sources

• Google, “Gemini 4 Argon: Built to solve your hardest problems”, October 13, 2026 (benchmark table, vendor-reported)
• Gemini API model page and pricing page for gemini-4-argon (read October 13, 2026)
• My logs: opencode session database, Claude Code and Codex session files, OpenRouter usage.cost for every benchmark call

Independent review by Anass Kartit. Not affiliated with Google, Anthropic or OpenAI. Video made with ZArchitect.