Qwen3.5-0.8B: una IA editó el 0,016 % de sus pesos, y los bucles de razonamiento bajaron del 93 % a cerca del 32 %

Otra IA cambió 64 columnas de números en cada uno de dos puntos de Qwen3.5-0.8B, un modelo de razonamiento abierto y pequeño, y lo hizo sin ningún entrenamiento. Ejecutamos el modelo editado y el original uno junto al otro en una RTX 4090 de nuestra nube, con los mismos 50 problemas de matemáticas y los mismos ajustes. El editado acertó el 62 %. El original, el 8 %, porque el 96 % de sus respuestas no terminaban nunca: seguía pensando en círculos hasta chocar con el límite de 32.768 tokens (trozos de palabras). Si sirves modelos de razonamiento pequeños en tus propias GPU, esto va tanto de coste como de precisión. Una respuesta que no termina ocupa una plaza en tu tarjeta hasta que el límite la corta, y casi nunca da una respuesta. El fichero editado se carga y se sirve con el mismo comando que el modelo base. Solo comprobamos matemáticas con el razonamiento activado.

La pregunta de la imagen es sencilla: ¿cuántos divisores tiene 196? La respuesta es 9. El modelo editado la encontró y se detuvo. El modelo base se puso a enumerar números por encima de 3.300, uno a uno, y seguía cuando el límite lo cortó.

Un modelo que no encuentra el final, y una edición que se lo da

La edición hace una sola cosa: quita la costumbre que hacía entrar al modelo en bucle. Las matemáticas que el modelo acierta ya estaban ahí.

Qwen3.5-0.8B es un miembro de la familia Qwen3.5 con unos 0.8B números aprendidos (los pesos). Antes de responder, un modelo de razonamiento escribe un borrador: piensa en voz alta y después da el resultado. La propia ficha del modelo de Qwen avisa de que este tamaño es "more prone to entering thinking loops" que sus hermanos. Imagina una banda que no encuentra el final de una canción. Todos siguen afinados, pero el cierre da vueltas y vueltas hasta que el técnico de sonido desenchufa. En una GPU, el técnico de sonido es el límite de tokens, y cada token que escribe el modelo ocupa tiempo de tarjeta.

El 2 de noviembre de 2026, un equipo del MIT CSAIL publicó un artículo en su blog sobre lo que llaman programación en el espacio de pesos. En uno de sus experimentos, un modelo grande al que llaman GPT-6 Astra recibe una herramienta para inspeccionar y cambiar los números del modelo pequeño. También recibe problemas de práctica, ninguno del test con el que se le evalúa. Su presupuesto es un número de ejecuciones de práctica del modelo pequeño: 10, 25 o 50. Astra observa lo que hace el modelo, lee sus entrañas y edita los números directamente. Sin entrenamiento de ningún tipo.

De las primeras 96 respuestas de práctica del modelo base, 85 llegaron al límite de 32.768 tokens. Con 50 ejecuciones, Astra encontró el patrón detrás de los bucles en dos puntos del modelo y lo borró de 64 columnas de números en cada uno. Son 131.072 pesos de todo el modelo: el 0,016 %. En MATH-500, un conjunto estándar de 500 problemas de matemáticas de competición, los autores dan un salto del 7,9 % al 48,1 % de aciertos. La proporción de respuestas cortadas en el límite bajó del 93 % al 33,1 %. Dan saltos parecidos en otros dos tests, que no repetimos (ver el apéndice).

Los autores publicaron el cambio exacto y un script que lo reconstruye. El usuario de Hugging Face akhaliq reconstruyó el fichero del modelo editado, lo volvió a ejecutar con los 500 problemas y montó una demo pública. Su repetición acertó el 51,0 %, con el 31,6 % de las respuestas cortadas en el límite. Vimos la noticia en el vídeo de noticias de AI Search del 8 de noviembre.

62 % de aciertos frente a 8 % en una RTX 4090, y los bucles bajan del 96 % al 20 %

Con los ajustes de evaluación de los autores, el fichero editado cortó la mayoría de sus bucles en nuestro hardware y acertó casi ocho veces más respuestas.

Los dos modelos funcionaron uno junto al otro en una sola RTX 4090 de 24 GB de nuestra nube, cada uno detrás de su propio endpoint de API. Los dos usaron vLLM, el motor de servicio de código abierto que usó la repetición de akhaliq, con el borrador de razonamiento activado y con los ajustes de aleatoriedad de los autores.

Las preguntas fueron los primeros 50 problemas de MATH-500 en el orden de la repetición de akhaliq, un intento por problema, hasta 32.768 tokens por respuesta. Los 50 se lanzaron a la vez para cada modelo, con los dos modelos al mismo tiempo. Los corregimos con el propio script de corrección de los autores.

Nuestro 62 % está por encima de las dos cifras publicadas. Eso es la muestra pequeña: en estos 50 problemas, la repetición de akhaliq dio una media del 54 %, y nuestras respuestas coincidieron con su resultado habitual en 42 de 50. El 8 % y el 96 % del modelo base caen justo en las cifras de los autores.

Las dos veces que el modelo base terminó una respuesta, acertó. Sus otras 2 respuestas correctas salieron de bucles que habían escrito el número correcto antes de que el límite los cortara.

El ahorro: 1,02 millones de tokens en lugar de 1,59 millones para los mismos 50 problemas

En los mismos 50 problemas, el modelo editado dio una media de 20.444 tokens por respuesta y el base de 31.832, y el 20 % de las respuestas editadas se cortaron en el límite frente al 96 %. Por respuesta correcta: unos 5 minutos de tiempo de lote frente a 32 segundos (398.000 tokens frente a 33.000). Esa diferencia se apoya en solo 4 respuestas correctas del base, así que tómala como aproximada.

Una GPU sirve un número fijo de respuestas a la vez. Con el modelo base, casi todas esas plazas estaban atascadas en un bucle, hasta 12,6 minutos en la pregunta de los divisores. El modelo editado sigue escribiendo respuestas largas, pero la mayoría terminan con un resultado.

¿Por qué no bajar sin más el límite, o vigilar el stream y parar un bucle, como sugiere la ficha de Qwen? Así un bucle falla antes y ahorra tiempo de tarjeta. No lo hemos probado, ni tampoco el razonamiento desactivado, con el modelo base, así que pruébalo antes de cambiar de fichero.

Dónde deja de funcionar: quita bucles, no añade capacidad

La edición corrigió una mala costumbre. No hizo más listo al modelo, y los propios autores lo dicen.

Probaron el mismo enfoque con Gemma 3 270M, un modelo que rara vez entra en bucle: solo el 8,5 % de sus respuestas llegaban al límite. Astra no pudo mejorarlo. Se quedó entre el 6,8 % y el 7,7 % en MATH-500 fuera cual fuera el presupuesto. En sus palabras: "Editing weights could remove an obstacle that hid an ability, but it could not add an ability the model lacked." Así que no esperes que funcione con un modelo cuyo problema no sean los bucles.

Incluso editado, una quinta parte de nuestras respuestas siguió en bucle, y otras 3 terminaron sin respuesta final. Las respuestas son largas, así que una sola respuesta tarda alrededor de un minuto ella sola. Y el salto solo llegó con el presupuesto más grande: con 10 o 25 ejecuciones, las ediciones de Astra dejaron al modelo en el 12,3 % y el 14,1 %.

El vídeo de AI Search también avisa contra el bombo, y menciona un análisis que al parecer llevó al modelo sin editar a cerca del 44 % en MATH-500 solo cambiando ajustes. El vídeo no cita la fuente, y no lo hemos comprobado.

Solo probamos matemáticas con el razonamiento activado. No comprobamos chat general, seguimiento de instrucciones, razonamiento desactivado ni imágenes con el fichero editado. La ficha de Qwen dice que el modelo de 0.8B funciona con el razonamiento desactivado por defecto.

Qué GPU: el modelo editado terminó con un tope de memoria emulado de 6 GB

Esta prueba muestra que el modelo arranca y termina respuestas largas con cada tope. Usamos cinco problemas que ya había resuelto en el lote, y dio las mismas cinco respuestas correctas con 6 GB que con 8 GB, en el mismo tiempo. Con 5 GB solo pasó después de recortar el espacio reservado para conversaciones en paralelo de 256 a 32. Con 4 GB no arrancó.

Todos los topes por debajo de 24 GB fueron un límite que pusimos en la 4090. No ejecutamos una tarjeta real de 6 u 8 GB. Una tarjeta pequeña real también tiene una memoria más lenta, así que cuenta con que vaya más despacio que esto. No probamos el tope de 4 GB con un límite de respuesta más corto, ni una versión comprimida del modelo.

En InferenceKey: el base y su gemelo editado en una tarjeta de 24 GB, listos en 7 minutos

Una tarjeta de 24 GB alojó a la vez el base y su gemelo editado, cada uno con menos de media tarjeta, con 16,9 GiB usados en el pico. Los dos estuvieron listos 418 segundos después de pedirlos, partiendo de una máquina en frío. Unos tres minutos se fueron en instalar vLLM, y otros tres más o menos en el calentamiento del propio motor. Con esa instalación ya en la máquina, un motor nuevo estaba listo en alrededor de un minuto.

Nuestra API todavía no puede cambiar algunos ajustes por petición, como el interruptor del razonamiento, así que los fijamos en el servidor para todos los que llaman.

Un problema con el que te vas a encontrar: una respuesta del modelo base recibida en streaming a través del endpoint se paró a los 152 segundos, sin ningún error que nuestro cliente pudiera ver y sin marca de final. Para un cliente, una respuesta cortada parece una terminada. Sospechamos del timeout de dos minutos de silencio de la plataforma, que enviaría un error que nuestro script de ejemplo ignora, pero la causa no está confirmada. Hasta entonces, comprueba que cada respuesta en streaming diga que terminó como es debido antes de fiarte de ella.

¿Deberías usarlo? Pruébalo si sirves Qwen3.5-0.8B con el razonamiento activado

• Si ya sirves Qwen3.5-0.8B con el razonamiento activado y le mandas matemáticas: prueba el cambio. Tiene el mismo tamaño y la misma licencia, y funciona con el mismo motor.
• Si quieres las mejores matemáticas de un modelo diminuto: tómalo como un arreglo, no como una mejora. Saca lo que el modelo ya sabía, y sigue escribiendo respuestas largas.
• Si estás dimensionando una GPU: el resultado de 6 GB se emuló en una tarjeta de 24 GB, no en una tarjeta real de 6 GB; mira la sección de memoria.
• Si ejecutas otro modelo pequeño que entra en bucle: esto es un método publicado con logs, no un producto. El resultado de Gemma dice que solo ayuda cuando el problema son los bucles.

Para ejecutar la misma comparación en tu propia máquina con GPU, usa el ejemplo del SDK de la edición de pesos de Qwen3.5-0.8B con IK_WITH_BASELINE=1. Necesita una máquina NVIDIA registrada (un worker) con una tarjeta de 24 GB y unos 15 GB de disco libre. Las claves de acceso y la compilación local del SDK están en el paso a paso de abajo. Borra los dos workloads al terminar.

vllm serve <model> --dtype bfloat16 --max-model-len 34816 \
  --gpu-memory-utilization 0.45 \
  --default-chat-template-kwargs '{"enable_thinking": true}' \
  --override-generation-config '{"temperature": 0.6, "top_p": 0.95, "top_k": 20, "presence_penalty": 1.5}'