Hands-On Test: Claude Opus 5.5, GPT-6 Astra, and Gemini 4 Argon — Three Projects Settle the Score

When benchmark scores differ by only a few points, how far apart do three top-tier models actually end up on real coding tasks? Wade, the creator behind the YouTube channel AI Wade Journey, answered this with three real projects: a 3D blackjack game with a talking dealer, a Shibuya Sky rooftop scene built in Blender, and a Notion clone app. The conclusion: the benchmark rankings largely hold, but the gaps are significantly amplified. Claude Opus 5.5 won all three projects, GPT-6 Astra held a solid second place at about one-third the cost, and Gemini 4 Argon, while the cheapest, has not yet reached the same tier.

What those few benchmark points mean on real tasks

Let's start with the numbers on paper. According to Artificial Analysis's Intelligence Index, Opus scores 58, while Astra and Argon both score 53. On LiveBench, the total scores of the three are within 2.5 points of each other. On the user-voted web app leaderboard, Opus is #1, Astra #2, and Argon #9. Interestingly, in the small browser game category, Astra even edges out Opus.

But one number deserves special attention: on LiveBench's long-horizon agentic tasks — the metric closest to this hands-on test scenario — Opus and Astra both score above 80, while Argon scores only around 70. Wade's billing structure almost perfectly mirrors this score distribution: Opus cost $216.72 in total, Astra $77.86, and Argon at least $8.75 at Google's published pricing.

On pricing, things are somewhat counterintuitive: per token, Astra costs 2.5 times as much as Opus, and Argon is only half of Opus. But projects aren't billed by token. Running the full Artificial Analysis test suite costs roughly $8,700 for Opus, $5,300 for Astra, and $2,400 for Argon — Opus has the lower unit price but the higher total bill because it does more.

Artificial Analysis Intelligence Index is an aggregate benchmark that standardizes scores from multiple independent evaluation sets such as MMLU-Pro, GPQA, LiveCodeBench, and SciCode, then weights them into a single 0–100 composite score intended to capture a model's general intelligence level in one number. Its strengths are cross-model comparability and timely updates; its weaknesses are that the weighting design is subjective and it cannot reflect a model's specialization on particular task types (such as long-horizon coding). So it's not contradictory when the article notes that "composite scores differ by only 5 points, but sub-metric agentic scores differ by more than 10" — the aggregate score masks real divergence at the sub-dimension level.

LiveBench takes a different approach: questions come from recent competitions, papers, and news, and are updated monthly to prevent data contamination, while also having objectively verifiable answers. It categorizes tasks into six types — reasoning, coding, math, data analysis, language, and instruction following — with the agentic coding sub-item specifically examining a model's sustained performance across multi-step tool calls and file operations. That's why the article repeatedly cites it as "the metric closest to the actual test scenario."

Details from the three projects

Round One: 3D blackjack and a talking dealer

The task requirements included realistic casino sound effects, a female dealer with lip sync, eight specified lines of dialogue, and a runtime frame rate of 60 fps.

Argon built everything purely from mathematics: every chip click, card slide, and jazz chord was generated by code. But its self-reported 60 frames came from a counter capped at 60, measured in a small headless window, with no rule tests at all. Astra took the real-human route, downloading a 3D avatar with 66 facial blendshapes, driving mouth shapes with voice loudness, passing through 20 dealer lines, 17 rule tests, and 19 browser checks, and honestly noting that "locked 60 fps is unverified." Opus went the furthest: 1,600 lines of code building the dealer from scratch, syllable-by-syllable lip sync across 105 lines, two auxiliary agents separately building the dealer and the environment, even pausing to ask Wade whether the voice sounded natural, and using speech recognition to verify all eight lines, measuring 60 fps at full 4K.

Bill: Astra 8 minutes, $34.52; Argon about 1 hour 10 minutes, $3.36 at published pricing; Opus 6 hours 10 minutes, $121.89 — 3.5 times Astra, with the two auxiliary agents alone costing nearly $40.

Lip sync refers to the technique of aligning a 3D character's mouth shapes with speech phonemes in time. There are two common approaches: one is viseme mapping, which maps the phoneme sequence recognized from speech to preset mouth poses (such as Meta's Oculus LipSync or Ready Player Me's ARKit 52-blendshape solution); the other is audio-driven neural networks that regress facial coefficients directly from the waveform. The "66 facial blendshapes" mentioned in the article are blendshapes, a standard set of expression parameters from ARKit; "syllable-level sync" is finer-grained viseme-level control that requires forced alignment of the dialogue to get the start and end times of each phoneme. This is why Opus's syllable-by-syllable sync across 105 lines far exceeds Astra's in engineering effort — the latter only drives mouth open/close with voice loudness, which is amplitude approximation rather than phoneme alignment.

Round Two: Shibuya Sky rooftop in Blender

The task required building the Shibuya Sky rooftop and rendering a 30-second cinematic shot in a snowy dawn scene, with architecturally accurate structure and music composed in code. The prompt never specified resolution — which became the key variable.

Argon's deck was clean and low-poly, but the surrounding Tokyo was just 64 boxes on a plane, and Mount Fuji was a white cone 1.5 km away. The file was 4K, but the frames weren't: the footage was rendered at 1080p and then stretched, and the only indication of this was a single comment line in the code. Astra rendered true 4K, outputting 900 frames of native footage in about 40 minutes, with the rooftop following the official drawings — yellow helipad, six wooden beams, glass edges — but the surrounding city was a thousand random boxes, with no Mount Fuji, and the music was 123 hand-written notes. Opus started from real data: an auxiliary agent first researched the real deck and listed the parts it couldn't confirm, then pulled more than 22,000 buildings from OpenStreetMap, used the tower's real outline and height, placed Mount Fuji according to its true bearing, validated the model against real photos from four angles, and landed every cut point on a musical bar. It delivered at 1080p/24 fps, and after Wade requested 4K, it fixed an exposure setting that made the view completely black and re-rendered, taking 79 minutes.

Bill: Astra 59 minutes, $30.56; Argon about 3.5 hours, at least $4.17 (23 connection interruptions, which Wade confirmed was a VPN issue); Opus 3.5 hours including the 4K re-render, $69.32.

OpenStreetMap (OSM) is an open, collaborative world map database whose building data is stored as polygon outlines plus tags (height, number of floors, use), retrievable in bulk by latitude/longitude range via the Overpass API. In 3D scene reconstruction, OSM is often used to generate city blockouts: extruding building outlines into volumes and estimating height as floors × 3 meters when the height tag is missing. When Opus "pulled more than 22,000 buildings and used the tower's real outline and height," it was essentially importing OSM data into Blender for procedural modeling. The difference from Astra's "randomly generating a thousand boxes" lies in geographic accuracy and whether occlusion relationships are correct.

The distinction between render resolution and output resolution is also worth clarifying: in Blender, render resolution is determined by scene settings, while output size is just a final encoding parameter — stretching a 1080p image to 4K adds no detail whatsoever. Detecting this requires inspecting the project file or render log rather than judging the finished video by eye — which is exactly why Argon's single code comment became key evidence.

Round Three: Notion clone

The task was to build a Notion-style app with React and TypeScript, including nested pages, a block editor with a slash menu, drag-and-drop reordering, a small database, search, dark mode, and in-browser persistence.

Argon wrote the most code and covered the widest range of block types, but the agent never opened its own app in a browser and only ran five mock tests. Deleting a page or clicking reset demo made data vanish outright, with no confirmation and no undo. Astra's app had the highest completion level: cover images, favorites, 15-second undo, exportable/importable backups, 31 minutes, 12 data tests passing, and it clicked through the interface itself in Chrome, including real mouse dragging. Opus acted like a QA team: all 21 browser tests passed, then a second Opus agent was dispatched to attack the app, finding 14 bugs — for example, typing a slash inside a code block broke the code — all of which were fixed with regression tests added.

Bill: Astra 31 minutes, $12.77; Argon about 31 minutes, $1.22 (the session clock showed nearly 19 hours, of which 17.5 hours was one command waiting for approval); Opus 1 hour 18 minutes, $25.50.

The self-verification capability of agentic coding agents refers to whether an agent can proactively open a browser, click through the interface, and run real interaction tests before delivery, rather than relying solely on unit tests it wrote itself. This is exactly where the divergence in the article lies: Argon ran only five mock tests and never opened the app; Astra used browser automation to click the real interface (including mouse dragging); Opus went further, using a second agent as an attacker to conduct adversarial testing on the app. This difference corresponds to what the industry calls the "generation-verification gap" — a model's ability to generate code is not synchronized with its ability to find defects in its own code, and the latter depends on whether it is given browser control, observability, and multi-turn autonomous loops. This is also the mechanistic reason why, under the same batch of benchmark scores, actual delivery quality gets significantly amplified.

The bottom line and interpretation: cheap doesn't mean efficient

Across the three projects: Opus $216.72, Astra $77.86, and Argon at least $8.75 at published pricing (at least $17.50 at full price). Work time: Astra about 2.5 hours total, Argon about 5 hours (estimated), Opus nearly 11 hours. These are API-equivalent estimates based on session logs, not actual subscription charges.

Wade's core conclusion is: Opus 5.5 is the strongest builder here, suited to users who want the most complete, most thoroughly tested results and can bear the time and the bill; Astra is the value pick close behind, with solid builds, honest reporting, and about one-third the cost; Argon is the cheapest but has not yet reached the same tier. He particularly emphasized that "cheap doesn't mean efficient" — when every output needs human review, the money saved gets paid back in another form.

A caveat worth stating: each task was run only once, and the three ran in Claude Code (highest effort), Codex (highest setting), and Gemini CLI on Vertex AI (high thinking) respectively, so what's being compared is three coding agent configurations rather than pure models. Results will vary by environment. But under the same setup, the benchmark ranking not only holds in real work — it gets amplified.

One-line Summary

Three top models tested on three real projects: Opus wins it all but costs the most, Astra offers the best value, and Argon is cheapest but not in the same tier.

Paragraph Summary

Creator Wade compared Claude Opus 5.5, GPT-6 Astra, and Gemini 4 Argon across three real projects: 3D blackjack, a Blender Shibuya rooftop, and a Notion clone. The results show that the few-to-ten-point gaps in benchmarks get amplified on real tasks: Opus won all three thanks to auxiliary agents, syllable-level lip sync, real OSM building data, and adversarial testing, at a total cost of $216.72 and nearly 11 hours; Astra delivered solid builds and honest self-reporting at about one-third the cost ($77.86), holding a firm second place; Argon was the cheapest (at least $8.75), but its self-reported frame rate was unreliable, its 4K was actually stretched 1080p, and its agent never opened its own app. The author's conclusion is that the benchmark ranking holds and gets amplified, but cheap doesn't mean efficient.