Anthropic: 16 AI Agents Built a C Compiler in 2 Weeks

How 16 Claude Agents Wrote 100,000 Lines of Production Code

Anthropic researcher Nicholas Carlini ran an experiment that puts hard numbers on the multi-agent coding paradigm: 16 Claude agents, working in parallel over two weeks, produced a Rust-based C compiler from scratch. The result — 100,000 lines of code — can compile the Linux kernel, PostgreSQL, FFmpeg, Redis, QEMU, and even runs Doom.

The cost: $20,000 in API tokens across nearly 2,000 Claude Code sessions, consuming nearly 2 billion input tokens and 140 million output tokens.

The key insight — testing as coordination: “Claude will work autonomously to solve whatever problem I give it. So it’s important that the task verifier is nearly perfect, otherwise Claude will solve the wrong problem.” Carlini’s breakthrough was using GCC as a “known-good oracle” — a reference compiler that agents could verify their output against. This turned an ambiguous creative task into a verifiable engineering problem that agents could solve independently.

Parallel work via git-based locking: The 16 agents didn’t step on each other’s work because of a simple coordination mechanism: a git-based locking system that assigned distinct compilation challenges to each agent. No central orchestrator, no complex communication protocol — just isolated tasks with a shared verification standard.

What the compiler achieves:

• Passes 99% of GCC’s torture test suite
• Compiles Linux 6.9 across x86, ARM, and RISC-V architectures
• Builds real-world software: PostgreSQL, FFmpeg, Redis, SQLite, QEMU
• Clean-room implementation with no internet access — depends only on Rust’s standard library

Why Multi-Agent Coordination Is the Unlock

• Parallelism beats serial work — 16 agents working simultaneously accomplished in two weeks what would take a single agent months. The pattern: decompose into independent, verifiable tasks and run them concurrently.
• Verification > supervision — Instead of watching agents work, Carlini built automated verification. The agents didn’t need human review because the test oracle caught errors automatically.
• The economics are striking — $20,000 and two weeks for a 100,000-line compiler. For context, GCC has been built by thousands of engineers over 37 years. The output isn’t as optimized, but it works.
• Agents need boundaries, not micromanagement — Each agent had a clear scope (specific compilation files), a verification mechanism (GCC oracle), and isolation (git locking). This is the emerging pattern for agent orchestration: clear tasks, automated checks, minimal coordination overhead.

What This Means for AI-Powered Organizations

This isn’t just a compiler story — it’s a proof point for how AI teams will operate in production. The pattern Carlini demonstrated (parallel specialized agents, automated verification, git-based coordination) is the same architecture that powers multi-agent business workflows: each agent owns a function, verification ensures quality, and the system scales by adding more agents, not more human oversight.

The limitations matter too: the generated code isn’t efficient, and some edge cases still need GCC. This mirrors what organizations see when deploying AI employees — they handle 80% of the work reliably, with humans covering the remaining 20% that requires judgment and optimization.