16 agents Claude ont codé un compilateur C en 2 semaines

#Un compilateur C écrit par des agents IA

Début février 2026, Anthropic a publié un article d'ingénierie qui a secoué la communauté dev : 16 instances de Claude Opus 4.6 ont construit, en autonomie totale, un compilateur C fonctionnel écrit en Rust. Pas un prototype. Un compilateur de 100 000 lignes capable de compiler le noyau Linux.

Le projet a été mené par Nicholas Carlini, chercheur dans l'équipe Safeguards d'Anthropic. Son objectif : tester les limites de ce que des agents IA peuvent accomplir quand on les laisse travailler ensemble, sans intervention humaine, pendant une durée prolongée.

#Ce que le compilateur peut faire

Le résultat est impressionnant. Le compilateur compile avec succès :

• Linux 6.9 sur trois architectures : x86, ARM et RISC-V
• PostgreSQL, FFmpeg, SQLite, Redis, QEMU
• Et même... Doom

Il passe 99% de la suite de torture GCC, le benchmark standard pour valider la conformité d'un compilateur C.

#Les limites honnêtes

Anthropic ne cache pas les limitations :

• Le code généré est moins performant que GCC, même avec les optimisations désactivées côté GCC
• Le compilateur utilise l'assembleur et le linker de GCC (pas d'outils custom)
• Il manque le support 16-bit x86 (GCC est appelé pour cette phase)
• La qualité du code Rust est correcte, mais loin du niveau d'un expert

Ce n'est pas un remplaçant de GCC. C'est une démonstration de capacité — et c'est déjà énorme.

#L'architecture Agent Teams

La vraie innovation, c'est la méthode. Voici comment 16 agents Claude se coordonnent pour travailler sur un même codebase.

#L'infrastructure

Chaque agent tourne dans un conteneur Docker isolé avec le repo monté sur /upstream. Les agents clonent une copie locale dans /workspace, travaillent dessus, puis poussent leurs changements vers le repo partagé.

Le système fonctionne en boucle infinie : dès qu'un agent termine une tâche, il en prend une nouvelle automatiquement.

#La coordination sans chef

Il n'y a pas d'agent "chef d'orchestre". Chaque agent choisit indépendamment le prochain problème le plus évident à résoudre. La coordination repose sur des mécanismes simples :

• Verrouillage par fichiers : chaque agent écrit un fichier dans le dossier current_tasks/ pour signaler ce sur quoi il travaille
• Git comme arbitre : les conflits de merge sont fréquents, mais Claude sait les résoudre
• Spécialisation émergente : certains agents se concentrent naturellement sur des rôles spécifiques

#Les rôles spécialisés

#Les pièges techniques (et leurs solutions)

Le projet a révélé des défis spécifiques au travail multi-agents. Ce sont des leçons précieuses pour quiconque veut construire des systèmes d'agents autonomes.

#La pollution du contexte

Quand un agent lance une suite de tests, la sortie peut être massive. Si ces résultats remplissent la fenêtre de contexte, l'agent perd de vue le code sur lequel il travaillait.

Solution : minimiser la sortie des tests à quelques lignes, logger les détails dans des fichiers séparés. Pré-calculer des statistiques agrégées. Formater les erreurs avec un préfixe ERROR pour faciliter le grep.

#La cécité temporelle

Les agents n'ont pas de notion du temps qui passe. Un agent peut lancer des tests pendant des heures sans réaliser qu'il ne progresse plus.

Solution : implémenter un flag --fast qui exécute un échantillon aléatoire de 1 à 10% des tests. L'échantillon est déterministe par agent mais varie entre les VMs, ce qui permet de détecter les régressions rapidement.

#Le verrouillage des tâches

Avec 16 agents en parallèle, le risque de travailler en double est réel.

Solution : le système de fichiers dans current_tasks/ combiné avec la synchronisation native de Git empêche qu'un seul agent travaille sur la même tâche. Quand un agent termine, il supprime son fichier de verrouillage.

#La parallélisation du debugging

Compiler le noyau Linux est une tâche monolithique. Comment paralléliser le débogage quand tout doit fonctionner ensemble ?

Solution : utiliser GCC comme oracle — un compilateur de référence dont on sait qu'il produit du code correct. Compiler aléatoirement certaines sections du noyau avec GCC et le reste avec le compilateur Claude. Cela permet d'isoler les erreurs par fichier et d'appliquer des techniques de delta debugging.

#Au-delà du compilateur : Opus 4.6 en chiffres

Le projet compilateur est spectaculaire, mais il s'inscrit dans un contexte plus large. Claude Opus 4.6 représente un saut qualitatif pour les agents autonomes.

#Les benchmarks

Le score MRCV2 est particulièrement frappant : à 1 million de tokens de contexte, Opus 4.6 retrouve 76% des informations ciblées contre seulement 18,5% pour Sonnet 4.5. C'est ce qui permet à un agent de maintenir la cohérence sur un projet de 100 000 lignes.

#La découverte de vulnérabilités zero-day

En parallèle du compilateur, Anthropic a démontré une autre capacité d'Opus 4.6 : la découverte de failles de sécurité.

Sans outillage spécialisé ni prompt custom, Claude a identifié plus de 500 vulnérabilités zero-day dans des projets open-source majeurs comme GhostScript, OpenSC et CGIF. Des failles de corruption mémoire, de dépassement de buffer, de traversée de chemin.

Chaque vulnérabilité a été validée soit par un membre de l'équipe Anthropic, soit par un chercheur en sécurité externe. Les patches ont été développés et soumis aux mainteneurs.

#Rakuten : 50 développeurs managés par une IA

Côté entreprise, Rakuten a testé Opus 4.6 sur son issue tracker. Résultat : Claude a autonomement fermé 13 issues et routé 12 autres vers les bons membres de l'équipe en une seule journée — dans une organisation de 50 personnes répartie sur 6 dépôts.

Le modèle a géré des décisions à la fois techniques et organisationnelles, en synthétisant le contexte à travers plusieurs domaines. Et surtout, il savait quand escalader vers un humain.

#Ce que ça change pour les développeurs

Il y a un an, les agents IA tenaient environ 30 minutes d'autonomie avant de dérailler. Aujourd'hui, on parle de deux semaines de travail continu et cohérent.

Ce n'est pas juste une amélioration incrémentale. C'est un changement de nature dans ce que les agents peuvent accomplir :

• Projets entiers au lieu de fonctions isolées
• Coordination multi-agents au lieu d'un agent solitaire
• Auto-correction au lieu d'abandon au premier obstacle

#Ce qui ne change pas

Le compilateur Claude ne remplace pas GCC. Les agents ne remplacent pas les développeurs. La qualité du code produit reste inférieure à celle d'un expert humain.

Mais la trajectoire est claire. Les agents passent de l'assistant ponctuel au collaborateur capable de porter un projet. Et le coût — 20 000 dollars pour un compilateur C fonctionnel en deux semaines — pose des questions intéressantes sur l'économie du développement logiciel.

#Pour aller plus loin

• L'article technique complet d'Anthropic : Building a C compiler with a team of parallel Claudes
• L'annonce officielle d'Opus 4.6 : Introducing Claude Opus 4.6
• Les découvertes de zero-days : red.anthropic.com/2026/zero-days