# carlini-anthropic-building-c-compiler-parallel-claudes-2026-02-05

## Veille

Compilador de C en Rust construido por 16 agentes autónomos de Claude en paralelo - Anthropic

## Titre Article

Building a C Compiler with a Team of Parallel Claudes

## Date

2026-02-05

## URL

https://www.anthropic.com/engineering/building-c-compiler

## Keywords

compilador de C, Rust, agentes en paralelo, Claude Opus 4.6, autonomía de agentes de IA, Claude Code, programación agéntica, Linux 6.9, x86, ARM, RISC-V, 100.000 líneas, 20.000 dólares, Docker, sincronización de agentes, pruebas automatizadas, GCC, especialización de agentes, seguridad de agentes autónomos

## Authors

Nicholas Carlini (chercheur équipe Safeguards, Anthropic)

## Ton

**Perfil**: Publicación técnica de ingeniería, registro narrativo-analítico, nivel técnico muy avanzado

**Descripción**: Publicación del blog de ingeniería de Anthropic que combina el relato de un experimento con lecciones técnicas. El tono es el de un investigador de seguridad que comparte, con entusiasmo y honestidad, un proyecto personal que lleva al límite las capacidades del modelo. La redacción alterna descripciones técnicas precisas (scripts bash, arquitectura Docker, algoritmos de sincronización) con reflexiones más amplias sobre las implicaciones. El autor reconoce abiertamente las limitaciones y los riesgos de seguridad, aportando una perspectiva matizada gracias a su experiencia en pentesting. El público objetivo son ingenieros e investigadores de IA interesados en los sistemas multiagente autónomos.

## Pense-betes

- **Resultado principal**: compilador de C en Rust de 100.000 líneas, construido por 16 agentes Claude Opus 4.6 en paralelo, ~2.000 sesiones de Claude Code, coste ~20.000 dólares
- **El compilador compila Linux 6.9** en x86, ARM y RISC-V, además de QEMU, FFmpeg, SQLite, PostgreSQL, Redis y Doom
- **Arquitectura de agentes paralelos**:
- Bucle bash sencillo que relanza Claude en modo `--dangerously-skip-permissions`
- Contenedores Docker aislados, repositorios montados en `/upstream`
- Sincronización mediante archivos de bloqueo en `current_tasks/` + Git
- Sin comunicación entre agentes ni orquestación explícita — selección autónoma de tareas
- **Especialización por rol**: deduplicación de código, optimización de rendimiento, eficiencia del código generado, revisión de diseño en Rust, documentación
- **Lecciones clave para agentes autónomos**: 1. **Tests de muy alta calidad**: los agentes resuelven exactamente lo que se les da, por lo que la precisión de los tests es crítica 2. **Pensar desde la perspectiva de Claude**: cada agente entra en un contenedor vacío → se requieren READMEs exhaustivos; salida de tests mínima; flag `--fast` para muestreo aleatorio (1-10%) 3. **Habilitar el paralelismo**: sencillo cuando fallan muchos tests independientes, difícil para una tarea monolítica (p. ej. la compilación del kernel de Linux). Solución: GCC como "oráculo de referencia" + compilación parcial aleatoria 4. **Roles múltiples**: la especialización se vuelve posible una vez establecido el paralelismo
- **Progresión de los modelos**: Opus 4 = compilador apenas funcional, Opus 4.5 = primer compilador que supera las suites de pruebas, Opus 4.6 = compila Linux
- **Consumo**: 2.000 millones de tokens de entrada, 140 millones de tokens de salida, ~20.000 dólares — una fracción del coste del desarrollo humano
- **Limitaciones reconocidas**: sin x86 de 16 bits (recurre a GCC), ensamblador/enlazador incompletos, no universalmente compatible, código generado menos eficiente que GCC -O0, calidad del código Rust decente pero no de nivel experto
- **Seguridad**: el autor (con experiencia en pentesting) subraya que superar los tests no garantiza la corrección; desplegar software autónomo no verificado es un riesgo real
- **Cita memorable**: "Building this compiler has been some of the most fun I've had recently, but I did not expect this to be anywhere near possible so early in 2026."
- **Código fuente**: disponible en GitHub (anthropics/claudes-c-compiler)

## RésuméDe400mots

Nicholas Carlini, investigador del equipo Safeguards de Anthropic, dirigió un experimento ambicioso: construir un compilador de C en Rust íntegramente mediante agentes de Claude Opus 4.6 trabajando en paralelo, sin intervención humana directa sobre el código.

**Arquitectura multiagente**: 16 instancias de Claude trabajaron simultáneamente en contenedores Docker aislados, compartiendo un repositorio Git upstream. Cada agente selecciona de forma autónoma su siguiente tarea mediante un sistema de bloqueo de archivos (file-locking). La sincronización se apoya en Git: un agente reclama una tarea, trabaja en ella, envía sus cambios (push) y pasa a la siguiente. No se requiere comunicación explícita entre agentes.

**Resultados notables**: en aproximadamente 2.000 sesiones de Claude Code y 20.000 dólares de coste de API (2.000 millones de tokens de entrada, 140 millones de tokens de salida), el compilador resultante, de 100.000 líneas, compila con éxito Linux 6.9 en tres arquitecturas (x86, ARM, RISC-V), así como proyectos importantes como QEMU, FFmpeg, SQLite, PostgreSQL, Redis e incluso Doom, con una tasa de éxito del 99% en las suites de pruebas de compiladores, incluida la suite de tortura de GCC.

**Lecciones de diseño**: el autor comparte cuatro conclusiones clave. Primero, la calidad de los tests es crítica porque los agentes resuelven exactamente lo que se especifica. Segundo, hay que pensar desde la perspectiva de Claude: cada agente entra en un entorno vacío sin contexto, lo que exige documentación exhaustiva y una salida mínima para preservar la ventana de contexto. Tercero, habilitar el paralelismo es esencial: sencillo cuando fallan muchos tests independientes, pero la compilación del kernel de Linux resultó problemática porque todos los agentes corregían los mismos errores. La solución: usar GCC como "oráculo de referencia" para distribuir aleatoriamente los archivos a compilar. Cuarto, especializar a los agentes por rol (deduplicación, optimización, revisión de diseño, documentación) maximiza la eficiencia.

**Progresión de los modelos**: el artículo también sirve como banco de pruebas de capacidades. Opus 4 apenas produjo un compilador funcional, Opus 4.5 permitió que el primer compilador superara las suites de pruebas, y Opus 4.6 empuja los límites al compilar proyectos reales a gran escala.

**Preocupaciones de seguridad**: el autor, apoyándose en su experiencia en pentesting, señala que superar los tests no garantiza la corrección del software. El despliegue autónomo de código no verificado por humanos representa un riesgo real que exige nuevas estrategias de seguridad. El código fuente está disponible en GitHub (anthropics/claudes-c-compiler).

## GrapheDeConnaissance

- Nicholas Carlini —utilise→ agents parallèles (METHODOLOGIE, 0.99)
- Nicholas Carlini —travaille_chez→ Anthropic (ORGANISATION, 0.99)
- Nicholas Carlini —a_créé→ compilateur C en Rust (TECHNOLOGIE, 0.99)
- Claude Opus 4.6 —a_créé→ compilateur C en Rust (TECHNOLOGIE, 0.99)
- compilateur C en Rust —s_applique_à→ Linux 6.9 (TECHNOLOGIE, 0.98)
- compilateur C en Rust —mesure→ 99% de réussite sur suites de tests (MESURE, 0.97)
- agents parallèles —utilise→ Docker (TECHNOLOGIE, 0.98)
- agents parallèles —utilise→ synchronisation par fichiers verrou (METHODOLOGIE, 0.97)
- agents parallèles —utilise→ GCC (TECHNOLOGIE, 0.95)
- spécialisation par rôle —améliore→ agents parallèles (METHODOLOGIE, 0.9)
- sécurité agents autonomes —est_basé_sur→ vérification humaine (CONCEPT, 0.92)
- Nicholas Carlini —affirme_que→ la qualité des tests est critique pour les agents autonomes (AFFIRMATION, 0.97)
- Claude Opus 4.6 —surpasse→ Claude Opus 4.5 (TECHNOLOGIE, 0.96)

---
Canonical: https://www.thekb.eu/es/fiches/carlini-anthropic-building-c-compiler-parallel-claudes-2026-02-05/