Gemini 4 Argon Hands-On: AI Builds Board Games, Constructs Temples, and Trains Robots Autonomously

Title

Gemini 4 Argon Hands-On: AI Builds Board Games, Constructs Temples, and Trains Robots Autonomously

Meta Description

A roundup of Gemini 4 Argon hands-on tests: the AI autonomously builds a desk racetrack and temple in Blender, writes a ray tracing engine, and trains a humanoid robot to sink 7 shots in a row, plus API pricing and developer access details.

Article Content

After Google's Gemini 4 Argon launched, a hands-on video on Bilibili showcased its surprisingly broad capability range: from turning desk photos into a playable racing game, to autonomously building temple scenes and writing a ray tracing engine, to directing a humanoid robot to practice beanbag throwing—all with almost no human intervention.

From a Desk Photo to a Playable Racing Game: The Power of Multi-Agent Collaboration

The most intuitive demo in the video has Argon take a few photos of a real desk and, within the Anti-Gravity environment, orchestrate multiple agents to collaborate: use Blender to build the desk, room, and track models, call Nano Banana for photorealistic rendering, then wire in the physics engine, shaders, and engine sound effects. Game logic such as lap counts, timing, and speedometer is also filled in by the AI, and the final product was uploaded to the AI Studio leaderboard where it can be played online directly.

The significance of this pipeline is that it no longer just generates an image or a snippet of code—it lets multiple agents divide the work across modeling, rendering, physics simulation, and front-end integration as a complete pipeline. For developers, Argon is more like a "project collaborator" that can decompose tasks autonomously.

Multi-Agent Collaboration refers to breaking a complex task into sub-tasks handled by multiple AI agents with different specialties, advancing in parallel or in sequence, and coordinating results through message passing or a shared workspace. Compared with a single model generating everything in one pass, the advantage of a multi-agent architecture is that each agent can focus on a specific toolchain (e.g., modeling, rendering, physics simulation), reducing the context burden of any single inference; at the same time, a "generate—review—revise" loop enables self-correction. Common patterns include Orchestrator-Worker and debate-style collaboration. The cost is increased token consumption and latency, so cache discounts and task-planning efficiency become key to cost control.

Temples and 3D Chess: AI's Aesthetic and Engineering Capabilities

In another demo, Argon independently built a temple scene in Blender, complete with cards, electricity, trees, and lighting. Multiple agents took turns inspecting the camera view to spot flaws and iterated round after round until the image approached photorealistic quality—this "self-review" mechanism significantly improves output quality.

The 3D chess project demonstrated rigor on the engineering side: Argon first checked the Blender Node and Python environment, then wrote Python scripts to procedurally sculpt the pieces, animate an antique-style board, and generate PBR materials, and finally ported it to the web. The pieces have weakness settings—for example, the lion piece shatters into pieces when hit—and it also came with a computer opponent that can scare you stiff.

5,000 Lines of Math Code and a Self-Built Ray Tracing Engine

The most astonishing one was a room project with "no prompt, no 3D engine, no images." Argon wrote over 5,000 lines of math code and built its own ray tracing engine, making sunlight on the glass bend twice and converge into a light spot on the stone table. It also wrote its own video tools and mixer, added TTS narration and sound effects, and edited the entire film together.

This shows that Argon's capabilities have extended from "calling ready-made tools" to "building underlying tools for specific effects," demonstrating considerable autonomous engineering ability when given a clear goal.

Ray tracing is a physically based rendering method: it shoots rays from the camera toward each pixel in the scene, computes intersections between rays and objects, recursively traces along reflection and refraction directions, and finally accumulates the color contributions of each light path. It can naturally simulate reflection, refraction, shadows, and caustics (the bright light patterns formed on surfaces after light is refracted through curved surfaces), whereas traditional rasterization rendering requires many approximation tricks to fake similar effects. Implementing a usable ray tracer usually requires mathematical foundations such as vector operations, ray-triangle intersection, Monte Carlo sampling, and denoising. Therefore, "building an engine with 5,000 lines of code and making sunlight bend and converge into a light spot" means the model needs to independently complete a systematic engineering effort spanning geometry, optics, and numerical computation rather than calling an existing rendering library.

Seven Shots in a Row: Simulation Modeling Cuts Costs and Boosts Efficiency

In an internal test, researchers showed Argon only a video of a person throwing a beanbag. It measured the court coordinates, calculated how the full-body joints should move, wrote the simulation code itself, trained in the simulator, and then had the Apollo humanoid robot sink 7 shots in a row on the spot. Simulation modeling that originally took weeks was compressed into a few hours.

The value of this case lies in connecting the chain of "video understanding—physics modeling—simulation training—real-machine deployment," which is a substantial improvement for the iteration speed of robotics R&D.

The Sim-to-Real Gap is a core challenge in robot learning: policies trained in physics simulators often fail when transferred to real hardware due to modeling errors such as friction, mass distribution, and sensor noise. Common mitigation methods include domain randomization (randomizing physical parameters and visual appearance during training to force the policy to be robust to errors) and system identification (calibrating simulation parameters with real data). In this article, Argon measures court coordinates from a video, infers full-body joint motion, and writes simulation code—essentially performing automated system identification and scene reconstruction to narrow the sim-to-real gap. This is also the technical meaning behind "compressing weeks of modeling into a few hours": automation of the modeling stage directly determines the iteration speed of real-machine deployment.

How Developers Can Use Argon

Developers can call Argon through the Gemini API, and can also use it in AI Studio and Android Studio; the company's own Anti-Gravity development tool also already supports it.

On pricing, the Argon API launch price is $2 per million input tokens and $10 per million output tokens, with cached input 95% cheaper. The discount runs until November 30, 2026, after which prices rise to $4 input and $20 output. For agent workflows that require heavy iteration, cache discounts are a cost item worth planning for in advance.

From desks, temples, and chess games to robots, the common thread across these cases is that Argon does not merely generate content—it autonomously decomposes and completes complex cross-toolchain tasks within a multi-agent framework. This may be the most fundamental difference between it and previous-generation models.

Token caching (Prompt Caching) refers to storing the intermediate computation results of a repeated prefix (such as system prompts, long documents, and tool definitions) on the server side, so that subsequent requests that hit the cache can reuse them directly, skipping repeated computation and being billed at a discount. For agent workflows, system prompts and tool descriptions often remain unchanged across dozens of iterations, so the cache hit rate can be high; therefore, a 95% input discount affects total cost far more than the unit price itself. When planning costs, note that caching usually has a minimum cacheable length and a time-to-live (TTL) limit, and a hit requires the prefix to be exactly identical; if the prefix content is modified on every iteration, the discount will not apply. In addition, output tokens usually do not participate in cache discounts, and agent workflows often produce a considerable volume of output, so input and output costs should be estimated separately.

One-line Summary

Gemini 4 Argon demonstrates multi-agent autonomy across game development, a ray tracing engine, and robot simulation modeling.

Paragraph Summary

A hands-on video on Bilibili showcases the capability boundaries of Google Gemini 4 Argon: it can orchestrate multiple agents in the Anti-Gravity environment to complete a full development pipeline from desk photos to Blender modeling, Nano Banana rendering, a physics engine, and game logic; it can independently build a temple scene and improve realism through multi-agent cross-review iterations; it can write over 5,000 lines of math code to build its own ray tracing engine and complete video editing; and it can complete robot simulation modeling from just one beanbag-throwing video, enabling the Apollo humanoid robot to sink 7 shots in a row. The article argues that the essential difference between Argon and previous-generation models lies in autonomous task decomposition and cross-toolchain execution within a multi-agent framework. Developers can access it via the Gemini API, AI Studio, and more, with a launch price of $2 input and $10 output per million tokens, and a 95% discount on cached input until November 30, 2026.