✅ Claude Code Agent Teams Ship — 16 Agents Build a C Compiler Without Human Intervention

Anthropic has shipped Claude Code Agent Teams as an experimental feature, and to demonstrate the capability, published an engineering post showing 16 parallel Claude agents building a Rust-based C compiler entirely without human code contributions. The compiler — produced across nearly 2,000 agent sessions — is a 100,000-line codebase capable of building Linux 6.9 on x86, ARM, and RISC-V, passing 99% of the GCC torture test suite, and successfully compiling QEMU, FFmpeg, SQLite, PostgreSQL, and Redis.

By the numbers

• ~$20,000 in API calls over approximately two weeks of wall-clock time
• 16 agents working across independent compiler modules (parser, type-checker, code-gen, linker, etc.) in isolated git worktrees
• 99% GCC torture test pass rate — a high bar for a compiler produced without a single human-written line

Agent Teams are disabled by default and enabled via the CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS environment variable in settings.json. The experimental flag is available to all Claude Code Max subscribers.

✅ Agent Teams vs Sub-Agents — Understanding the Architecture Difference

Alongside the C-compiler showcase, Anthropic has published an architecture primer on a distinction that matters for production use: sub-agents and agent teams are not the same thing, and choosing the wrong one will hurt performance and cost.

The key difference

• Sub-agents report only to an orchestrator and cannot communicate laterally — they are hierarchical, suited for sequential decomposition, and have lower coordination overhead
• Agent teams have direct peer-to-peer messaging and a shared task board, eliminating the orchestrator bottleneck for highly parallelisable workloads where agents need to negotiate interfaces and share intermediate state

When to use each

• Use sub-agents when tasks are sequentially dependent — step B needs step A's output before starting
• Use agent teams when tasks are truly parallel with well-defined module boundaries — each agent owns a clearly bounded component with stable interfaces
• Agents work best within teams when they can write integration tests before implementing — this creates a shared contract that prevents interface drift