Anthropic’s compiler experiment exposes the real work of agent handoffs

On February 5, 2026, Anthropic researcher Nicholas Carlini described using 16 Claude instances to build a C compiler in Rust. The company reported nearly 2,000 sessions and about $20,000 in API costs, producing a 100,000-line compiler capable of building Linux 6.9 on several architectures. The headline was autonomous coding at scale. The more revealing engineering detail was how the agents divided work without a central orchestration agent. Anthropic C compiler experiment.

Splitting an assignment among several agents can make the work look organized. The harder task is making each handoff unambiguous. One agent's confident summary can become another's unexamined premise. Multi-agent autonomy therefore needs to explain not just who performs each step, but what evidence moves between steps and who resolves conflicting conclusions.

AutoGen, first submitted August 16, 2023, described a framework for applications built through conversations among customizable agents, tools, and people. It demonstrated flexible interaction patterns. The framework provides building blocks, not a claim that adding agents automatically improves every task. AutoGen paper.

Specify the deliverable

Our recommendation is to give each delegated task a concrete output contract. A research agent should return sources and unresolved questions. An implementation agent should return a change and validation evidence. A reviewer should identify actionable problems rather than merely express agreement. These distinct deliverables make it easier to inspect whether the division of labor actually helped.

MetaGPT, submitted August 1, 2023, incorporated structured operating procedures and role assignments into multi-agent collaboration. Its authors aimed to address inconsistencies from naïvely chaining model outputs. The comparison reinforces that coordination design is an important part of the system being evaluated. MetaGPT paper.

Measure the whole chain

We would compare a multi-agent arrangement with a simpler baseline on completion quality, latency, cost, and human review effort. Include tasks that produce disagreement, because that is where ownership becomes visible. Multiple agents are useful when their organization improves evidence and execution. They are expensive theater when they merely distribute one unsupported assumption across a larger conversation.

A handoff can be a file, not a conversation

Carlini’s prototype gave agents separate containers connected through a shared Git repository. Agents claimed tasks by writing lock files, worked locally, synchronized changes, and removed the locks. This is a concrete coordination mechanism: another agent could see that a piece of work was already owned. The report also describes frequent merge conflicts. Parallel work did not eliminate integration; it moved integration into the agents’ operating environment. Anthropic C compiler experiment.

The research product used another arrangement

Anthropic’s June 13, 2025 account of its Research feature described a lead agent delegating searches to subagents and synthesizing the findings. A separate citation stage connected claims to source locations. The company reported that early versions sometimes duplicated searches or created far too many subagents. Its response included clearer task descriptions and output requirements. This was a production architecture for information gathering, unlike the compiler prototype’s decentralized task claiming. Anthropic multi-agent research system.

Different work needs different boundaries

The two systems illustrate why “multi-agent” is not a complete architectural description. A compiler project contains files, tests, and interfaces that several workers can modify. A research assignment contains questions, sources, and competing interpretations. Both benefit from dividing work, but the handoff object differs. Code must integrate into a working program. Research must integrate into an argument whose evidence can still be inspected.

A useful handoff therefore carries more than a cheerful declaration that the task is done. It identifies what changed, what remains uncertain, and where the recipient can verify the result. In software, a commit and a test output can serve that role. In research, a source reference and a carefully bounded claim can do so. Compressing everything into a conversational summary risks losing exactly the detail that another worker needs to distinguish a result from an assertion.

The integration cost does not disappear

The compiler example is especially valuable because it makes coordination visible without attributing human personalities to the agents. A lock file is an attempt to prevent duplicated effort. A merge conflict is evidence that separate changes interacted. Neither problem is solved merely by giving one model the title of manager and another the title of engineer. The underlying dependencies still need representation.

This puts a limit on comparisons based on agent count. Sixteen workers can be useful when the work contains sixteen separable pieces. They can become an expensive queue when every piece depends on the same unresolved design choice. The relevant quantity is the amount of independently verifiable progress, not the number of simultaneous conversations.

For readers following agent deployment, the stronger story is that coordination mechanisms are becoming explicit artifacts: repositories, task claims, citations, and persistent outputs. These are inspectable in a way that an agent’s confidence is not. The next convincing demonstrations will show how those artifacts preserve correctness when work is interrupted, revised, or combined. Anthropic’s reports show substantial progress, but also show why a successful team depends on the shape of the work and the quality of the handoff—not simply on replicating a capable model.

The research behind the release

AutoGen’s August 2023 paper presented configurable agents that could combine language models, tools, and human participation through conversation. Its contribution was a framework for composing interaction patterns, rather than a proof that any chosen team structure improves every task. That distinction helps interpret the later compiler experiment. The useful unit is not an agent with a job title; it is a worker with a bounded input, an inspectable output, and a way to coordinate access to shared state. Framework flexibility enables many arrangements. The workload still determines which arrangement produces progress instead of duplicated effort. Original research paper.