Google Antigravity 2.0: 96 agentes crean un sistema operativo desde cero en 12 horas por menos de $1.000
TL;DR
- Google publicó Antigravity 2.0, un experimento donde 96 agentes LLM coordinados generaron un sistema operativo funcional desde cero.
- El sistema operativo resultante corre Doom — la métrica no-oficial de “es real” en software generado por IA.
- Coste total: menos de $1.000 en tokens. Tiempo: 12 horas.
- El post en r/singularity acumuló 1.594 upvotes y 303 comentarios — una de las señales más fuertes del mes.
- Esto no es un truco de marketing. Es la demostración más clara hasta la fecha de que los sistemas multi-agente pueden producir software funcional complejo, no solo snippets o funciones aisladas.
Qué es Antigravity 2.0
Antigravity es el proyecto interno de Google DeepMind que explora hasta dónde pueden llegar los sistemas multi-agente en la generación de software completo. La versión 2.0 lleva el concepto a un nuevo extremo: un sistema operativo entero, con scheduler, drivers, filesystem y capacidad de ejecutar aplicaciones.
Los detalles técnicos públicos son limitados — Google no ha publicado un paper formal aún —, pero lo que sabemos del post original y la discusión:
| Métrica | Valor |
|---|---|
| Agentes coordinados | 96 |
| Tiempo de generación | ~12 horas |
| Coste en tokens | < $1.000 |
| Output | Sistema operativo funcional |
| Verificación | Ejecuta Doom |
| Arquitectura | Multi-agente con especialización de roles |
La métrica de Doom no es accidental. “It runs Doom” se ha convertido en el benchmark cultural de “¿esto es software real o una demo?” Si un SO generado por agentes puede correr un juego con rendering en tiempo real, significa que la cadena de abstracción —desde el kernel hasta el framebuffer— funciona.
Por qué importa para desarrolladores
1. La complejidad que un sistema multi-agente puede manejar saltó de orden de magnitud
Hasta ahora, los sistemas multi-agentes demostrados públicamente generaban: aplicaciones web sencillas, scripts de automatización, componentes de UI. Antigravity 2.0 genera infraestructura de sistemas: la capa más baja y compleja del software.
La diferencia entre “generar una landing page” y “generar un scheduler de procesos” es enorme. No es incremental — es un salto cualitativo.
2. El coste es trivial comparado con el output
Menos de $1.000 en tokens para producir un sistema operativo es absurdamente barato. Un equipo de ingenieros senior tardaría meses en escribir un SO desde cero. Incluso con modelos frontier a $5/$30 por millón de tokens, el coste de coordinar 96 agentes durante 12 horas se mantiene por debajo de cuatro cifras.
Esto tiene implicaciones directas para arquitectura de agentes en producción:
| Enfoque | Coste aprox. | Output | Escalabilidad |
|---|---|---|---|
| 1 agente (coding assistant) | $1-10/día | Funciones, fixes | Limitada por contexto |
| 5-10 agentes (pipeline) | $50-200/día | Apps completas | Bien documentada |
| 96 agentes (Antigravity) | <$1.000 total | Sistema operativo | Frontera actual |
3. La especialización de roles funciona a esta escala
96 agentes no hacen lo mismo en paralelo. El sistema asigna roles especializados: unos diseñan el kernel, otros escriben drivers, otros implementan el filesystem, otros hacen testing. Es una organización de ingeniería replicada en agentes.
Esto valida el patrón de orquestación con roles que ya usamos en sistemas más pequeños — ver arquitecturas multi-agente 2026 — pero a una escala que parecía teórica hace meses.
Lo que no sabemos (y debería preocupar)
Reproducibilidad
Google tiene ventajas que el resto no: infraestructura propia (TPUs), modelos internos ajustados, y un equipo de investigación dedicado. El experimento es impresionante, pero ¿puede un equipo estándar replicarlo con APIs públicas?
Probablemente no con los mismos resultados. La diferencia entre un experimento de Google y una arquitectura reproducible por la comunidad es enorme.
Mantenibilidad del código generado
Un SO que corre Doom en 12 horas de generación es impresionante. Pero ¿qué pasa cuando hay que mantenerlo, debuggearlo o extenderlo? El código generado por agentes tiende a ser funcional pero denso, sin la estructura que un humano necesitaría para mantenerlo.
La métrica “it runs” no implica “it’s maintainable”. Y para software en producción, lo segundo importa más que lo primero.
Verificación formal
Un SO tiene requisitos de seguridad y correctness que una landing page no tiene. Si los agentes generan el scheduler, ¿quien verifica que no haya race conditions? ¿Deadlocks? ¿Memory leaks?
El que corra Doom demuestra que funciona en el happy path. Pero los edge cases en sistemas operativos son donde viven los bugs catastróficos.
Qué significa para la línea editorial
Antigravity 2.0 encaja en una tendencia que llevamos tracking todo el año: los sistemas multi-agente ya no son demos académicas. Son arquitecturas que producen software real, medible y (potencialmente) útil.
La pregunta para devs no es “¿pueden los agentes generar software?” — ya sabemos que sí. Es “¿dónde está el límite entre lo que los agentes generan bien y lo que sigue necesitando supervisión humana?” Antigravity 2.0 empuja ese límite más lejos de lo que nadie esperaba en junio de 2026.
Qué haría yo
Si te interesa explorar arquitecturas multi-agente a escala:
- Empieza pequeño: 5-10 agentes con roles claros (planner, coder, tester, reviewer) son el sweet spot actual. Ver nuestra guía de infraestructura de agentes.
- Mide costes desde el minuto uno: 96 agentes durante 12 horas pueden escalarse a $10.000 si los modelos no son eficientes. Usa routing multi-modelo para enviar tareas simples a modelos baratos.
- Define verificación, no solo generación: si los agentes generan código, necesitas otros agentes (o humanos) que lo verifiquen. El patrón drafter-reviewer es un buen punto de partida.
- No intentes replicar Antigravity en producción: es un experimento de investigación. Aprende de él, pero tu sistema en producción debería ser más conservador.
Fuentes
- r/singularity: Google’s Antigravity 2.0 creates an operating system from scratch using 96 agents (score 1.594, 303 comentarios)
- Análisis interno: Arquitecturas multi-agente — patrones 2026
- Análisis interno: Infraestructura de agentes 2026
- Análisis interno: Multi-model validation: patrón drafter-reviewer