Un modelo de programación de casi 138.000 millones de parámetros en un PC
A principios de noviembre de 2026, Microsoft detalló MAI-Code-1.1-Flash, un modelo orientado a la programación que se ejecuta de forma local dentro de GitHub Copilot en un equipo con Windows. La noticia no está en que exista otro modelo de código, sino en dónde se ejecuta: un sistema de 137,9 mil millones de parámetros, con arquitectura de mezcla de expertos y unos 6,8 mil millones de parámetros activos por token, funciona sin depender de un centro de datos remoto para generar cada respuesta.
Para que esto sea posible, la compañía comprime el modelo desde unos 276 GB en precisión de 16 bits hasta un checkpoint de precisión mixta de 53 GiB, y existe además una variante más pequeña de 46,1 GiB. En un equipo con hardware NVIDIA RTX Spark y 128 GB de memoria unificada, Microsoft reporta una mediana de 51,12 tokens por segundo de salida con 120.000 tokens de contexto. El modelo ofrece un contexto local de 256K y está disponible a través de Microsoft Foundry.
La propia empresa acompaña los resultados con una advertencia importante: las cifras proceden de una sola configuración de hardware y software, y no deben extrapolarse a otros ordenadores. Este artículo repasa qué se anunció, qué significan los números, cómo encajan las técnicas utilizadas y qué implicaciones tiene para los equipos de desarrollo que hoy dependen de asistentes alojados en la nube.
Los datos confirmados, uno por uno
Conviene separar lo que se ha publicado de lo que es interpretación. Los datos que Microsoft ha dado a conocer son los siguientes.
- El modelo se llama MAI-Code-1.1-Flash y está pensado para tareas de programación.
- Tiene 137,9 mil millones de parámetros en total, organizados como mixture-of-experts.
- Se activan unos 6,8 mil millones de parámetros por token.
- En 16 bits ocupa aproximadamente 276 GB.
- Tras la compresión, el checkpoint de precisión mixta pesa 53 GiB, con una variante de 46,1 GiB.
- Se ejecuta dentro de GitHub Copilot, de manera local, en un PC con Windows.
- En hardware NVIDIA RTX Spark con 128 GB de memoria unificada, la mediana de salida es de 51,12 tokens por segundo con 120.000 tokens de contexto.
- Con decodificación especulativa mediante un modelo borrador, la velocidad sube desde 25,81 tokens por segundo.
- El contexto local es de 256K.
- Está disponible mediante Microsoft Foundry.
- Microsoft advierte de que los resultados son de una sola configuración y no deben generalizarse.
Todo lo que sigue se apoya en esas cifras. Cuando se haga un cálculo derivado, se indicará que es una estimación propia y no un dato publicado.
Qué es una mezcla de expertos y por qué importa aquí
Un modelo denso tradicional utiliza todos sus parámetros para procesar cada token. Si tiene 100.000 millones de parámetros, cada paso de generación recorre esos 100.000 millones. Una arquitectura de mezcla de expertos divide parte de la red en varios bloques especializados, llamados expertos, y un mecanismo de enrutamiento decide para cada token cuáles de ellos se activan. El resto permanece inactivo en ese paso.
En el caso de MAI-Code-1.1-Flash, la relación entre el total y lo activo es muy llamativa: 137,9 mil millones frente a 6,8 mil millones. Dicho de otro modo, por cada token solo participa alrededor del 5 % de los parámetros. Haciendo la cuenta, 6,8 dividido entre 137,9 da aproximadamente 0,049. Es un cálculo sencillo, pero explica por qué el modelo puede aspirar a velocidades razonables en un equipo de sobremesa o portátil de gama alta.
Esta diferencia entre capacidad y coste de cómputo es la razón de ser de la arquitectura. El modelo conserva una gran cantidad de conocimiento almacenado en sus pesos, porque todos los expertos deben estar disponibles, pero el trabajo aritmético por token se parece al de un modelo mucho más pequeño. El precio es la memoria: aunque solo se use una fracción en cada paso, todos los pesos tienen que residir en algún lugar al que se pueda acceder con rapidez, porque el siguiente token puede requerir expertos distintos.
Ahí entra el segundo ingrediente de la historia, la memoria unificada de 128 GB. Si el modelo debe caber entero en memoria, el tamaño del checkpoint pasa a ser la restricción dominante, y de ahí el esfuerzo de compresión.
De 276 GB a 53 GiB: la compresión como condición de partida
El primer paso para entender la cifra de 276 GB es una comprobación aritmética. Un parámetro en 16 bits ocupa dos bytes. Con 137,9 mil millones de parámetros, el resultado es de unos 275,8 mil millones de bytes, es decir, esos 276 GB que menciona Microsoft. No hay sorpresa ahí; es el tamaño natural del modelo en media precisión.
El checkpoint de 53 GiB es otra historia. Una gibibyte equivale a 1.073.741.824 bytes, algo más que un gigabyte decimal. Así, 53 GiB son cerca de 56,9 mil millones de bytes. Dividiendo esa cantidad entre los 137,9 mil millones de parámetros se obtiene algo más de 3,3 bits por parámetro de media. La variante de 46,1 GiB, por el mismo cálculo, queda en torno a 2,9 bits por parámetro. Son estimaciones propias a partir de las cifras publicadas, y el reparto real entre capas puede ser muy distinto.
Esas medias bajas son posibles gracias a la precisión mixta. En lugar de comprimir todo el modelo con el mismo número de bits, se asignan más bits a las partes sensibles y menos a las que toleran mejor la pérdida de precisión. En una mezcla de expertos, la inmensa mayoría de los parámetros viven en los bloques de expertos, de modo que son los candidatos naturales a una cuantización agresiva, mientras que componentes como la atención, las normalizaciones o el enrutador suelen conservarse con mayor fidelidad. Microsoft no ha detallado en las cifras citadas qué parte recibe qué precisión, así que lo anterior describe la práctica habitual de la técnica y no el esquema concreto de este modelo.
La reducción es sustancial: de 276 GB a 53 GiB supone pasar a menos de una quinta parte del tamaño original. La variante de 46,1 GiB ofrece margen adicional para quien necesite dejar más memoria libre para el contexto, para el sistema operativo o para otras aplicaciones.
El papel del hardware: RTX Spark y 128 GB de memoria unificada
Las mediciones se hicieron en hardware NVIDIA RTX Spark con 128 GB de memoria unificada. En una arquitectura de memoria unificada, el procesador central y el acelerador gráfico comparten el mismo conjunto de memoria física, en lugar de tener una memoria de sistema y otra de vídeo separadas. Para modelos de lenguaje grandes esto resulta decisivo, porque permite cargar pesos que no cabrían en la memoria de una tarjeta gráfica de consumo convencional sin tener que repartirlos entre dos dominios con un bus lento por medio.
Con un checkpoint de 53 GiB en un sistema de 128 GB, quedan aproximadamente 75 GB para todo lo demás. Parte de ese espacio se la lleva la caché de claves y valores, que crece con la longitud del contexto, y otra parte la necesita el sistema operativo, el editor y el resto de herramientas del desarrollador. Esa holgura es lo que hace viable un contexto largo como el de 120.000 tokens usado en la medición.
Un matiz que Microsoft subraya y que debe repetirse: estos resultados corresponden a una única configuración. Otro equipo con menos memoria, un ancho de banda distinto o controladores diferentes puede obtener cifras muy diferentes, y es probable que muchos portátiles y sobremesas actuales no puedan cargar siquiera el checkpoint de 53 GiB. Hablar de modelo local no significa que cualquier PC con Windows pueda ejecutarlo.
Qué significan los 51,12 tokens por segundo
La mediana de 51,12 tokens por segundo de salida con 120.000 tokens de contexto es la cifra que más titulares puede generar, y también la más fácil de malinterpretar. Una mediana indica que la mitad de las mediciones quedó por encima y la otra mitad por debajo, lo que es más robusto frente a picos aislados que una media, pero no informa de la dispersión ni del peor caso.
En términos prácticos, 51 tokens por segundo equivalen aproximadamente a una respuesta que se lee con comodidad en pantalla mientras se genera. Para un asistente de programación, donde las respuestas suelen incluir fragmentos de código y explicaciones de varias decenas o cientos de tokens, es una velocidad que se percibe como fluida. Lo relevante es que se obtiene con un contexto ya muy cargado, de 120.000 tokens, que es el escenario más exigente: a más contexto, más datos de atención que consultar en cada paso y, por tanto, menor velocidad.
Un cálculo orientativo ayuda a poner la cifra en perspectiva. Si cada token requiere leer los pesos activos, unos 6,8 mil millones de parámetros a algo más de 3 bits de media, hablamos de unos 2,8 GB de pesos por paso, sin contar la atención ni la caché. A 51 tokens por segundo, eso sugiere un tráfico de memoria del orden de 140 GB por segundo solo en pesos. Es una estimación propia, con muchas simplificaciones, pero muestra que el rendimiento está gobernado sobre todo por el ancho de banda de memoria y no solo por la potencia de cálculo, y que la cuantización no solo ahorra espacio sino también velocidad, porque hay menos bytes que mover por token.
Hay también una pregunta que las cifras por sí solas no responden: cómo se reparte el tiempo entre procesar la instrucción inicial y generar la respuesta. Con un contexto de 120.000 tokens, la fase de lectura del contexto puede tardar bastante, y la cifra de 51,12 se refiere a la salida. Quien evalúe esta tecnología debería mirar ambos tiempos, el de la primera respuesta y el de generación sostenida.
Decodificación especulativa con modelo borrador
Microsoft indica que, con decodificación especulativa mediante un modelo borrador, la velocidad sube desde 25,81 tokens por segundo. Para entender el sentido de esa frase hay que explicar la técnica.
La generación de texto con un modelo de lenguaje es secuencial: cada token depende de los anteriores, de modo que no se puede calcular el token número diez sin haber producido el nueve. Esto deja desaprovechada buena parte de la capacidad de cálculo, porque en cada paso el cuello de botella es leer los pesos de la memoria. La decodificación especulativa aprovecha esa capacidad ociosa con un truco: un modelo pequeño y rápido, el borrador, propone varios tokens seguidos, y el modelo grande los verifica todos en una sola pasada. Los tokens que el modelo grande habría elegido igualmente se aceptan de golpe, y desde el primero que difiere se corrige y se continúa.
El resultado, bien implementado, es idéntico en distribución al que produciría el modelo grande solo, pero obtenido en menos pasos costosos. La ganancia depende de la tasa de aceptación: cuanto más se parezcan las predicciones del borrador a las del modelo principal, más tokens se aceptan por pasada y mayor es la aceleración. En programación, donde hay mucho código repetitivo, sintaxis predecible y patrones estructurados, la tasa de aceptación suele ser favorable, lo que explica el interés de aplicar esta técnica a un asistente de código.
Conviene señalar una limitación de lo que se conoce. Del texto publicado se desprende que 25,81 tokens por segundo es el punto de partida y que el borrador mejora esa cifra, pero el detalle exacto de qué medición corresponde a cada configuración, qué modelo borrador se usa y con cuántos tokens por propuesta debe consultarse en la documentación técnica de Microsoft. Si ambas cifras se leen juntas, la velocidad se duplica aproximadamente, aunque esa relación es una lectura, no una afirmación de la compañía.
Un contexto local de 256K y lo que cuesta mantenerlo
El modelo admite un contexto local de 256K tokens, y la medición de velocidad se hizo con 120.000. Un contexto de ese tamaño permite, en la práctica, que el asistente tenga a la vista una parte considerable de un repositorio, varios archivos relevantes, el historial de la conversación y los resultados de herramientas, sin necesidad de recortar con tanta frecuencia.
El coste de un contexto largo no es solo de cálculo. La caché de claves y valores almacena, para cada token ya procesado, información que la atención necesita en pasos posteriores, y su tamaño crece de forma lineal con la longitud. En un equipo con memoria finita, cada token de contexto compite con los pesos del modelo por el mismo espacio. Por eso la combinación de un checkpoint comprimido y una memoria generosa es tan importante: sin ella, el contexto largo sería un dato de ficha técnica imposible de usar.
La mención de contexto local es también significativa. Sugiere que el límite puede ser distinto cuando el modelo se consume a través de un servicio alojado, y que el valor de 256K corresponde al escenario de ejecución en el propio equipo. Para el desarrollador, la consecuencia es sencilla: el tamaño máximo de contexto no es una propiedad abstracta del modelo, sino el resultado de lo que el hardware concreto puede sostener.
Dentro de GitHub Copilot, sin depender de la nube
Que el modelo funcione dentro de GitHub Copilot en un PC con Windows tiene una lectura práctica. El asistente más extendido en el ecosistema de Microsoft pasa a poder apoyarse en un motor que corre en la máquina del programador. Esto cambia varias ecuaciones a la vez.
La primera es la de la latencia de red. Un modelo local elimina el viaje de ida y vuelta a un servidor y las variaciones de una conexión inestable. La segunda es la de la disponibilidad: el asistente puede seguir funcionando con conectividad limitada. La tercera, y probablemente la más relevante para muchas organizaciones, es la de los datos. Si el código fuente no sale del equipo para ser procesado, desaparece una de las objeciones más frecuentes a los asistentes de programación en entornos con requisitos estrictos de confidencialidad.
Es un debate que ya ha tenido episodios muy visibles en el sector. La decisión de Goldman Sachs de retirar Claude Code y Copilot a traders y banqueros mostró hasta qué punto las entidades reguladas examinan con lupa qué herramientas de IA pueden usar sus empleados. Un modelo capaz de ejecutarse íntegramente en local no resuelve por sí solo las preocupaciones de cumplimiento normativo, que dependen también de la telemetría, de las extensiones y de la gobernanza interna, pero sí cambia el punto de partida de la conversación.
Microsoft Foundry y la forma de distribución
El modelo está disponible a través de Microsoft Foundry, la plataforma de la compañía para acceder a modelos de inteligencia artificial y desplegarlos. Esto indica que MAI-Code-1.1-Flash no es una pieza reservada a una función interna de Copilot, sino un recurso al que los desarrolladores y las organizaciones pueden llegar por un canal más general.
Para los equipos técnicos, la distinción importa. Una cosa es usar el modelo como parte de una funcionalidad ya integrada en el editor y otra es incorporarlo a flujos propios, con sus propios agentes, pruebas automatizadas o herramientas internas. La presencia en una plataforma de modelos abre esa segunda vía, aunque los detalles concretos de licencias, precios y condiciones de uso deben consultarse en la documentación oficial, porque no forman parte de los datos confirmados que sirven de base a este artículo.
El software que hace posible la inferencia local
Nada de esto ocurre sin un ecosistema de software de inferencia maduro. Ejecutar un modelo cuantizado de más de cien mil millones de parámetros requiere núcleos de cálculo optimizados, formatos de pesos eficientes, gestión cuidadosa de la memoria y, en este caso, soporte para mezcla de expertos y decodificación especulativa.
En ese terreno, los proyectos abiertos han sido durante años el laboratorio donde se perfeccionaron muchas de estas ideas. El hecho de que llama.cpp y GGML lleguen a la versión 1.0.0 con semver en su API de C es una señal de la madurez que ha alcanzado la inferencia local: lo que empezó como experimentos para correr modelos en portátiles se ha convertido en infraestructura sobre la que otros pueden construir con garantías de estabilidad. Microsoft no ha precisado en los datos citados qué motor concreto emplea MAI-Code-1.1-Flash, de modo que la comparación se limita al contexto del sector y no debe leerse como una relación entre ambos proyectos.
Lo que sí revela el conjunto es una tendencia: la distancia entre lo que se puede hacer en un centro de datos y lo que cabe en una estación de trabajo se acorta gracias a la cuantización, a las arquitecturas dispersas y a las técnicas de aceleración como la especulativa.
El panorama de los modelos abiertos y locales
La noticia de Microsoft aterriza en un momento de competencia intensa por los modelos que se pueden ejecutar fuera de la nube. Desde distintos laboratorios han aparecido pesos abiertos cada vez más grandes y capaces, y la comunidad ha respondido con herramientas de cuantización que los hacen utilizables en hardware accesible. Un ejemplo reciente es la apertura de pesos de Kimi K3.1 Pro por parte de Moonshot AI en Hugging Face, que alimenta el interés por modelos de gran tamaño que los usuarios puedan descargar y ejecutar bajo su control.
Hay diferencias que no deben pasarse por alto. En los datos publicados, MAI-Code-1.1-Flash se presenta como un modelo integrado en el producto de Microsoft y accesible mediante su plataforma, no como una publicación de pesos para descarga libre; cualquier afirmación sobre sus condiciones de licencia requeriría confirmación específica. Aun así, comparte con los modelos abiertos la idea central de que un modelo grande, comprimido con criterio, puede vivir en la máquina del usuario.
Para los desarrolladores, esta convergencia ofrece opciones. Pueden usar asistentes alojados para tareas donde la máxima capacidad importa más que la privacidad, y modelos locales para trabajo sensible, entornos aislados o situaciones en las que el coste por token de un servicio sería prohibitivo con un uso intensivo.
Qué cambia para un equipo de desarrollo
Aterrizando el análisis en el día a día, hay varios aspectos que un equipo debería sopesar antes de entusiasmarse o descartar la propuesta.
Primero, el coste. Un modelo local traslada el gasto desde un pago por uso hacia una inversión en hardware. Un equipo con 128 GB de memoria unificada no es un portátil corriente, de modo que la cuenta solo sale si el uso es intenso o si hay razones de confidencialidad que justifiquen la inversión. Para un equipo pequeño con presupuesto ajustado, seguir con servicios alojados puede ser más razonable.
Segundo, la calidad. Las cifras publicadas hablan de tamaño, memoria y velocidad, pero no de cuán buenos son los resultados en tareas reales de programación. Un modelo comprimido a unos 3 bits de media puede perder precisión respecto a su versión original, y la magnitud de esa pérdida solo se conoce con evaluaciones específicas. Antes de adoptar el modelo para tareas críticas, conviene medirlo con el propio código y las propias pruebas.
Tercero, la operación. Mantener un modelo local implica gestionar actualizaciones, versiones y compatibilidad con los controladores. En un parque de equipos heterogéneo, esa carga no es trivial, y es una razón por la que muchas organizaciones preferirán, al menos al principio, un despliegue centralizado en servidores propios.
Cuarto, la experiencia de uso. Un asistente que responde a 51 tokens por segundo con un contexto grande resulta cómodo, pero la percepción depende también del tiempo hasta el primer token y de la integración con el editor. Una buena integración en Copilot puede compensar limitaciones del modelo, y una integración deficiente puede arruinar un buen modelo.
Limitaciones y cautelas que conviene mantener
La advertencia de Microsoft no es una fórmula de cortesía, sino una precisión metodológica. Las cifras de rendimiento de modelos de lenguaje dependen de muchas variables: la versión del controlador, el motor de inferencia, la temperatura del equipo, el tamaño del lote, la longitud exacta del contexto, la naturaleza del texto generado y hasta el tipo de código que se pide. Un resultado medido en una combinación concreta no se traslada de manera lineal a otra.
Hay además tres puntos que los datos publicados no resuelven. El primero es la calidad comparada, ya mencionada: no se dispone aquí de resultados en pruebas de programación que permitan situar al modelo frente a otros. El segundo es la variabilidad: una mediana oculta cómo se comportan los percentiles más bajos, que son los que el usuario recuerda cuando el asistente se vuelve lento. El tercero es la generalización a hardware más modesto: la variante de 46,1 GiB mejora el panorama, pero sigue exigiendo una cantidad de memoria fuera del alcance de la mayoría de los equipos de consumo actuales.
Una lectura equilibrada de la noticia reconoce el avance técnico sin convertirlo en una promesa para todo el mundo. Es una demostración de viabilidad, con cifras sólidas en una configuración concreta, y no una garantía de rendimiento universal.
Lecciones técnicas de fondo
Más allá del anuncio, el caso ilustra varias ideas que los programadores harán bien en retener.
La primera es que el tamaño de un modelo ya no se describe con un solo número. Parámetros totales, parámetros activos, bits por parámetro y tamaño del contexto cuentan historias distintas, y confundirlos lleva a conclusiones erróneas. Un modelo de 137,9 mil millones de parámetros con 6,8 mil millones activos no se comporta como uno denso de 137,9 ni como uno de 6,8.
La segunda es que la memoria suele ser el recurso más escaso. Gran parte del ingenio actual en inferencia consiste en mover menos bytes: cuantizar, activar solo una parte de la red, comprimir la caché o verificar varios tokens por pasada. La decodificación especulativa es un ejemplo elegante de cómo convertir cálculo sobrante en velocidad.
La tercera es que la ejecución local y la ejecución en la nube no son bandos enfrentados, sino herramientas con perfiles distintos. La mejor arquitectura para un equipo puede combinar ambas, enrutando cada tarea según su sensibilidad, su dificultad y su coste.
Situación actual de la historia
A mediados de noviembre de 2026, MAI-Code-1.1-Flash ya está detallado públicamente por Microsoft y disponible a través de Microsoft Foundry, con ejecución local en GitHub Copilot sobre un PC con Windows. Las cifras de rendimiento conocidas proceden de una única configuración con hardware NVIDIA RTX Spark y 128 GB de memoria unificada, y la propia compañía pide no extrapolarlas.
Quedan por conocer, o al menos por contrastar de forma independiente, varios aspectos: la calidad del modelo en pruebas de programación ajenas a Microsoft, el comportamiento en otras configuraciones de hardware, los requisitos mínimos prácticos para usuarios corrientes y las condiciones comerciales de uso. Es previsible que desarrolladores y analistas publiquen mediciones propias en las próximas semanas, y esas pruebas serán las que determinen si la propuesta se queda como una demostración llamativa o se convierte en una opción habitual de trabajo.
Conclusiones
MAI-Code-1.1-Flash resume bien el momento que atraviesa la inteligencia artificial aplicada al desarrollo de software. Un modelo de 137,9 mil millones de parámetros, comprimido de 276 GB a un checkpoint de 53 GiB, funciona dentro de GitHub Copilot en un PC con Windows y alcanza una mediana de 51,12 tokens por segundo con 120.000 tokens de contexto, con una variante aún más compacta de 46,1 GiB.
Las claves técnicas son conocidas pero están bien combinadas: una mezcla de expertos que activa solo unos 6,8 mil millones de parámetros por token, una cuantización de precisión mixta que reduce de forma drástica el tamaño, memoria unificada suficiente para alojar pesos y caché, y decodificación especulativa para acelerar la generación. Ninguna de esas piezas es nueva por separado; la novedad está en su integración en un producto que los programadores ya usan.
Al mismo tiempo, la prudencia es obligada. Las cifras corresponden a una sola configuración, no hay en los datos citados una evaluación independiente de la calidad del código generado y el hardware descrito está lejos de ser el equipo medio. La advertencia de Microsoft contra la generalización es, en ese sentido, la frase más importante del anuncio.
Para los equipos de desarrollo, la recomendación práctica es seguir el asunto con interés y medir antes de decidir. Si las pruebas independientes confirman que la calidad compensa la compresión, la ejecución local de modelos de programación grandes pasará de curiosidad a alternativa real frente a los servicios alojados, especialmente donde la privacidad del código sea un requisito y no una preferencia.
