Anthropic Claude: $20,000, 16 AI Agents, and a Compiler That Builds Linux

Anthropic researcher Nicholas Carlini orchestrated 16 autonomous Claude agents working in parallel to build a 100,000-line C compiler in Rust. Using a custom harness for task coordination, testing, and conflict resolution, the agent team produced a compiler capable of building Linux 6.9 across multiple architectures.

A recent project has developed a Rust-based C compiler using a novel method called "agent teams." This approach involves running 16 instances of the language model Claude in parallel, without active human intervention. Over nearly 2,000 Claude Code sessions and approximately two weeks of continuous execution, the agent team produced a 100,000-line compiler capable of building Linux 6.9 across x86, ARM, and RISC-V architectures. In total, the project consumed roughly 2 billion input tokens, generated 140 million output tokens, and cost just under $20,000 in API usage. The primary focus of the work was not only the compiler itself, but the design of frameworks that allow autonomous agent teams to make sustained progress and execute tasks in parallel. Challenges such as task synchronization, merge conflicts, and regression control were central to the experiment.

The "agent teams" concept allows multiple Claude instances to autonomously work on a shared codebase. Each agent runs inside its own isolated container with a local copy of the repository, while a bare upstream Git repository is used for synchronization. To avoid agents duplicating work, the framework implements a simple file-based locking mechanism, where an agent claims a task by creating a lock file before starting work. If a conflict occurs, Git forces the agent to rebase and choose a different task. Once a task is completed, the agent merges changes back into the upstream repository and releases the lock. A continuous execution loop keeps spawning fresh agent sessions, enabling long-running autonomous development without manual supervision.

Maintaining correctness and preventing regressions proved to be one of the most difficult aspects of the project. As the compiler grew in scope, agents frequently introduced changes that broke existing functionality. To address this, the project incorporated high-quality test suites, strict continuous integration pipelines, and known-good compiler oracles. In particular, GCC was used as a reference compiler to compare outputs and isolate failing files when compiling large codebases such as the Linux kernel. This technique enabled agents to split a monolithic task into smaller, parallelizable units. Using this approach, the compiler was able to build not only the Linux kernel but also large real-world projects including QEMU, FFmpeg, SQLite, Postgres, Redis, Lua, and libjpeg, achieving a ~99% pass rate on most compiler test suites, including the GCC torture tests.

Despite these successes, the compiler has clear limitations. It lacks a native 16-bit x86 code generator, which is required to boot Linux from real mode and instead relies on GCC for that stage.

The project also does not yet have a fully reliable in-house assembler or linker, again falling back to GCC tooling in some cases. Even with optimization passes enabled, the generated machine code is significantly less efficient than GCC’s output, sometimes performing worse than GCC with optimizations disabled. While the Rust codebase is functional and maintainable, it does not yet match the quality or performance of production-grade compilers written by expert human teams.

Overall, the project serves as a stress test of the current limits of autonomous agent teams. It demonstrated both their surprising capabilities and the constraints that still require careful human oversight.

• https://github.com/anthropics/claudes-c-compiler...
• https://www.anthropic.com/engineering/building-c-c...