Anthropic : 16 agents IA ont construit un compilateur C en 2 semaines

Comment 16 agents Claude ont écrit 100 000 lignes de code de production

Le chercheur d’Anthropic Nicholas Carlini a conduit une expérience qui donne des chiffres concrets au paradigme de codage multi-agents : 16 agents Claude, travaillant en parallèle pendant deux semaines, ont produit de zéro un compilateur C en Rust. Le résultat — 100 000 lignes de code — peut compiler le noyau Linux, PostgreSQL, FFmpeg, Redis, QEMU, et fait même tourner Doom.

Le coût : 20 000 dollars en tokens API sur près de 2 000 sessions Claude Code, consommant près de 2 milliards de tokens en entrée et 140 millions en sortie.

L’enseignement clé — le test comme 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.” (Claude résout de manière autonome n’importe quel problème qu’on lui soumet. Il est donc essentiel que le vérificateur de tâches soit quasi parfait, sinon Claude résout le mauvais problème.) La percée de Carlini a été d’utiliser GCC comme « oracle de référence » — un compilateur de référence contre lequel les agents pouvaient vérifier leurs sorties. Cela a transformé une tâche créative ambiguë en un problème d’ingénierie vérifiable que les agents pouvaient résoudre indépendamment.

Travail parallèle via verrouillage git : Les 16 agents n’ont pas empiété les uns sur les autres grâce à un mécanisme de coordination simple : un système de verrouillage basé sur git qui attribuait des défis de compilation distincts à chaque agent. Pas d’orchestrateur central, pas de protocole de communication complexe — juste des tâches isolées avec un standard de vérification commun.

Ce que le compilateur accomplit :

• Passe 99 % de la suite de tests de torture de GCC
• Compile Linux 6.9 sur les architectures x86, ARM et RISC-V
• Construit des logiciels réels : PostgreSQL, FFmpeg, Redis, SQLite, QEMU
• Implémentation en chambre blanche sans accès à Internet — ne dépend que de la bibliothèque standard de Rust

Pourquoi la coordination multi-agents est la clé

• Le parallélisme bat le travail en série — 16 agents travaillant simultanément ont accompli en deux semaines ce qu’un seul agent mettrait des mois à faire. Le schéma : décomposer en tâches indépendantes et vérifiables, puis les exécuter en concurrence.
• La vérification plutôt que la supervision — Au lieu de surveiller les agents au travail, Carlini a construit une vérification automatisée. Les agents n’avaient pas besoin de revue humaine car l’oracle de test détectait les erreurs automatiquement.
• Une économie frappante — 20 000 dollars et deux semaines pour un compilateur de 100 000 lignes. Pour comparaison, GCC a été construit par des milliers d’ingénieurs sur 37 ans. Le résultat n’est pas aussi optimisé, mais il fonctionne.
• Les agents ont besoin de limites, pas de microgestion — Chaque agent avait un périmètre clair (fichiers de compilation spécifiques), un mécanisme de vérification (oracle GCC) et un isolement (verrouillage git). C’est le schéma émergent pour l’orchestration d’agents : tâches claires, vérifications automatisées, surcharge de coordination minimale.

Ce que cela signifie pour les organisations propulsées par l’IA

Ce n’est pas seulement une histoire de compilateur — c’est une preuve de concept pour la façon dont les équipes IA fonctionneront en production. Le schéma que Carlini a démontré (agents spécialisés en parallèle, vérification automatisée, coordination git) est la même architecture qui alimente les workflows métier multi-agents : chaque agent possède une fonction, la vérification assure la qualité, et le système monte en charge en ajoutant plus d’agents, pas plus de supervision humaine.

Les limites comptent aussi : le code généré n’est pas efficace, et certains cas limites nécessitent encore GCC. Cela reflète ce que les organisations constatent lors du déploiement d’employés IA — ils gèrent 80 % du travail de manière fiable, les humains couvrant les 20 % restants qui requièrent jugement et optimisation.