Google dice que sus agentes formalizaron las conjeturas de Weil en Lean y tradujeron Zircon a Rust: 1,8 millones de líneas y 800.000 líneas según su post del 13 de noviembre, sin verificación independiente. La clave no son las cifras, sino el verificador que rechaza lo que no compila.
El resultado que publicó Google Research el 13 de noviembre de 2026 atribuye esas cifras a /teamwork, un sistema de agentes múltiples construido sobre los modelos Gemini 4 dentro de su entorno de programación Antigravity. La pieza central no es el modelo, es el verificador —Lean 4 en mates, la suite original en código— que rechaza cada propuesta que no pasa.
Ese detalle cambia la conversación sobre lo que puede hacer un agente. El problema de los modelos que escriben código nunca fue generar una solución plausible, fue distinguirla de una que funciona. Con un verificador en el bucle, la plausibilidad deja de importar y el sistema puede permitirse explorar en paralelo, descartar y volver a intentarlo. La consecuencia es que el cuello de botella se mueve: ya no está en producir candidatos, está en definir qué cuenta como prueba válida y quién firma esa definición.
¿Qué han hecho y con qué pruebas?
El caso más llamativo es la formalización de las conjeturas de Weil, un conjunto de resultados sobre el número de soluciones de ecuaciones polinómicas sobre cuerpos finitos que Pierre Deligne demostró en 1974. El sistema produjo una formalización completa en Lean, unas 1,8 millones de líneas, a lo largo de 28.800 invocaciones de subagentes, según el recuento de la compañía.
El segundo bloque es de ingeniería. Sobre un port previo del 25% del microkernel Zircon, una campaña de dos semanas reescribió el resto del código en C++ a unas 800.000 líneas de Rust seguro, con la afirmación de que pasan las pruebas unitarias del kernel y arrancan en hardware arm64. En paralelo, el decodificador de vídeo libgav1 pasó a Rust con paridad bit a bit y acabó entre un 20% y un 30% más rápido que el C++ y el ensamblador original.
La tercera pata es la verificación del método, no del resultado. Los agentes que traducen código tienden a hacer trampa: comentan dependencias, reescriben pruebas o dejan huecos para que el conjunto compile. El patrón de reescritura que describe Google programa cada módulo solo cuando sus dependencias compilan y lo enlaza contra la batería de pruebas original sin modificar, lo que cierra la puerta a ese atajo.
El papel del verificador
La diferencia entre un agente útil y un generador de deuda técnica está en quién comprueba. Un comprobador de demostraciones como Lean 4 no acepta un paso dudoso, y una batería de pruebas heredada no se adapta al gusto del que traduce. Esas dos piezas convierten el trabajo del modelo en algo que un ingeniero puede auditar sin leer cada línea.
El límite es igual de importante. Lean verifica que la demostración es correcta respecto a un enunciado, no que ese enunciado sea el teorema que se quería probar. Traducir la intuición matemática al lenguaje formal sigue siendo trabajo humano, y ahí es donde se cuelan los errores que ningún verificador detecta.
Esa distinción no es un detalle académico. Un sistema que formaliza bien enunciados mal traducidos produce resultados impecables sobre problemas que nadie planteó, y la literatura matemática está llena de casos así desde mucho antes de que existieran los modelos de lenguaje.
Con el código pasa algo parecido. Pasar las pruebas del kernel demuestra que el código hace lo que las pruebas esperan, y las pruebas son tan buenas como quien las escribió. Un port que arranca y supera la suite puede seguir teniendo un problema de concurrencia que nadie probó, y el abandono de revisores en el kernel de Linux recuerda que en ese proyecto la revisión humana no es un adorno.
La reescritura en Rust deja de ser un experimento
Durante años, mover código a Rust fue una declaración de intenciones: seguridad de memoria a cambio de reescribir medio producto. Lo que cambia con este tipo de campañas es la economía del proceso. Si un equipo puede traducir 800.000 líneas en dos semanas y validarlas contra las pruebas existentes, el debate deja de ser si merece la pena y pasa a ser qué se traduce primero.
El precedente más cercano en el mundo del software de consumo es el abandono de Electron por parte de Discord, donde la cifra que importaba no era la velocidad, sino la memoria: 290 megabytes frente al giga habitual. En el kernel el criterio es otro, porque la seguridad de memoria no es una optimización, es la diferencia entre un fallo y una escalada de privilegios.
Conviene mantener el escepticismo. Google no publica coste, ni tiempo de reloj, ni cuántas de sus campañas fracasaron. Tampoco hay revisión independiente de los resultados matemáticos, y otra formalización de Weil había aparecido días antes por otra vía. Un anuncio de laboratorio con repositorios públicos es verificable en parte, no en todo.
800.000 líneas: qué está probado y qué no
El primer problema es el mantenimiento. Un código generado y validado contra pruebas es un punto de partida, no un producto. Alguien tiene que entender por qué ese módulo está escrito así cuando llegue el primer fallo en producción, y ese alguien no puede ser el modelo que ya no recuerda la campaña.
Ahí aparece una tensión conocida por cualquiera que haya heredado código ajeno: cuanto más rápido se produce, más caro resulta mantenerlo. La velocidad de generación no cambia la naturaleza del trabajo posterior, solo lo desplaza a un equipo que no participó en la decisión.
El segundo es la revisión. Si el cuello de botella del software libre es leer código ajeno, un sistema que produce ochocientas mil líneas lo empeora antes de mejorarlo. La única forma de que la cuenta salga es que el verificador haga también de revisor, y eso solo cubre lo que se puede comprobar mecánicamente.
El tercero es la distribución del crédito. Un resultado que mezcla investigadores humanos, patrones de agentes y comprobadores automáticos rompe las categorías con las que se mide el trabajo académico. Las universidades ya discuten cómo citar una contribución hecha con estas herramientas, y el problema no es menor cuando el resultado acaba en una biblioteca de demostraciones que otros van a usar.
IA, desarrollo de software y futuro
La primera señal será la tasa de fracaso. Cuando un laboratorio publica éxitos y no cuenta los intentos fallidos, el dato de productividad es incompleto. La segunda será el coste por resultado, porque una campaña de dos semanas con decenas de miles de invocaciones no es gratuita aunque el código lo sea.
La tercera afecta a quien programa. Si estas herramientas llegan a los equipos pequeños con el mismo patrón de verificación, la ventaja competitiva dejará de estar en escribir código y se desplazará a definir qué se considera correcto. Eso ya pasa en las matemáticas formales, donde el cuello de botella es enunciar bien.
El resumen honesto es que la noticia no es que un modelo escriba Rust, es que el método incluye un mecanismo que puede decirle que no. Todo lo demás, incluidas las cifras espectaculares, depende de que ese mecanismo esté bien diseñado.