The biggest shift with Gemini 4 Argon is not just how much information you can feed into an AI model. It is how much useful work the model can give you back.
After more than 1,000 hours of hands-on testing, our team pulled together ten standout demos built by teams, engineers, and creators across Google. They range from modernizing decades-old scientific code to generating browser-based 3D worlds, translating medical data into interactive anatomy, and designing physical gadgets.
What connects them? Sustained reasoning that carries a complex task from the initial idea through implementation, iteration, and a usable result. And yes, some of the results are just ridiculously fun.
Key Takeaways
- Gemini 4 Argon’s million-token output capacity gives complex tasks more room for sustained reasoning and complete deliverables.
- The engineering demos combine system understanding, performance optimization, testing, and autonomous recovery from build obstacles.
- Agentic workflows connect multimodal inputs to playable 3D worlds and interactive technical data visualizations.
- Hardware designs and sensor-driven games extend AI-generated experiences into physical interaction.
Table of Contents
- Why One Million Output Tokens Matters
- Capability 1: Software Engineering That Goes Beyond Code Generation
- Capability 2: Real-Time 3D, Shaders, and Physics
- Capability 3: Turning Complex Data Into Useful Knowledge Work
- Capability 4: Bringing AI Into Physical, Interactive Experiences
- The Common Thread: Completing the Whole Task
Why One Million Output Tokens Matters
Gemini 4 Argon can output up to one million tokens in a single run. That is output capacity, not simply the amount of input context it can accept.
If you have ever had an AI agent lose track of a large task halfway through, you know the problem. It starts strong, gets tangled in the details, and needs you to restart it or explain the plan again. More output headroom gives the model room to work through longer solutions instead of stopping partway through.
Argon pairs that capacity with long-horizon reasoning: keeping a system architecture in context, running experiments, and working through complicated logic across multiple steps. At Google, it is already being used for work such as optimizing quantum algorithms and migrating systems containing more than 800,000 lines of code.
The interesting part is not generating an enormous answer for its own sake. It is staying with the problem long enough to deliver something complete.
Capability 1: Software Engineering That Goes Beyond Code Generation
The first three demos tackle a familiar engineering challenge: writing code is only one part of the job. Understanding dependencies, finding performance problems, and recovering from build failures are often the harder parts.
1. Translating 1960s Fortran Into Modern C++ and Rust
A surprising amount of critical scientific software, including weather models and physics research systems, still depends on Fortran written decades ago. Rewriting those systems by hand is a massive undertaking. Documentation may be missing, modern tooling can be limited, and a seemingly small change can break important behavior.
Working with Antigravity, Argon took an entire vintage codebase, mapped how its pieces fit together, and autonomously rewrote it into modern C++ and Rust.
This was not a simple syntax conversion. The model also cleaned up the architecture. The resulting Rust version was memory safe by default and ran 20% faster in this demo. Researchers could then edit and extend the software using modern development tools.
The important shift is from translating individual statements to understanding and modernizing a whole system. That is where sustained reasoning becomes genuinely useful.
2. Optimizing the ADK Python Runtime Without Changing Public APIs
Google’s Agent Development Kit helps developers build multi-turn AI agents. But when an agent runs continuously across many turns, memory consumption and latency can accumulate.
The team gave Argon a single assignment: profile the core ADK Python runtime, identify memory and speed bottlenecks, and fix them.
It handled the work as an end-to-end engineering task:
- Analyzed the runtime to understand where performance was being lost.
- Pinpointed the bottlenecks.
- Rewrote the relevant code.
- Passed every unit test without modifying public APIs.
That last point matters. An optimization is much more useful when existing applications can keep using the same interfaces. The result was a verified change presented as ready for production, not just a plausible suggestion for someone else to investigate.
The ADK Python repository provides relevant implementation context for developers working with this runtime.
3. Building an Android 3D Interface and Recovering From a Real Build Block
For the Android demo, Antigravity received a basic 2D map and a request to rebuild it as a high-end 3D spatial experience.
The most interesting moment was not the initial generation. It was the recovery.
Mid-build, the agent encountered a Maps SDK signing block in logcat. Rather than stopping or asking for help, Argon diagnosed the error and rewrote the layout around a local 3D rendering pipeline.
The finished experience hot-deployed to a Pixel 11 Pro and ran at 120 frames per second. It included a procedural 3D Griffith Observatory, a camera that could fly inside the building, and a 360-degree celestial planetarium dome. Audio-reactive shaders pulsed in response to on-device voice.
That combination is pretty wild: complex 3D math, Android implementation, deployment, and an architectural workaround for a real-world obstacle. The agent did not merely follow the original plan. It adapted the plan while preserving the goal.
The Antigravity and agentic workflow resources cover the platform behind several of these builds.
Capability 2: Real-Time 3D, Shaders, and Physics
The next set of demos goes well beyond static shape generation. These projects combine geometry, lighting, physics, asset creation, and modern web graphics into interactive experiences.
4. Desk Racer: Turning Desk Photos Into a Playable Racing Game
The starting point for Desk Racer could hardly be more ordinary: a few photos of a messy desk and a request to build a racing game based on it.
Argon worked with the visual model Nano Banana 2 to map the space. It then coordinated subagents using Blender to build a 3D track, generate textures, and position obstacles where the real objects appeared on the desk.
The result was a fully playable racing game. Your coffee mug became part of the course. Your keyboard became something to ramp over. The physical arrangement of a workspace became the layout of a custom digital world.
What makes this compelling is the complete chain from photo interpretation to asset generation to gameplay. The output is not just an image of a game concept. It is a game you can actually play.
5. A Detailed Japanese Pagoda Built Through Agentic Loops
Intricate historical architecture is a tough 3D modeling problem. Multi-tiered roofs, wooden framing, small architectural details, and natural surroundings can take an artist days to assemble by hand.
For this demo, the team used Argon inside Antigravity to handle the pipeline through autonomous agentic loops:
- Procedurally assemble the initial geometry and environment in Blender.
- Refine architectural details over successive iterations.
- Convert the scene into Three.js for use on the web.
The finished result was a highly detailed Japanese pagoda that could be explored directly in a browser. The scene was authored through code and iterative agent work rather than manual placement of every piece.
The detail is what makes this one stand out. The model was not just producing a recognizable silhouette. It was refining the structure into an explorable environment. For the browser-side technology, the Three.js documentation offers useful background.
6. Fur and Hair Simulation Running in a Browser
Realistic fur and hair are notoriously demanding to simulate and render. Traditional workflows can involve complex software and long rendering times, even for short sequences.
Argon built a complete GPU-based fur renderer and physics setup using Three.js. It began with a WebGL implementation, then iterated toward WebGPU for substantial performance improvements.
It also included an automatic fallback so the experience could still work in older browsers. That is an important engineering detail: pursuing better performance without abandoning compatibility.
The result was thousands of individual strands moving in the wind and responding to lighting in real time, with no visible stutter in the demonstration.
This is more than a cute character. It combines rendering, strand behavior, lighting, performance iteration, and browser support in one deliverable. The WebGPU API reference provides supporting context for the browser graphics technology involved.
Capability 3: Turning Complex Data Into Useful Knowledge Work
Knowledge work is not just summarizing a paragraph. Real inputs are often messy: spreadsheets, medical scans, sensor files, and coordinate tables that need to be interpreted together.
The goal here is multimodal reasoning that produces structured, polished deliverables. Accuracy matters, but so does how effectively the final interface helps someone understand the information.
7. A 3D DEXA Body Composition Viewer
A clinical DEXA report can be difficult to interpret visually. It typically combines numerical measurements, percentages, and flat radiographic images.
In this demo, Argon turned those 2D images and clinical measurements into an interactive, four-layer 3D representation of the body.
The interface supported several ways to explore the data:
- Remove the skin layer to examine muscle symmetry.
- Slice through the torso to inspect internal regions.
- Explore visceral fat and bone density.
- Move through nine years of scans to compare changes over time.
A live simulator also allowed adjustments to future fitness goals, reshaping the displayed anatomy interactively.
The exciting part is the change in presentation. Static measurements become something a person can explore spatially and across time. The demo illustrates an interactive visualization of medical data, rather than establishing the model as a diagnostic tool.
8. Visualizing NASA’s Artemis II Mission in 3D
A crewed lunar mission brings together orbital mechanics, velocity vectors, telemetry, and antenna-targeting information. Raw coordinate tables can contain the details while still making the overall journey difficult to grasp.
Argon ingested NASA open data and orbital coordinates to build an interactive 3D visualization of the Artemis II flight, presented as mathematically accurate.
The experience brought several mission elements into one environment:
- Orion’s checkout orbits around Earth.
- Communication links to ground-based, 70-meter Deep Space Network dishes.
- The figure-eight trajectory around the Moon.
- The final atmospheric reentry modeled at Mach 32.
A cockpit view made the trajectory explorable from the spacecraft’s perspective. Instead of mentally assembling a mission from separate tables, a person could navigate a spatial representation of the flight.
The broader lesson is how raw technical data can become an understandable interface without discarding the mathematical relationships that make it meaningful.
Capability 4: Bringing AI Into Physical, Interactive Experiences
The final category is simply cool and unique. These projects connect agentic generation with hardware design, device sensors, and playful physical interaction.
9. Agent Gadgets: From a Sketch to 3D-Printable Hardware
Turning a rough sketch into a website is one thing. Turning it into a physical device is a very different challenge.
Agent Gadgets begins with a basic drawing of a device. Argon takes on a mechanical engineering role, searching for the exact 3D models of the internal electronic components the design needs.
Through agentic loops, it works out how those components fit together and designs a custom 3D-printable casing around them. The workflow moves from an initial idea to a print-ready file, then to a working physical gadget.
That internal fit is the key. A good-looking exterior is not enough. The casing has to accommodate actual components, and the demo connects that practical constraint to the original sketch.
10. Argon Tennis: A Phone Becomes a Motion-Controlled Racket
Argon Tennis combines hardware sensors, web technology, and multiple AI models in a single interactive experience.
Generated in one shot by Argon, the project included both a 3D browser tennis game and a companion mobile web app. Opening the companion link on a phone turned the device into a motion-controlled racket.
The phone’s gyroscope tracked the swing, while haptic feedback was timed to contact with the virtual ball. Meanwhile, the desktop browser ran the 3D game with realistic physics.
The audio added another layer: live play-by-play commentary voiced by 3.8 Flash TTS and procedural background music from Lyria.
The result brings together the game, controller, sensor input, tactile feedback, commentary, and music. It is a great example of AI-generated software becoming something physical, responsive, and genuinely fun to play.
The Common Thread: Completing the Whole Task
These ten demos look very different, but they share a pattern. Argon is not stopping at a draft, a static asset, or an isolated code snippet. It is coordinating tools, working through dependencies, iterating on results, and, in some cases, recovering when the original approach fails.
The Fortran migration shows whole-system understanding. The ADK optimization adds test-based verification. The Android build demonstrates recovery. The 3D projects connect asset creation to real-time delivery. The data visualizations turn difficult inputs into explorable interfaces. And the hardware experiments carry ideas beyond a conventional desktop application.
The real promise of one million output tokens is room to finish complex work. These examples make that promise concrete, from serious production engineering to a tennis racket hiding inside your phone.
Full credit for the original video and demo presentation goes to Google Cloud Tech, with presenters Smitha Kolan and Shubham Saboo, and to the Google teams, engineers, and creators who built the featured projects.
Be the first to comment