Programación en el espacio de pesos: cómo los LLM leen y editan los pesos de redes neuronales

La programación en el espacio de pesos es un método en el que un modelo de lenguaje grande (LLM) de propósito general lee los pesos en bruto de una red neuronal y los edita o escribe directamente a partir de un objetivo en lenguaje natural, sin descenso por gradiente ni bucle de entrenamiento. En una entrada de blog publicada el 2 de noviembre de 2026, cuatro investigadores de MIT CSAIL informan de que GPT-6 Astra ya puede hacerlo: editó el 0,016% de los pesos de Qwen3.5-0.8B y elevó la puntuación del modelo en MATH-500 del 7,9% al 48,1%.

Los autores son Rikiya Takehi, Jayden Teoh, Alex Zhang y Omar Khattab, primer autor del artículo original de DSPy. Los resultados son preliminares y provienen de un único LLM, pero el equipo publicó todos los prompts, respuestas y evaluaciones que los respaldan.

En este artículo, veremos qué es la programación en el espacio de pesos, qué mostraron los experimentos, dónde se atasca el método y qué implica para tu trabajo. Si necesitas un repaso del modelo que hace las ediciones, consulta nuestra guía de GPT-6 Astra.

¿Qué es la programación en el espacio de pesos?

La programación en el espacio de pesos consiste en pedir a un LLM que lea, corrija o escriba directamente los pesos de una red neuronal a partir de una especificación en lenguaje natural, a veces sin ningún feedback del entorno. El LLM deduce qué calcula cada parte de la red, o qué debería calcular, y ajusta los números en consecuencia.

Es un camino distinto al modo en que normalmente se obtienen los pesos. Hoy, los pesos surgen del descenso por gradiente con optimizadores como Adam o Muon, de redes entrenadas para generar los pesos de otras redes, o de compiladores que transforman programas formales en redes. En el planteamiento del MIT, GPT-6 Astra no escribe ningún bucle de entrenamiento. Razona sobre los pesos como una persona ingeniera razona sobre el código.

Los LLM ya optimizan prompts, programas y código de entrenamiento. El argumento de los autores es que esta optimización guiada por el razonamiento ahora alcanza a los propios pesos.

Lo que mostraron los investigadores del MIT

Los 8 experimentos se agrupan en tres bloques: leer pesos, corregirlos y escribirlos desde cero. La mayoría usa redes pequeñas cuyos pesos caben como texto en la ventana de contexto de Astra; en las más grandes se añade un sandbox de Python y, en algunos casos, un presupuesto de forward passes.

Leer los pesos de una red

El equipo entrenó cuatro políticas con proximal policy optimization (PPO), el algoritmo estándar de aprendizaje por refuerzo para agentes de juego, en versiones en cuadrícula de Breakout, Pong, Pac-Man y Freeway, todas con la misma arquitectura de 17.253 pesos. Sin proporcionarle la lista de juegos, Astra nombró el juego correcto para las 4 redes, leyendo pistas como que los pesos de la primera capa del agente de Breakout se situaban a lo largo de la fila inferior, donde está la pala.

Le siguieron dos versiones más difíciles:

• Modelos de difusión: A partir de los pesos de 3 pequeños DDPM, sin permitir ningún forward pass, Astra identificó cuál generaba círculos, cuadrados o triángulos. Los dibujó como contornos aunque los modelos producen formas rellenas, una señal de que leyó la geometría de los pesos en lugar de simular la red.
• Modelos de lenguaje: Dadas solo las 4 capas intermedias de transformadores de modelos de caracteres con 7,2 millones de parámetros, Astra nombró el idioma de entrenamiento (Python, japonés en romaji o inglés) en los 3 casos, y en ambos intentos. También encontró todas las copying heads, también llamadas induction heads, y no etiquetó ninguna otra cabeza como tal. Nuestra guía sobre atención multi-cabeza explica qué hacen esas cabezas.

Reparar una política defectuosa

Una política PPO entrenada durante 1.000 millones de pasos en un nivel de coche y rampa en el entorno Kinetix se lanzaba recto hacia la rampa y se quedaba atascada siempre. Con 171.664 pesos, la escena y un episodio grabado, Astra explicó el fallo y escribió una corrección en una sola respuesta y sin herramientas. La edición cambió el 3,5% de los pesos y llevó la tasa de éxito del 0% al 100% en 1.024 episodios.

La corrección es legible: una pequeña vía extra que hace retroceder el coche y se desactiva cuando el coche supera la franja.

Escribir redes desde cero

Para tres juegos de MinAtar, Astra recibió las reglas, el código fuente y una red con todos los pesos a cero, y luego escribió todos los pesos como texto en una sola respuesta, sin datos, gradientes ni herramientas. Las tres redes superaron a agentes PPO entrenados durante 100 millones de pasos.

Breakout es la excepción porque Astra lo escribió como si fuera un programa: la primera capa calcula dónde caerá la pelota, la segunda mueve la pala hasta allí. Una red de Go de 9x9 con 1.480.274 pesos, escrita en un sandbox de Python, superó a una red PPO del mismo tamaño entrenada en 20 millones de partidas cuando Astra dispuso de 50 forward passes para probar.

Corregir bucles de razonamiento en Qwen3.5-0.8B

El resultado más práctico ataca un fallo conocido. La model card de Qwen advierte que Qwen3.5-0.8B es propenso a los bucles de pensamiento y, en las pruebas del MIT, el 93,0% de sus respuestas en MATH-500 alcanzaban el límite de 32.768 tokens. Trabajando en un kernel de Python con 50 forward passes sobre problemas de práctica de GSM8K y MATH, Astra rastreó los bucles hasta una dirección escrita por los MLP de las capas 15 y 19 y la restó de 64 columnas de salida en cada una.

La proporción de respuestas que alcanzan el límite de tokens cayó al 33,1% y, como los bucles no son específicos de matemáticas, también mejoró el seguimiento de instrucciones. El presupuesto importó: con 10 o 25 forward passes los bucles apenas desaparecieron. Ahsen Khaliq, de Hugging Face, reconstruyó el checkpoint editado a partir de los registros y volvió a ejecutar MATH-500 con la misma configuración, obteniendo un 51,0%.

Dónde se queda corta la programación en el espacio de pesos

La programación en el espacio de pesos falla allí donde el problema no es un fallo único y localizado en los propios pesos. Los autores informan de dos fallos claros, y ambos son reveladores.

• La zalamería no era visible en los pesos. Dadas una fine-tune honesta y otra zalamera de Gemma 3 270M, Astra no pudo distinguirlas solo por los pesos en ninguno de sus cuatro intentos. Una vez pudo ver sus patrones de atención, identificó al modelo zalamero en los tres pares.
• Gemma 3 270M no mejoró en matemáticas. Gemma rara vez entra en bucles, así que no había un único fallo que eliminar, y la mejor edición de Astra movió MATH-500 del 6,8% al 7,7%. Como señalan los autores, editar pesos puede quitar un obstáculo que ocultaba una capacidad, pero no puede añadir una capacidad que el modelo no tiene.

Advertencias más amplias: cada experimento usa un solo LLM, la red más grande tiene 0,8 mil millones de pesos y se trata de una entrada de blog con resultados tempranos, no de un artículo revisado por pares. Los autores dicen que aún están construyendo un benchmark para la tarea.

Qué significa esto para profesionales de datos e IA

Para quienes trabajan en datos e IA, la programación en el espacio de pesos es hoy una señal de investigación, pero aún no una herramienta. Hay dos aspectos que conviene seguir de cerca.

El primero es la interpretabilidad. Métodos de atribución como SHAP explican un modelo a través de sus entradas, y la interpretabilidad mecanicista necesita herramientas específicas. Astra recuperó induction heads con un método conocido de multiplicación de matrices que las personas investigadoras no le mencionaron. Si eso se sostiene en modelos más grandes, "preguntar a un modelo puntero qué hace esta capa" puede convertirse en un primer paso antes del tooling pesado.

El segundo es la reparación dirigida. Cuando un modelo pequeño tiene un fallo acotado, como los bucles de Qwen, la corrección habitual es afinarlo (fine-tuning) con nuevos datos. Una edición de 131.072 pesos deja intacto el resto del modelo, lo que, según los autores, evita el olvido catastrófico que puede causar el fine-tuning. Yo lo trataría como una hipótesis: el resultado con Gemma muestra que la edición solo funciona cuando hay un único culpable que encontrar. La lista de deseos de los autores —desde auditar modelos en busca de puertas traseras sin ejecutarlos hasta desaprender capacidades sin datos— aún no se ha demostrado.

Cómo probar tú mismo la programación en el espacio de pesos

La forma más directa de probar la programación en el espacio de pesos es reproducir uno de los experimentos: los registros incluyen los prompts exactos que recibió Astra, y GPT-6 Astra está disponible como gpt-6-astra en la API de OpenAI, en Amazon Bedrock y en los planes de pago de ChatGPT. El Experimento 1, nombrar el juego a partir de los pesos de una política, es el mejor punto de partida:

1. Consigue los registros. Clona el repositorio lm_understand-logs. Cada carpeta de experimento tiene un README que mapea cada cifra del post con el archivo del que procede.

2. Elige un experimento sin herramientas. En los experimentos 1, 2, 4 y 5 no se dieron herramientas a Astra, así que un único prompt reproduce cada ejecución. En el Experimento 1, cada carpeta de ejecución contiene un prompt.txt con la descripción de la red, la pregunta y los 17.253 pesos como texto.

3. Envíalo como lo hicieron los autores. Llamaron a gpt-6-astra a través del CLI de Codex (codex exec, prompt por stdin) con todas las herramientas integradas desactivadas, y con alto esfuerzo de razonamiento para el Experimento 1. El resto de la configuración está en harness/codex_config.toml, pero sus valores por defecto son gpt-6-luna con esfuerzo medium, así que establece el modelo y el esfuerzo de razonamiento en cada llamada, como hicieron los autores.

4. Compara las respuestas. Cada carpeta de ejecución también contiene el answer.md de Astra, y eval/ contiene la puntuación y la plantilla de respuestas.

Una ejecución usó unos 73.700 tokens de entrada y menos de 2.000 de salida, así que, con precios de 10 $ y 50 $ por millón de tokens en la API, una repetición cuesta menos de 1 $. Los experimentos con sandbox de Python (3, 6, 7 y 8) requieren el harness/sandbox.py de los autores y muchas más iteraciones, así que planifica el presupuesto.

Si prefieres no ejecutar nada, el Qwen3.5-0.8B editado está en Hugging Face bajo Apache-2.0, con los hashes de los 2 tensores modificados en su model card. El Space de Hugging Face te permite escribir un problema y ver cómo el modelo base entra en bucle mientras el editado lo resuelve.

Reflexiones finales

La programación en el espacio de pesos muestra que un LLM puntero puede leer y editar pesos de redes neuronales razonando, al menos en redes pequeñas y fallos únicos y localizados. La corrección de Qwen es el resultado que llamará la atención, y la merece, en parte porque Hugging Face la reprodujo en un día.

Yo sería más cauto con las afirmaciones más ambiciosas. Un único modelo, redes pequeñas y ningún benchmark es una base débil para enmarcar que "nuestros pesos de redes neuronales pronto serán optimizados de forma nativa por LLM". Aun así, los fallos se reportan con el mismo cuidado que los aciertos, y eso me hace tomar más en serio los aciertos.

Si te interesa entender las tripas del transformador a las que apuntan estas ediciones, te recomiendo nuestro itinerario Developing Large Language Models.