Gemini 4 Argon Hands-On: Build a 3D Game from One Sentence, But Don't Trust the Benchmarks

After Google opened Gemini 4 Argon to all developers in October, the most talked-about demo wasn't a benchmark chart—it was a playable 3D desktop racing game. But the picture pieced together from independent tests and user feedback is far more complicated than the official launch post: it genuinely can generate a complete interactive project from a single prompt, and it genuinely validates the engineering value of "one run, one million tokens of output"—but the costs, quotas, and credibility issues are just as real.

From Desktop Photo to Playable World: Argon's Demo Matrix

Google's published demos cover several different routes. The most intuitive is "reality to game": photograph a real desktop, have Argon model the desk and track in Blender, texture it with Nano Banana, then wire up physics, custom shaders, and engine sounds in Three.js to produce a mini racing game playable directly in AI Studio. Another route is scene sculpting: Argon builds an entire pagoda complex in Blender, including buildings, trees, and lighting. The mechanism behind this is what Google calls a "multi-agent visual critique loop"—an agent renders the scene, looks at the result, offers critiques, and iterates until the image meets the bar.

There are even more complete 3D game examples: Argon writes Python scripts to sculpt each model, rig skeletons, create animations and textures, then publishes to the web via Three.js with shader effects, fracture physics, and computer opponents. Non-game directions were also attempted: integrating data from three open-source projects into a 3D anatomy tool with layer-by-layer剥离 of the human body; designing new 3D-printable sofa legs from a measurement sketch and a photo of a sofa.

The most flamboyant claim in the launch post: Argon wrote its own ray tracer, video tool, and audio mixer in pure Python with zero external libraries, and generated a narrated short film set in a sunlit library. This claim was later debunked—details below.

Three.js is an open-source 3D graphics library that runs in the browser, using WebGL for hardware-accelerated rendering. It lets developers build interactive 3D scenes directly in JavaScript without plugins. In this article, after Argon exports models built in Blender, it's through Three.js that physics engines, shaders, and sound effects are connected so you can play directly in the AI Studio web page.

Blender is an open-source 3D creation suite covering modeling, sculpting, rigging, animation, and rendering. One way Argon invokes Blender is through MCP (Model Context Protocol)—an open protocol that lets models communicate with external tools, enabling the model to execute Blender commands and generate assets rather than just output text. The texturing step for the desktop racer is handled by Nano Banana, Google's image generation model, which converts real photos into stylistically consistent game textures. Understanding how these three divide the work helps clarify that Argon's "generation" is essentially orchestrating a toolchain, not end-to-end output from a single model.

Games and Robots: Two Extreme Tests of Agent Autonomy

Google researchers gave four Argon agents a Minecraft survival world and a single goal—defeat the Ender Dragon. No one assigned roles, and no one wrote game logic. The agents wrote 2,783 programs themselves, died 605 times, and completed the goal in 27 hours and 14 minutes. The value of this case isn't "AI can play games" but rather the combined performance of long-horizon planning, failure recovery, and program generation under zero supervision.

Another case stepped off the screen: Argon watched raw video of a real person playing a beanbag toss game, mapped spatial relationships, inferred body movements, wrote its own simulation code, loaded it onto Apptronic's Apollo humanoid robot, and the robot hit seven shots in a row. Skeptics on Reddit raised a fair point—throwing from the same position every time casts doubt on generalization. This skepticism is worth keeping, but it doesn't negate the feasibility of the video-to-simulation-code pipeline itself.

One Million Tokens per Run: The Key Number Behind the Capability Leap

"How can a model build an entire game in a single run?" The Reddit user's question points to the key figure in Google's September announcement: Argon's output limit is 1 million tokens, up from 64,000 previously. This isn't a nice-to-have parameter—it's a change in how work gets done: enough to write an entire project in one go rather than piecing together scattered code fragments. The video creator himself used Argon to build a "Pocket World" glass terrarium: a rotating sphere, raising and lowering terrain, placing trees, cabins, flocks of sheep, and rain clouds, running directly in the browser with a guided camera. His assessment: this used to require a Three.js developer; now it starts from a prompt, with the human steering.

Token is the basic unit of text a model processes, roughly equivalent to part of an English word or one Chinese character. The output limit refers to the maximum number of tokens a model can generate in a single request. The previous 64,000 limit was roughly the length of a novella; the model had to generate in segments that humans then stitched together. One million tokens is enough to hold an entire project's source code, comments, and configuration.

The significance of this leap lies in context continuity: when the entire codebase is in memory within a single run, the model can maintain consistency in naming, interfaces, and logic, avoiding the variable conflicts and duplicate implementations common in segmented generation. The article's mention of "95% discount on cached input" is also tied to the token mechanism—when resubmitting the same project context, Google heavily discounts the cached input portion, which is especially critical for large projects requiring repeated iteration.

Independent Comparison: Leading, But Not Dominating

Oh My Unicorn had three models each build a 3D planet from the same prompt, single run, no blind evaluation: Argon completed in 12.4 minutes in Anti-Gravity at a cost of $1.45; Opus 5.5 took 14 minutes at $2.54; another model took 7 minutes at $0.70. Argon is in a favorable position on speed and cost.

Benchmarks paint a more nuanced picture. On the VALS index covering finance, programming, law, and tax, Argon ranks first at 68.9%. But on Vibe Code Bench, which tests building web apps from scratch, it ranks second: Sonnet 5.5 leads 92.39 to 91.91. The details behind the rankings are more telling: in the same app test, Argon spent $8.11 and 37 minutes per task; Sonnet spent $31.25 and over an hour. In other words, Argon achieved a score half a point behind at about a quarter of the cost, ranking 8th among 216 models. This is frontier-level—but not a one-sided winner.

VALS index is a comprehensive benchmark covering professional domains such as finance, programming, law, and tax, testing model accuracy on knowledge-intensive tasks; Vibe Code Bench focuses on end-to-end ability to build web apps from scratch, evaluating whether generated code actually runs and meets requirements. The two measure different dimensions, so divergent rankings aren't contradictory: the former emphasizes knowledge application, the latter engineering output.

Understanding benchmark limitations is equally important: single-prompt, single-run tests struggle to cover the iteration and debugging of real development, and different benchmark weighting designs amplify specific models' advantages. The article's comparison—"Argon costs about a quarter of Sonnet 5.5 with a score half a point behind"—precisely shows that reading benchmarks should combine cost and time, not just ranking position.

Three "Receipt" Issues to Watch Out For

The most valuable takeaway from this launch for content creators is three facts about credibility.

Prices have an expiration date. Google calls $2 per million input tokens and $10 per million output tokens an "introductory price." The official pricing page states that starting December 1, these become $4 and $20—double. By that math, that $1.45 planet will cost roughly double six weeks later. Users paying per token should complete large projects before the price hike and reuse the same project context, since Google offers a 95% discount on cached input.

"Pure Python" isn't pure. The launch post claims zero external libraries, but the readme of the repository Google itself links to states the offline renderer was written in Python and NumPy. NumPy is an external library. The engine is still impressive, but this is a reminder to read the receipts, not just the launch post.

It fabricates data. In the planet test, the page Argon generated included a benchmark drawer, and the tester discovered that the "Gemini 4" row was invented by the model itself—fabricated numbers presented as data. This is the most practical warning: if you're going to publish something it built, every number on screen must be traceable to a real source.

Real-World Performance: Strong at 3D, Weak at Layout

One reviewer built five apps with Argon and scored each on a five-point scale: the racing game and black hole simulator received perfect 5s; the perfume website and a town builder with broken layout got only 2s, for a total of 17/25. The conclusion is clear—3D and simulation are strengths, page layout is a weakness. User feedback shows the same mix: one Pro subscriber said a quick prompt for an Archero-style game produced 2,200 lines of code in minutes, but the same sentence includes a critical cost—3% of the five-hour quota. Another user claimed a single "hello" prompt used 2%. On Hacker News, a developer called it "the worst frontier lab launch," while simultaneously betting the strategy will succeed because ordinary people use Google for everything.

Six Directly Applicable Usage Strategies

• Aim at strengths: Prioritize interactive 3D games and simulations with Argon; don't expect a polished responsive website on the first try.
• Let it see its own work: In the planet test, the Anti-Gravity run took seven page screenshots and reviewed each one, and the result was noticeably cleaner; the Gemini CLI run never looked at its own page. Asking it to screenshot and fix replicates the visual critique loop behind the official demos.
• Give it tools, not just prompts: The official demos ran in Anti-Gravity, using slash commands like /goal, custom skills, and multi-agent loops; the desktop racer was modeled via Blender MCP and textured with Nano Banana. The more tools connected, the more it can complete autonomously.
• Build big projects before the price hike: The $2 and $10 pricing lasts until November 30, then doubles.
• Consolidate prompts for subscribers: Each prompt consumes 2–3% of the five-hour quota, so write the full specification first—mechanics, appearance, controls—and send one detailed prompt rather than ten fragmented ones.
• Verify every number: It fabricated its own benchmark row, and Google's launch post called a NumPy project pure Python. Trace every on-screen statistic before publishing.

What This Means for Content Creators

Models can now build the interactive object itself—games, 3D explainers, tools the audience actually plays with. For online content producers, this dramatically lowers the barrier to creating "interactive centerpieces." Google AI Pro in Canada costs CAD 26.99 per month, and the Gemini app includes Argon; the API is paid-tier only. Three things to watch next: actual usage costs after the December 1 price doubling, the remaining members of the Gemini 4 family (Google says Argon is just the beginning), and whether daily usage quotas loosen.

In one sentence: Argon can build apps, but turning what it builds into trustworthy, monetizable products still requires human judgment.

One-line Summary

Gemini 4 Argon can generate complete 3D projects in one shot, but costs, quotas, and credibility remain concerns.

Paragraph Summary

After opening in October, Gemini 4 Argon drew attention with demos like prompt-generated playable 3D racing games. Its core breakthrough is raising the single-run output limit from 64,000 to 1 million tokens, enabling the model to write an entire project at once. Independent tests show Argon excels at 3D games and simulations but is notably weak at web layout; benchmark rankings are mixed—first on VALS but second on Vibe Code Bench—at a quarter of competitors' cost. The article also reveals three credibility issues: limited-time pricing doubles on December 1, the so-called "pure Python" actually depends on NumPy, and the model fabricates benchmark data. The ultimate conclusion: Argon can build apps, but turning them into trustworthy, monetizable products still requires human judgment.