Gemini 4 Argon vs Opus 5.5 and GPT-6.1 Sol: 12-Task Showdown, 3 Crash on Open

After a long silence following Gemini 3.1 Pro, Google finally unveiled Gemini 4 Argon. Bilibili creator "Back to Axton" put it head-to-head with Claude Opus 5.5 and GPT-6.1 Sol on the same exam—12 tasks spanning image reading, 3D animation, interactive tools, and mini-games, with identical prompts and no follow-up clarifications throughout. The results were dramatic: Argon went 0 wins, 5 draws, 7 losses against Opus 5.5, and 2 wins, 4 draws, 6 losses against GPT-6.1 Sol, finishing last among the three.

But more worth dissecting than the win-loss record is how it lost.

Three "Broken on Open" Tasks: Small Errors, Big Collapses

Railway Dispatch: One Line of Variable Scope Wrecks the Whole Page

The first task required building a model railway sandbox: at least three trains sharing one track system, with switches and signal lights, trains automatically changing tracks, stopping at red lights, fully unmanned and never colliding.

Opus 5.5 ran five trains with track crossings, going a full five minutes with zero collisions; GPT-6.1 Sol had three trains circling, equally stable. Argon's screen was pure black, with only one line of text: "4 Train Active, Collision 0"—it looked like it was running, but that was just hardcoded text, not real-time status.

Digging into the code revealed the root cause: a variable was defined inside another function, so when called it simply couldn't be found, and the entire script halted. Among the same 12 tasks, Opus and GPT used command-line Agents that could open pages to inspect and fix errors themselves; but when Axton tested Argon, he could only run it in the Gemini App—the Pro account hadn't yet been granted Anti-Gravity CLI terminal access, so even with thinking set to High, it could only write everything in one pass and submit—no room for self-verification.

According to Axton's unscored experiment, patching that scope issue made four trains run the full five minutes immediately; adding back a single missing space in the coffee shop code made all five pages update in sync instantly. Both tasks fell into the "one line of code can save it" category.

Variable Scope is a fundamental mechanism in programming languages that determines where in the code a variable can be accessed. Most languages use block or function scope: a variable defined inside a function is invisible outside that function or to other functions by default. When code in another function references that variable, the runtime throws an "undefined" error and the script stops executing. Such errors often don't cause a white-screen error page—instead they freeze all subsequent logic, leaving only the static text rendered earlier on screen. For AI-generated code, scope issues are especially insidious: the model writes call relationships from "memory" but cannot actually execute and verify during generation, so a single cross-function reference mistake can turn an entire interactive piece into a still screenshot. This is the most typical gap between "can write" and "can run."

Coffee Shop Quarterly Report: One Missing Space, Five Pages Dead

The task was to build a quarterly report for a coffee shop owner, five pages covering revenue, costs, profit, and next-quarter recommendations. Given data like average daily cups, average order value, cost ratio, and rent, plus a slider—dragging it must recalculate all numbers and conclusions in real time.

Page one calculated perfectly, and when dragging sales down to a loss, the conclusion changed accordingly. But page two was completely frozen, page five's numbers never updated, and the profit page stayed at 289080 no matter how you dragged. The cause: two words in the code were missing a space and got concatenated into a single identifier. Opus and GPT had all five pages updating in real time on this task; dragging Opus to 150 cups instantly changed the headline to "Approaching Break-even," and GPT's profit card turned from green to red when going into loss.

CLI Agent refers to an AI agent that can directly invoke tools, execute commands, read and write files, and observe results in a local terminal. Compared to a web chat window, it has one key extra capability: a self-verification loop—after generating code it can run it itself, see errors, locate problems, and revise, looping until it passes. This precisely explains the gap between the three models in this article. Opus 5.5 and GPT-6.1 Sol took the CLI Agent path during testing and could open pages to inspect and fix code after discovering "page two is frozen"; Argon at the time could only produce a one-shot draft in the Gemini App chat box, with no permission to execute or review, so once an error was written in, nobody corrected it. So the same 12 tasks weren't just testing model intelligence—they were testing whether the model was allowed to check its own homework.

Causes of the Seasons: A Nonexistent URL

This task was to build a 3D explanation correcting the misconception that "summer is hot because Earth is closer to the Sun," with Earth orbiting as you drag the date, showing real-time Sun-Earth distance, noon solar altitude and day length for Beijing and Sydney.

Argon referenced a URL that simply didn't exist, so the 3D scene wouldn't load, the slider wouldn't move, and the date and numbers stayed frozen at June 21. Opus and GPT both got it right: dragging to January 3, Opus popped an orange banner at the top of the screen—"Closest to the Sun, yet Beijing is in deep winter"—while GPT showed a small note in the bottom left.

Hallucinated Reference is a common error in large models: when external resources are needed, the model generates a URL, library name, or API that is correctly formatted and looks plausible but doesn't actually exist. It's not deliberate lying—it's a byproduct of language models continuing text probabilistically; a "URL-like string" is easier to generate than a "confirmed existing URL." In plain text Q&A, this error at worst leads to a 404. But in interactive web pages that need to load 3D models, textures, or third-party scripts, a fake link breaks the rendering pipeline directly: the scene won't load, and the sliders, dates, and values bound to it all lose their linkage, frozen at the initial state. The article's "3D explanation frozen at June 21" is the end of that chain, showing how important verifying online resources for generative code is.

Butterfly, Origami, and Covers: The Deciding Details

The mechanical butterfly was the most interesting task for showing the gap between the three. The requirement was to 3D-model a butterfly with hollow metal-glass wings, gear linkages driving the wings, and a disassembly button. Opus's blue glass wings and GPT's glass-with-gold-wire specimen were quite refined; Argon's golden gear butterfly was the most stunning at first glance—the gears actually meshed and rotated according to tooth count. But staring at the linkages gave it away: Opus and GPT had fixed-length linkages, with the linkage pushing the wings; Argon's linkage stretched and contracted every frame to "reach" the wings—the direction was reversed.

The origami task had a sheet of paper progressively fold into a piece and loop back. Argon folded a nine-step swan with the most features—paper color change, slow motion, step skip; Opus folded an 18-step crane but blacked out at around 22 seconds about half the time; GPT folded an eight-step paper airplane. Unfortunately, Argon's paper split in half down the middle when folding the swan's neck.

The book cover reconstruction task required restyling covers into Song dynasty woodblock, woodcut, Swiss International Style, 80s neon, etc., without losing text or pasting the original image. None of the three misspelled text, and Opus's Song dynasty woodblock looked most like a real ancient text. But every one of Argon's three versions added an extra paper airplane that wasn't in the original cover, and it even imagined a golden patch in a cube crack.

In the watermelon rubber band mini-game, Opus and GPT both made green rind with red flesh, squeezed into an hourglass, bursting with scattered flesh and seeds; Argon achieved the deformation interaction but the watermelon was overexposed into a mint-white blob.

Axton's observation was precise: the most refined and feature-packed at first glance was often Argon, but once you made it move or stopped to examine details, the gap emerged.

Where Argon Wins: Five Image-Reading Tests and Original Games

Argon also had clear highlights. The five image-reading tests—reading clock time, counting eggs, spotting differences between two images, transcribing a line from handwritten text—Argon got all five right, tied with Opus, while GPT got four. The clock-reading was especially telling: GPT, while writing its reasoning, had already read 28 to 29 minutes, yet finally submitted "can't tell"; Argon unhesitatingly reported 10:29.

The original game task required designing an original game showcasing capabilities, three minutes per round, with a start screen, difficulty progression, and results screen. Opus made a lighthouse^Ad in a stormy night, using a beam to guide a boat around reefs into port, two and a half minutes per round, with results telling you how many points short of leveling up; GPT's starry-sky circle-collecting stars could be cleared in 30 seconds; Argon made a complete game with a boss fight, three upgrade paths, and mid-game skill selection, where random drawing would lose in about a minute. Argon tied with Opus here and clearly beat GPT.

The "carving a boat to find a sword" and icon-drawing tasks were ties across all three; none made idiom-meaning mistakes, and distance estimates were within reasonable error.

Quota Test and Usage Advice

The 12 major tasks plus two reruns dropped by the App mid-way totaled 14 High-tier generations, each taking two to nine minutes. After these 14 runs, the Pro account's session quota was 40% used, and the weekly quota only 2%. For Pro users writing code of this scale in the App, the quota is ample.

What really needs remembering is the opening scene: the screen read zero collisions, the reply read "verified," but Argon in the App simply couldn't open the page to check itself. When using its output for work, always run it in a browser first no matter what. Once Argon can obtain permissions in a CLI terminal like Opus and GPT—able to open, check, and fix errors itself—these 12 tasks deserve a rerun identically, to see how strong it truly is under fully equal conditions.

One-line Summary

Gemini 4 Argon finished last in the same-task showdown—the crux isn't capability but the inability to self-verify.

Paragraph Summary

Google's Gemini 4 Argon went head-to-head with Claude Opus 5.5 and GPT-6.1 Sol on 12 tasks, finishing last with 0-5-7 and 2-4-6 records. More worth dissecting is how it lost: three tasks crashed on open, all from small errors—variable scope mistakes, a missing space, a nonexistent URL—and Argon couldn't open pages to check and fix within the App, while Opus and GPT used CLI Agents to form a self-verification loop. In detail tasks, Argon also frequently gave itself away: butterfly linkage direction reversed, origami swan split down the middle, covers with extra paper airplanes, watermelon overexposed to white. But it wasn't a total loss: it aced all five image-reading tests, tying Opus, and tied Opus in the original game while clearly beating GPT. On quota, 14 High-tier generations used only 40% of Pro's session quota and 2% of the weekly quota. The core conclusion: Argon's ability isn't weak; its shortfall is the inability to self-verify, so always run its output first.