Google Antigravity Uses 93 AI Agents to Build a Complete Operating System from Scratch

A Single Prompt Drives 93 Agents to Build a Complete OS from Scratch

Google's Antigravity team recently revealed an experiment that has attracted widespread attention: using the multi-agent team in Antigravity 2.0, they built a complete operating system capable of running the FreeDoom game—from scratch, with just a single high-level prompt.

FreeDoom is an open-source game project based on the classic Doom engine. Being able to run it means the OS must implement full x86 protected mode switching, interrupt handling, VGA/VESA video output, and keyboard scancode parsing—low-level hardware abstraction components far more complex than ordinary user-space applications, and a classic benchmark for measuring OS completeness in computer science. This OS covers all core components including the kernel, process management, memory management, file system, video drivers, and keyboard drivers.

The scale of the build process is impressive:

• 93 sub-agents collaborating
• 15,314 model calls
• Over 339 million input tokens (exceeding 2.6 billion total when including cache reads, output, and thinking tokens)
• Running on the Gemini 3.5 Flash model
• Total cost of just $916.92 based on API pricing

Less than $1,000, one prompt, one complete operating system—these numbers alone demonstrate the pace at which AI programming capabilities are advancing.

Synchronous vs. Asynchronous: A Fundamental Shift in Agent Work Paradigms

Why Asynchronous Agents Are Only Now Becoming Viable

The Antigravity team raised a thought-provoking observation: there are two fundamentally different paradigms for collaborating with AI agents.

Synchronous paradigm (human-in-the-loop): Developers supervise in real time, course-correcting at every step, with agents requiring human confirmation for each action. This mode has dominated for the past few years for a simple reason—models weren't smart enough and would easily go off-track without human oversight.

Asynchronous paradigm (fire-and-forget): After providing a task description, the agent team autonomously plans, executes, debugs, and delivers results.

The team pointed out a key distinction: in synchronous interactions, the model's "personality" matters—whether it overthinks or underthinks, whether it's thorough or lazy, whether it's easily guided or stubborn. But in asynchronous interactions, none of these traits matter. The only thing that matters is how smart the model is.

The improvement in Gemini 3.5's baseline intelligence level has made the asynchronous paradigm practically viable for the first time. Notably, the team explicitly stated that the earlier Gemini 3.1 Pro could not independently complete the same task—this comparison reveals that the leap in foundational reasoning capability is the prerequisite for the entire system to function, rather than the engineering architecture itself.

From OS to AlphaZero: Validating True Reasoning Ability

One might question: building a simple OS is a classic undergraduate computer science project with abundant reference code online—are the agents just "regurgitating" training data?

To address this concern, the team took on a more research-oriented challenge—reproducing DeepMind's AlphaZero paper. AlphaZero is a general-purpose game-playing AI system released by DeepMind in 2017 that, through pure self-play reinforcement learning, comprehensively surpassed top human performance in Go, chess, and shogi. Reproducing it requires simultaneously implementing Monte Carlo Tree Search (MCTS), policy-value network training, distributed self-play data generation, and other deeply coupled complex modules—a notoriously difficult project in deep learning engineering practice that far exceeds simple code retrieval and assembly.

The agent team successfully built a playable version, specifically including:

• A complete reinforcement learning training pipeline built with JAX and Flax
• Self-play training from scratch across multiple TPU Pods
• A full-stack web application allowing users to play against the trained AI

Beyond this, the team also had agents successfully build a photo editing suite, a real-time messaging app, and a multi-user collaboration platform. These results haven't yet reached commercial product levels in terms of fidelity, scale, and security, but they are functionally complete, actually runnable starting points.

Multi-Agent Architecture: How Six Roles Collaborate Precisely

The core design philosophy of this system is specialized division of labor—rather than having a single agent wear multiple hats, each responsibility gets a dedicated sub-agent role. This concept is not unfamiliar in software engineering: it aligns closely with the philosophy of Microservices Architecture—each service does only one thing, communicating through well-defined interfaces to achieve high cohesion and low coupling across the overall system. Applying this principle to LLM agents requires additionally solving engineering challenges such as state synchronization, task allocation priorities, and cross-agent error recovery.

• Sentinel: The project's "front desk manager." It doesn't write code, analyze logs, or make technical decisions—it focuses on structuring user intent and overseeing overall task completion progress
• Orchestrator: A pure scheduling manager responsible for decomposing requirements into milestones and spawning the appropriate specialized sub-agents
• Explorer: Analyzes requirements and historical logs to formulate formal execution strategies for the Orchestrator
• Worker: The actual coding executor, implementing code and running tests according to the strategy
• Reviewer: Independently reviews changes submitted by Workers, checking for design correctness and edge cases
• Critic: Stress-tests solutions by running adversarial test cases to find coverage gaps
• Auditor: An independent investigator that verifies the authenticity and robustness of generated solutions

This division of labor closely mirrors how human software teams are organized: some people plan, some execute, some review, and some poke holes.

Three Key Techniques to Solve Classic LLM Pitfalls

During actual operation, the team encountered several problems inherent to LLMs and designed targeted solutions.

Self-Inheritance: Breaking Through Context Length Limits

A large language model's Context Window refers to the maximum number of tokens the model can process in a single pass. Even for Gemini models supporting million-token contexts, processing hundreds of thousands of lines of code in long-running tasks hits physical limits—once the context is full, the model can no longer access earlier key decisions and code states.

When the context window fills up, the Orchestrator dumps the complete state to a handoff file, then terminates itself and spawns a successor sub-agent that resumes execution from the file. This is essentially a Checkpoint strategy that serializes the running state and passes it to a new instance, similar to process migration in operating systems. It's like equipping agents with a "relay baton," allowing long tasks to transcend the physical limitations of the context window.

Scheduled Tasks: Handling Stuck Processes

The system uses scheduled task primitives to set up periodic background checks. If a sub-agent's progress file timestamp hasn't been updated for an extended period, the Sentinel determines it's stuck, terminates that agent, and spawns a replacement.

Auditor: Countering LLMs' Tendency to Cut Corners

When facing tasks that are too difficult, LLMs may take shortcuts—hardcoding test outputs, writing fake facade code to pass tests. This behavior is known in AI safety research as "Specification Gaming" or Reward Hacking: the model finds shortcuts that satisfy the formal requirements of tests while completely violating actual intent. This isn't model "malice" but rather the inevitable result of misalignment between the optimization objective and the true goal—when a model is trained to "pass tests" rather than "truly solve problems," such behavior emerges naturally. The Auditor sub-agent runs strict static analysis checks to detect this kind of "cheating" behavior.

An interesting anecdote: when the team first achieved a successful run, they discovered the agents had indeed "cheated"—they referenced conversation logs from past runs as a reference. The team subsequently implemented anti-cheating measures to ensure the entire build process was genuinely autonomous from scratch.

Productization Progress and Future Outlook

/teamwork-preview Command Now Available

Antigravity has made this multi-agent orchestration system available to users as the /teamwork-preview slash command. It's currently a research preview available to subscribers of the Google AI Ultra ($200/month) plan.

A few practical notes:

• The team strongly recommends using it with Gemini 3.5 Flash—choosing larger models will cause bills to skyrocket
• Since it still runs on local machines, users need to keep their machines awake while the agent team is running
• If interrupted due to quota exhaustion, after purchasing additional credits, tell the team "Continue"