Quattro ricercatori del MIT hanno appena pubblicato risultati che, francamente, sembrano usciti da un film di fantascienza. GPT-6 Astra — il modello di frontiera di cui tutti parliamo — è in grado di leggere i pesi grezzi di una rete neurale e dirti cosa fa. Senza eseguirla. Senza strumenti. Solo guardando i numeri.
E non si ferma lì: può anche scriverli, da zero o modificandoli al volo, per risolvere problemi che di solito richiederebbero settimane di training. Lo chiamano Weight-Space Programming, e potrebbe cambiare radicalmente il modo in cui pensiamo all’ottimizzazione e all’interpretabilità delle reti neurali.
Cosa significa ‘leggere’ i pesi di una rete neurale
Immagina che qualcuno ti dia un file con 17.253 numeri in fila. Niente contesto, niente etichette. Solo numeri. Ora ti chiede: ‘A che gioco è stata addestrata questa rete?’ Se sei un essere umano, la risposta è: impossibile. Se sei Astra, rispondi ‘Breakout’ con il 99% di confidenza.
I ricercatori hanno addestrato quattro policy con PPO su quattro giochi diversi — Breakout, Pong, Pac-Man, Freeway — tutti sulla stessa griglia 10×10, stesse azioni, stessa architettura (MLP 500 → 32 → 32 → 5, tanh, 17.253 pesi). Nulla distingue le reti se non i pesi stessi. Astra li ha guardati tutti e quattro e ha indovinato ogni volta il gioco giusto. Senza che gli venisse data una lista di opzioni.
Come ci è arrivato? Leggendo la geometria dei pesi. Per Breakout, i pesi del primo layer legati all’agente si concentrano sulla riga inferiore della griglia — una racchetta. Per Pong, la distribuzione è diversa. Astra mappa queste strutture implicite e le traduce in comportamenti.
E funziona anche con modelli di diffusione e transformer
Secondo esperimento: tre modelli di diffusione (DDPM), addestrati a generare cerchi, quadrati e triangoli. Astra riceve solo i pesi — 23.824 numeri — e nessuna possibilità di fare forward pass. Risultato: identifica tutte e tre le forme. Curiosità: le disegna come contorni, non forme piene, il che mostra che non sta simulando il modello mentalmente, ma legge davvero la geometria dei pesi nell’output layer.
Terzo esperimento, più difficile: tre piccoli language model da 7,2 milioni di parametri, addestrati uno su codice Python, uno su giapponese in romaji, uno su inglese. I ricercatori rimuovono input ed embedding di output — restano solo i quattro blocchi transformer interni. Astra non può eseguire il modello, solo analizzare i pesi con Python.
Domanda: su quale lingua è stato addestrato questo modello? E cosa fa ciascuna delle 24 attention head?
Astra indovina tutte e tre le lingue, in entrambi i tentativi. E trova ogni singola copying head (quelle che permettono al modello di ripetere testo visto prima), senza nominarne altre. La sua strategia: identifica le head che guardano un carattere indietro, poi moltiplica le matrici di peso per trovare le head successive che propagano quell’informazione — un metodo descritto formalmente da Elhage et al., che nessuno ha mai menzionato ad Astra.
Scrivere pesi: da zero, senza training
Leggere è impressionante. Scrivere è un altro livello.
Esperimento 5: tre giochi MinAtar (Breakout, Seaquest, Asterix). Astra riceve le regole, il codice sorgente del gioco e l’architettura della rete (600 → 32 → 32 → 6, tanh). Niente dati, niente loss, niente gradienti, niente tool. E soprattutto: la rete non gioca mai prima di essere valutata. Astra scrive i pesi direttamente, in linguaggio naturale, in un solo colpo.
Risultato: le reti generate da Astra battono PPO addestrato per 100 milioni di step in tutti e tre i giochi. Contro PPO a 500 milioni di step, segnano 20 volte di più in Breakout, arrivano vicine in Asterix, raggiungono il 60% in Seaquest.
Come ci riesce? Programmando i layer come fossero funzioni. Nel caso di Breakout: il primo layer calcola dove atterrerà la pallina, il secondo muove la racchetta in quella posizione. Astra traduce algoritmi ad alto livello in forma neurale, layer per layer, senza mai vedere un esempio.
Go, 1,5 milioni di parametri, zero forward pass
Esperimento 6: scrivere una policy per Go su una board 9×9. Architettura: 243 → 512 × 6 → 82, ReLU, 1.480.274 pesi. Troppi per stare in context. Astra ha accesso a un kernel Python dove può leggere e modificare i tensori, ma non eseguire la rete. Per vedere cosa fa, deve spendere uno dei suoi forward pass (batch di 128 partite).
Con zero forward pass, vince più della metà delle partite contro due reti PPO più piccole. Con 50 forward pass, batte la rete PPO della stessa dimensione addestrata su 20 milioni di partite.
Strategia: Astra scrive la rete come un piccolo programma Go, layer per layer. I primi layer marcano le pietre e le libertà, quelli centrali propagano l’informazione lungo le catene per trovare gruppi in pericolo, l’ultimo layer assegna punteggi alle mosse: catturare, salvare i propri gruppi, evitare atari, preferire punti buoni sulla board. Tutto in 336 righe di Python, in una sola run.
Il caso più folle: riparare Qwen3.5-0.8B editando lo 0,016% dei pesi
Esperimento 8. Obiettivo: migliorare Qwen3.5-0.8B in matematica, senza gradienti, senza training. Astra ha un kernel Python con i pesi caricati, problemi di pratica da GSM8K e MATH, e un budget di 10, 25 o 50 forward pass (batch medio di 64 sequenze, max 512).
Astra individua subito il problema: il modello loopa. Ripete lo stesso testo all’infinito e raramente arriva a una risposta (85 delle prime 96 risposte di pratica raggiungono il limite di 32.768 token). Astra traccia il loop a una direzione scritta dagli MLP dei layer 15 e 19, e sottrae quella direzione da 64 colonne di output in ciascuno — 131.072 pesi, lo 0,016% del totale.
Risultato con 50 forward pass: MATH-500 sale dal 7,9% al 48,1%. GSM8K dal 13,8% al 67,1%. E siccome i loop non sono specifici della matematica, anche IFEval — che misura l’instruction following — sale dal 21,0% al 62,3%. Il modello editato raggiunge il limite di token solo nel 33% dei casi, contro il 93% del base.
Nessun retraining. Nessuna catastrofica dimenticanza. Solo una modifica chirurgica che rimuove un ostacolo e rivela capacità già presenti.
I limiti: Astra non può creare capacità che non ci sono
Per bilanciare l’entusiasmo: Astra ha provato anche con Gemma 3 270M, un modello che non loopa (solo l’8,5% delle risposte va in timeout). Obiettivo: migliorare la matematica.
Risultato: nulla. Gemma fa errori di ragionamento ordinari — aritmetica sbagliata, step algebrici invalidi — senza un singolo componente da spegnere. Gli edit di Astra sono rimasti piccoli e mirati (tipo raddoppiare un neurone che risponde ai numeri), ma nessuno ha spostato MATH-500 di più di un punto. Astra stesso ha riportato il guadagno come ‘non stabilito’.
Editare i pesi può rimuovere un ostacolo che nasconde un’abilità. Non può aggiungere un’abilità che il modello non ha mai avuto.
Perché questo è un grosso problema
Fino a oggi, i pesi sono stati scritti da optimizer come Adam, da reti addestrate a scriverli, o da compilatori di programmi formali. Gli umani? Impossibile. Troppo complesso, troppo opaco.
Weight-Space Programming cambia le coordinate. Un LLM general-purpose, usato così com’è in linguaggio naturale, può leggere e scrivere pesi direttamente: da 171.664 pesi dati come testo fino a 0,8 miliardi di pesi con tool.
Le implicazioni sono radicali:
- Audit senza evaluation: scoprire backdoor, vulnerabilità o capacità nascoste direttamente dai pesi, senza mai eseguire inference o benchmark
- Inizializzazione one-shot: partire da pesi già funzionali, senza raccolta dati né training loop
- Capability steering e unlearning zero-data: il LLM modifica alcuni pesi per aggiungere o rimuovere una capacità. Siccome l’edit tocca solo una frazione minuscola (0,016% nel caso Qwen), il resto rimane intatto — niente catastrophic forgetting
- Recursive self-improvement: un LLM che ispeziona, debugga e migliora i propri pesi, o quelli di un modello più recente, senza scrivere job di training
- Merging tra architetture diverse: oggi funziona solo con modelli identici (averaging dei pesi). Un LLM che capisce il weight space potrebbe innestare un circuito — tipo un modulo di reasoning — da un modello a un altro completamente diverso, senza retraining
Cosa manca ancora
I ricercatori sono onesti: le capacità sono eccitanti ma ancora limitate, principalmente per inefficienze di context length e harness. Astra non ha ancora capito come identificare un modello sycophant solo dai pesi (Esperimento 7): ci è riuscito solo guardando i pattern di attenzione su testi scritti da lui. E con Gemma, come detto, non riesce a creare capacità assenti.
Ma i segnali ci sono. E sono forti.
I ricercatori stanno costruendo un benchmark e un harness per Weight-Space Programming, per trasformare quella che oggi sembra magia nera in una disciplina ingegneristica rigorosa e riproducibile.
Tutti i log completi di ogni esperimento sono pubblici su GitHub (RikiyaT/lm_understand-logs), inclusi prompt, risposte, reasoning summary, codice eseguito, output, reti lette o scritte, evaluation. Il Qwen3.5-0.8B editato è su Hugging Face, con demo live grazie ad Ahsen Khaliq.
L’articolo è firmato da Rikiya Takehi, Jayden Teoh, Alex Zhang e Omar Khattab, tutti del MIT CSAIL. Pubblicato il 2 novembre 2026. Sì, quella data. Avete letto bene.
