How I used Google's agentic stack to build a game

Key Concepts

• Long-Running Agents: AI agents designed to execute complex, multi-step tasks over extended periods (hours or days) rather than single-prompt interactions.
• Goal Primitive: A framework allowing agents to maintain state and continue working through iterative turns until a specific objective is achieved.
• Self-Correction: The ability of an agent to identify failures in a chain of dependent tasks and autonomously resolve them without human intervention.
• glTF (GL Transmission Format): A file format for 3D scenes and models, optimized for efficient transmission and loading in web-based applications.
• Draco Quantization: A library for compressing 3D geometric meshes and point clouds to reduce file size while maintaining visual fidelity.
• Lazy Loading: A design pattern that defers the initialization of resources (like 3D assets) until they are needed, improving initial load times.

---

1. The Shift to Long-Running Coding Agents

The speaker argues that traditional "chatbot-style" coding is insufficient for real-world software development, which consists of chains of dependent problems. When a prompt fails or encounters a complex error, simple chatbots often hallucinate fixes or give up. Long-running agents, by contrast, utilize a "goal primitive" to persist through failures, self-correct, and continue working until the final objective is met.

2. Case Study: Building "Adios" (Simple Operating System)

The speaker demonstrated an agent tasked with building a functional operating system named "Adios."

• Features Implemented: The agent successfully built a window manager, an IndexedDB-based file system, a terminal, a file explorer, a paint application, a music visualizer, and a playable version of the game Doom.
• Methodology: The agent operated autonomously for hours, generating the necessary code to handle file I/O, UI rendering, and game logic, demonstrating that agents can handle non-trivial, multi-component software architectures.

3. Case Study: Complex 3D Scene Generation

The second demo involved creating a nostalgic, interactive 3D "video store" environment for the browser.

• The Challenge: The project began with a 156MB Blender file, which was too large for efficient web performance (target: 5–10MB).
• Technical Pipeline:
  1. Export & Geometry: The agent wrote custom Python scripts to handle Blender’s Draco quantization, ensuring geometry remained intact across different meshes and transforms.
  2. Optimization: It built a pipeline to convert and compress assets into glTF format, implementing texture resizing and image conversion to ensure the scene was "lazy-loadable" without sacrificing visual quality.
  3. Lighting & Materials: The agent corrected Blender area lights (which often export with excessive intensity) and adjusted mixed shaders to faithfully reproduce the aesthetic of a classic video store.
• Outcome: The agent worked for two to three days to complete the scene, which included complex details like cardboard cutouts, merchandise, and specific movie displays, all optimized for browser-based navigation.

4. Key Arguments and Perspectives

• Agents as Force Multipliers: The speaker emphasizes that they are not an expert in Blender or game design, yet they were able to produce high-quality, complex results by providing high-level specs to an agent.
• Persistence is Key: The primary argument is that the value of these agents lies in their ability to "turn at this for hours and hours." By removing the human from the loop for tedious technical debugging (like fixing export pipelines), the agent can solve problems that would be prohibitive for a non-expert to handle manually.

5. Synthesis and Conclusion

The video illustrates a paradigm shift in AI-assisted development: moving from "chat-and-generate" to "goal-oriented autonomous execution." By leveraging long-running agents, developers can offload complex, multi-stage technical workflows—such as OS development or 3D asset optimization—to systems capable of self-correction and iterative refinement. The success of these demos suggests that the future of software engineering will increasingly rely on agents that can manage long-term, stateful projects that require deep technical problem-solving across multiple domains.