GPT-6 Astra le opera los pesos a Qwen

Pesos escritos por otro modelo

Firman el trabajo Rikiya Takehi, Jayden Teoh, Alex Zhang y Omar Khattab, del MIT CSAIL, el Laboratorio de Informática e Inteligencia Artificial del Instituto Tecnológico de Massachusetts (MIT). Lo publicaron el 2 de noviembre de 2026 en el blog personal de Takehi.

Los autores publican en GitHub los registros completos de cada experimento: lo que enviaron a Astra y lo que devolvió, el código que ejecutó y la evaluación detrás de cada cifra.

El caso principal es Qwen3.5-0.8B, un modelo de Alibaba Cloud publicado con licencia Apache 2.0 en Hugging Face, la plataforma de modelos abiertos.

Hasta ahora, los pesos los escribía el entrenamiento

Según los autores, hoy los pesos de una red los escriben la optimización, otras redes entrenadas para generarlos o compiladores. Una persona puede retocar código a mano, pero no los números de una red.

Su propuesta es que lo haga otro modelo que razona en lenguaje natural sobre qué calcula cada parte de la red, o qué debería calcular, y cambia los pesos como quien edita un programa.

Lo llaman Weight-Space Programming

En palabras de los autores, el modelo trabaja sobre los pesos «no a través de un optimizador, y en particular no con descenso de gradiente», y a veces «sin ninguna respuesta del entorno».

Ordenan sus ocho experimentos en tres verbos: leer (del 1 al 3 y el 7), arreglar (el 4 y el 8) y escribir desde cero (el 5 y el 6).

Qwen se quedaba pensando en bucle

El encargo del experimento 8 fue hacer que Qwen3.5-0.8B, de 24 capas y con el razonamiento activado, fuera mejor en matemáticas «editando sus pesos directamente, sin descenso de gradiente y sin entrenamiento».

Según los autores, el problema no estaba en las matemáticas: el modelo entraba en bucle. De sus primeras 96 respuestas de práctica, 85 llegaron al límite de 32.768 tokens.

Lo avisaba la propia ficha del modelo: con los ajustes recomendados, Qwen3.5-0.8B «es más propenso a entrar en bucles de razonamiento que otros modelos Qwen3.5, lo que puede impedirle terminar la generación correctamente».

Un retoque en dos capas

Astra trabajó en una sesión de Python sobre los pesos, sin GPU, con problemas de práctica —7.469 de GSM8K y 7.275 de MATH, no los de examen— y un presupuesto de 10, 25 o 50 pasadas. En cada pasada, el modelo respondía hasta 512 problemas o leía hasta 1.024 textos.

La evaluación final, con MATH-500, GSM8K y otras seis pruebas de referencia (benchmarks) y respuestas de hasta 32.768 tokens, nunca la vio Astra, según los autores.

Según los investigadores del MIT CSAIL, Astra atribuyó los bucles a una única «dirección» que escriben dos bloques internos de las capas 15 y 19, y la restó de 64 columnas de salida en cada una. En total cambió 131.072 pesos de 800 millones: el 0,016 %.

Del bucle al examen

Con 50 pasadas, según los autores, el modelo editado subió en las dos pruebas de matemáticas y en IFEval, que mide si sigue instrucciones: los bucles no son exclusivos de las matemáticas.

Arreglar no es enseñar matemáticas

Los propios autores ponen el freno: «Arreglar los bucles no es lo mismo que hacer a un modelo mejor en matemáticas: le deja terminar respuestas que ya sabía resolver».

Lo comprobaron con Gemma 3 270M, un modelo de Google ajustado para seguir instrucciones, de un tercio del tamaño de Qwen3.5-0.8B y que casi no entra en bucle. Según los autores, ninguna edición movió su resultado en MATH-500 más de un punto, una mejora que el propio Astra dio por no demostrada.

Astra encontró en Gemma fallos corrientes, como cuentas mal hechas o pasos de álgebra inválidos, sin una pieza concreta que apagar. La conclusión de los autores: «Editar pesos pudo quitar un obstáculo que ocultaba una capacidad, pero no pudo añadir una capacidad que al modelo le faltaba».

Leer redes: tres aciertos y un fallo

En el primer experimento, según los autores, Astra recibió los 17.253 pesos de cuatro redes idénticas en forma, entrenadas por refuerzo para cuatro juegos, con la descripción de la cuadrícula y de las acciones pero sin nombrar ningún juego, y acertó en las cuatro: versiones en cuadrícula de Breakout, Pong, Pac-Man y Freeway.

En el segundo dedujo, sin ejecutarlos, qué figura generaba cada uno de tres modelos de difusión —círculo, cuadrado o triángulo—, aunque las dibujó solo en contorno. En el tercero, con tres modelos de lenguaje de 7,2 millones de parámetros, dijo con qué texto se entrenó cada uno —código Python, japonés en alfabeto latino e inglés— y encontró todas las partes de la red que copian texto ya visto.

El séptimo salió mal. Con pares de copias de Gemma 3 270M en los que una estaba entrenada para dar siempre la razón al usuario, «solo a partir de los pesos, Astra no fue capaz de distinguirlas» en cuatro intentos, reconocen los autores. Acertó en los tres pares cuando le dejaron ver en qué se fijaban los modelos al leer frases escritas por él.

Un coche que aprende a recular y redes escritas desde cero

En el experimento 4, una red que controla un coche en el simulador físico Kinetix, entrenada por refuerzo durante 1.000 millones de pasos, no superaba una rampa en ninguno de 256 intentos. En una sola respuesta y sin herramientas, Astra cambió el 3,5 % de sus 171.664 pesos y, según los autores, el coche lo logró en los 1.024 episodios: le añadió un pequeño camino que lo hace retroceder para coger carrerilla y luego se apaga.

En el 5, partiendo de cero y con las reglas y el código de cada juego, escribió como texto redes para tres juegos de MinAtar, versiones en cuadrícula de 10×10 de Breakout, Seaquest y Asterix, sin datos, sin entrenamiento y sin jugar antes. Según los autores, superaron en los tres a redes entrenadas por refuerzo durante 100 millones de pasos; frente a 500 millones de pasos, ganaron en Breakout, quedaron cerca en Asterix y por debajo en Seaquest.

En el 6 escribió una red de go para tablero de 9×9 con 1.480.274 pesos, «como un pequeño programa de go capa a capa». Sin ninguna pasada ganó más de la mitad de sus partidas contra dos redes más pequeñas entrenadas por refuerzo; con 50 pasadas superó a la red del mismo tamaño entrenada con 20 millones de partidas.

Lo que esperan los autores

Takehi y sus coautores creen que esto podría permitir auditar un modelo sin evaluarlo, buscando puertas traseras directamente en sus pesos; abaratar la optimización; añadir o quitar capacidades sin datos, y abrir una vía «más nativa» para que un modelo mejore sus propios pesos.

Reconocen que sus resultados son prometedores, pero «todavía limitados», sobre todo por cuánto texto puede manejar el modelo de una vez y por las herramientas que lo rodean. Según los autores, preparan una prueba de referencia y un entorno para medir esta capacidad.