Idioma

Programación

Migración del runtime de Copilot a Rust costó 120.000 dólares en IA

GitHub completó la migración del runtime de Copilot a Rust en septiembre de 2026, con agentes de inteligencia artificial que escribieron la mayor parte de más de 800.000 líneas de Rust de producción en 14,5 semanas. The Register informa que el cambio costó unos 120.000 dólares en tokens de IA más unas tres semanas de trabajo de un desarrollador, y GitHub dice que un escenario de arranque medido bajó de 5,25 segundos a 292 milisegundos. Para las empresas con grandes bases de código heredado, es un caso medido de agentes que hacen una reescritura que antes requería un equipo entero.

Por Mike Mozg4 min de lectura

Por qué GitHub tuvo que sacar el runtime de TypeScript

El runtime de agentes de Copilot es el motor detrás de GitHub Copilot CLI, la app de Copilot, el Copilot SDK y el agente de Copilot en la nube. También da soporte a VS Code, Visual Studio, Excel, Outlook, PowerPoint y Word. Estaba escrito en TypeScript sobre Node.js y el motor V8, una plataforma pensada para desarrollar rápido, no para arrancar rápido ni para servidores densos.

Esa elección se volvió cara a medida que el runtime se extendía. Cada aplicación que usaba el SDK tenía que iniciar un proceso aparte para alojar Node.js y V8. GitHub dice que eso sumaba unos 100 MB de memoria de trabajo por cliente, obligaba a que cada evento y mensaje cruzara un límite entre procesos y hacía que un fallo en Node se llevara la sesión con él.

Qué construyó GitHub en su lugar

GitHub reemplazó el runtime con una biblioteca nativa en Rust que las aplicaciones anfitrionas pueden integrar directamente a través de una ABI de C, y mantuvo disponible un modo fuera de proceso. El Copilot SDK conserva interfaces específicas para TypeScript, Python, Go, .NET, Java y Rust.

«Esto de ninguna manera afirma que todo programa grande en TypeScript deba pasar a Rust». Stephen Toub, Microsoft Distinguished Engineer, sobre la migración

Toub escribió que los requisitos del equipo eran la integración a través de una ABI de C, un bajo costo de arranque y en régimen estable, y un uso de recursos predecible.

Cómo hicieron el trabajo los agentes en el día a día

La migración avanzó por partes y no con un gran cambio de una sola vez. Los componentes de TypeScript se reemplazaron uno a uno con Rust, conectados por una capa de compatibilidad temporal para que las pruebas de extremo a extremo existentes pudieran ejercitar el código nuevo. Esa capa llegó a 2.019 exportaciones internas y 3.356 puntos de llamada en TypeScript antes de retirarse. El trabajo entró en 128 pull requests, y GitHub publicó 135 versiones durante la migración, 35 estables y 100 preliminares.

Copilot reescribió Copilot, con varios modelos, entre ellos GPT-5.6 Sol y Claude Opus 4.8, para distintas partes del trabajo. Los agentes pasaron más tiempo reuniendo información que escribiendo código. El archivo más difícil, session.ts, tenía más de 30.000 líneas de TypeScript. Su sesión de migración duró 25 horas: pasó 56 minutos leyendo documentación, hizo 122 llamadas a herramientas y abrió 15 sesiones hijas que se coordinaban entre sí. GitHub registró 4.478 compilaciones de verificación directas, y el 87,1% terminó sin errores.

Qué midió la migración

GitHub y The Register reportan estos resultados:

  • Tamaño: al 21 de agosto, el runtime tenía 832.378 líneas de Rust de producción y 468.689 líneas de pruebas unitarias en Rust. Los agentes convirtieron unas 430.000 líneas de TypeScript, frente a una estimación de principios de mayo de 2026 de unas 130.000.
  • Arranque: un escenario de inicio del cliente, creación de sesión y un solo turno bajó de 5,25 segundos a 292 milisegundos con el runtime de Rust integrado en el proceso.
  • Rendimiento: en 1.000 ciclos de vida de sesiones de un turno sobre 100 flujos concurrentes, TypeScript completó 7,55 por segundo y Rust integrado en el proceso 120 por segundo, 15,9 veces más rápido.
  • Memoria: un lote de 10 clientes usó 1.383 MB con TypeScript y 126 MB con Rust.
  • Costo: unos 120.000 dólares en tokens de IA más unas tres semanas de trabajo de un desarrollador.

Dónde se equivocaron los agentes

La reescritura no fue limpia. The Register informa unas cuantas decenas de regresiones, código que compilaba pero ya no se comportaba como antes. Toub las atribuyó a semánticas ambiguas, ramas que se desviaron, funciones que no se migraron y código de reemplazo que se comportaba distinto. Escribió que «si compila, es correcto» solo sirve como chiste.

La compilación, las pruebas y la revisión humana detectaron estos problemas en el camino. La reestructuración del propio runtime quedó fuera del alcance y es el siguiente paso.

Qué cambia para las empresas con código heredado

La tarea de negocio aquí es la reescritura para la que nadie tiene personal. GitHub dice que, antes de los agentes, el proyecto le habría tomado a un equipo entero de desarrolladores uno o dos años, y que en cambio lo completó sobre todo un solo desarrollador en pocos meses, mientras el resto del equipo seguía sumando funciones.

El método importa tanto como los agentes: pull requests pequeños, un puente temporal entre el código viejo y el nuevo, las pruebas existentes y una persona que revisa cada cambio. Una empresa que evalúe su propia migración puede comparar sus costos con una cifra pública, unos 120.000 dólares en tokens para este trabajo.

Preguntas y respuestas

¿Cuánto tardó la migración del runtime de Copilot a Rust?

Unas 14,5 semanas, entregadas en 128 pull requests mientras GitHub seguía publicando versiones del runtime.

¿Cuánto costó la reescritura asistida por IA?

The Register informa unos 120.000 dólares en tokens de IA más unas tres semanas de trabajo de un desarrollador.

¿El compilador de Rust detectó los errores de los agentes?

Solo algunos. El compilador confirma que el código es Rust válido, no que conserve el comportamiento anterior, así que las pruebas y la revisión humana encontraron las regresiones que compilaban sin errores.

La visión de MOZGII

Cómo lo construiríamos

La lección que sacaríamos de este caso es que los agentes fueron la parte barata. Lo que hizo que funcionara fue la batería de pruebas que ya existía, el puente que permitió que el código viejo y el nuevo corrieran lado a lado y el ingeniero que revisó los cambios.

Si migráramos una base de código grande con agentes, primero capturaríamos en pruebas el comportamiento que nos importa en los bordes: entradas, salidas, casos de error, cancelaciones y reintentos. Migraríamos un módulo a la vez detrás de un puente temporal, publicaríamos cada parte en una versión normal y tendríamos el módulo viejo listo para volver atrás. Los agentes leerían, redactarían y correrían las verificaciones. Una persona sería dueña de cada fusión.

Fallaría donde el comportamiento nunca quedó por escrito. Un compilador confirma que el código es válido, no que haga lo que hacía el código anterior, y las regresiones de este caso salieron justo de esos huecos. Reproduciríamos solicitudes de producción grabadas contra ambas versiones y compararíamos las respuestas.

La métrica que vigilaríamos sería las regresiones encontradas después de publicar por cada módulo migrado, junto al gasto en tokens por módulo. Después aplicaríamos el mismo método a reestructurar el propio código, el paso que GitHub dejó para más adelante.

Fuentes

De dónde salen los datos de esta nota.

  1. 01Github Migrates Copilot Runtime to Rust with AI-Assisted Rewrite - InfoQinfoq.com
  2. 02Microsoft agentically ports Copilot runtime to Rust for $120Ktheregister.com
  3. 03Migrating the GitHub Copilot runtime to Rust, using Copilot - The GitHub BlogLinkedIn iconInstagram iconYouTube iconX iconTikTok iconTwitch iconGitHub icongithub.blog

Usamos cookies

Recopilamos datos de uso anónimos para mejorar MOZGII y tu experiencia. No se recopilan datos sin tu permiso. Política de privacidad · Política de cookies