Weight-space programming: hoe LLM’s netwerkgewichten lezen en bewerken
Met weight-space programming kan een LLM de gewichten van een netwerk lezen en bewerken zonder training. MIT’s GPT-6 Astra-experimenten, resultaten, beperkingen en wat ze betekenen.
Weight-space programming is een methode waarbij een generieke large language model (LLM) de ruwe gewichten van een neuraal netwerk leest en ze rechtstreeks bewerkt of schrijft op basis van een doel in gewone taal, zonder gradient descent en zonder traininglus. In een blogpost van 2 november 2026 melden vier MIT CSAIL-onderzoekers dat GPT-6 Astra dit nu al kan: het bewerkte 0,016% van de gewichten van Qwen3.5-0.8B en tilde de MATH-500-score van het model van 7,9% naar 48,1%.
De auteurs zijn Rikiya Takehi, Jayden Teoh, Alex Zhang en Omar Khattab, eerste auteur van het oorspronkelijke DSPy-artikel. De resultaten zijn vroeg en komen van één LLM, maar het team publiceerde elke prompt, respons en evaluatie erachter.
In dit artikel bespreek ik wat weight-space programming is, wat de experimenten lieten zien, waar de methode hapert en wat dit voor jouw werk betekent. Heb je een opfrisser nodig over het model dat de edits doet? Zie onze gids voor GPT-6 Astra.
Wat is weight-space programming?
Weight-space programming is de praktijk om een LLM een neuraal netwerk’s gewichten direct te laten lezen, repareren of schrijven rond een specificatie in natuurlijke taal, soms helemaal zonder feedback uit de omgeving. De LLM werkt uit wat elk deel van het netwerk berekent, of zou moeten berekenen, en stelt de getallen dienovereenkomstig in.
Dat is een andere route dan hoe gewichten normaal ontstaan. Vandaag komen gewichten voort uit gradient descent met optimizers zoals Adam of Muon, uit netwerken die zijn getraind om de gewichten van andere netwerken te genereren, of uit compilers die formele programma’s in netwerken omzetten. In de MIT-opzet schrijft GPT-6 Astra geen traininglus. Het redeneert over de gewichten zoals een engineer over code redeneert.
LLM’s optimaliseren al prompts, programma’s en trainingcode. Het argument van de auteurs is dat deze op redeneren gebaseerde optimalisatie nu de gewichten zelf bereikt.
Wat de MIT-onderzoekers lieten zien
De 8 experimenten vallen in drie groepen: gewichten lezen, ze repareren en ze vanaf nul schrijven. De meeste gebruiken kleine netwerken waarvan de gewichten als tekst in Astra’s contextvenster passen; de grotere voegen een Python-sandbox toe en sommige een budget aan forward passes.
De gewichten van een netwerk lezen
Het team trainde vier policies met proximal policy optimization (PPO), het standaard reinforcement learning-algoritme voor game-agents, op gridversies van Breakout, Pong, Pac-Man en Freeway, allemaal met dezelfde architectuur van 17.253 gewichten. Zonder de lijst met games te krijgen, noemde Astra het juiste spel voor alle 4 netwerken, door aanwijzingen te lezen zoals de eerste-laag-gewichten van de Breakout-agent langs de onderste rij, waar het batje is.
Er volgden twee moeilijkere varianten:
Diffusiemodellen: Uit de gewichten van 3 kleine DDPM’s, zonder forward pass toegestaan, identificeerde Astra welke cirkels, vierkanten of driehoeken genereert. Het tekende ze als contouren hoewel de modellen gevulde vormen produceren, een hint dat het de gewichtsgeometrie las in plaats van het netwerk te simuleren.
Taalmodellen: Alleen gegeven de 4 middelste transformerblokken van character-modellen met 7,2 miljoen parameters, noemde Astra de trainingstaal (Python, romaji-Japans of Engels) voor alle 3, in beide pogingen. Het vond ook elke copying head, ook wel induction head, en noemde geen andere head zo. Onze gids over multi-head attention legt uit wat die heads doen.
Een kapotte policy repareren
Een PPO-policy, getraind gedurende 1 miljard stappen op een auto-en-schakelbaanlevel in de Kinetix-omgeving, reed elke keer recht op de schans af en liep vast. Gegeven de 171.664 gewichten, de scène en één opgenomen episode, legde Astra de fout uit en schreef een fix in één antwoord zonder tools. De edit veranderde 3,5% van de gewichten en bracht het succespercentage van 0% naar 100% over 1.024 episodes.
De fix is leesbaar: een klein extra pad dat de auto laat terugrijden en uitschakelt zodra de auto de strook voorbij is.
Netwerken vanaf nul schrijven
Voor drie MinAtar-games kreeg Astra de regels, de broncode en een volledig nul-netwerk, en schreef vervolgens elk gewicht als tekst in één antwoord, zonder data, gradients of tools. Alle drie de netwerken versloegen PPO-agents die 100 miljoen stappen waren getraind.
Game
PPO, 100M stappen
PPO, 500M stappen
Astra, one shot
Breakout
15,8
25,3
517,4
Seaquest
5,6
88,9
53,1
Asterix
25,8
55,2
53,2
Breakout is de uitschieter omdat Astra het als een programma schreef: de eerste laag berekent waar de bal zal landen, de tweede beweegt het batje daarheen. Een 9x9 Go-netwerk met 1.480.274 gewichten, geschreven in een Python-sandbox, versloeg een even groot PPO-netwerk getraind op 20 miljoen partijen zodra Astra 50 forward passes had om tegen te testen.
Denkloops in Qwen3.5-0.8B repareren
Het meest praktische resultaat richt zich op een bekende fout. Qwen’s eigen modelkaart waarschuwt dat Qwen3.5-0.8B gevoelig is voor denkloops, en in de MIT-tests liep 93,0% van zijn MATH-500-antwoorden tegen de limiet van 32.768 tokens aan. Werkend in een Python-kernel met 50 forward passes op oefenproblemen uit GSM8K en MATH herleidde Astra de loops tot één richting die door de MLP’s van lagen 15 en 19 is geschreven en trok die af van 64 outputkolommen in elk.
Gewichten bewerkt
0,016%
131.072 van 0,8 miljard
MATH-500
7,9% → 48,1%
Basis vs. bewerkt
GSM8K
13,8% → 67,1%
Basis vs. bewerkt
IFEval
21,0% → 62,3%
Instructieopvolging
Het aandeel antwoorden dat de tokenlimiet raakte, daalde naar 33,1%, en omdat loops niet specifiek voor wiskunde zijn, verbeterde ook de instructieopvolging. Budget deed ertoe: met 10 of 25 forward passes verdwenen de loops nauwelijks. Ahsen Khaliq van Hugging Face bouwde de bewerkte checkpoint uit de logs opnieuw en draaide MATH-500 nogmaals met dezelfde instellingen, en haalde 51,0%.
Waar weight-space programming tekortschiet
Weight-space programming schiet tekort waar het probleem geen enkele, gelokaliseerde fout in de gewichten is. De auteurs melden twee duidelijke missers, en beide zijn leerzaam.
Sycophancy was onzichtbaar in de gewichten. Gegeven een eerlijke en een kruiperige fine-tune van Gemma 3 270M kon Astra ze in geen van zijn vier pogingen op basis van alleen de gewichten uit elkaar houden. Zodra het hun attentionpatronen kon zien, pikte het de kruiper eruit in alle drie de paren.
Gemma 3 270M werd niet beter in wiskunde. Gemma loopt zelden in rondjes, dus er was geen enkele fout om te verwijderen, en Astra’s beste edit verschoof MATH-500 van 6,8% naar 7,7%. Zoals de auteurs het stellen: het bewerken van gewichten kan een obstakel wegnemen dat een vaardigheid verborg, maar het kon geen vaardigheid toevoegen die het model miste.
De bredere kanttekeningen: elk experiment gebruikt één LLM, het grootste netwerk heeft 0,8 miljard gewichten, en dit is een blogpost met vroege resultaten, geen peer-reviewed paper. De auteurs zeggen dat ze nog werken aan een benchmark voor de taak.
Wat dit betekent voor data- en AI-practitioners
Voor practitioners is weight-space programming vandaag een onderzoekssignaal, maar nog geen tool. Twee onderdelen zijn nu al het volgen waard.
Het eerste is interpreteerbaarheid. Attributiemethoden zoals SHAP leggen een model uit via zijn inputs, en mechanistische interpreteerbaarheid heeft tools nodig die voor de taak zijn gebouwd. Astra herstelde induction heads met een bekende matrixvermenigvuldigingsmethode die de onderzoekers het nooit noemden. Als dat standhoudt op grotere modellen, wordt “vraag een frontiermodel wat deze laag doet” een eerste stap vóór het zware gereedschap.
Het tweede is gerichte reparatie. Wanneer een klein model één smalle fout heeft, zoals Qwen’s loops, is de gebruikelijke fix om het te fine-tunen op nieuwe data. Een edit van 131.072 gewichten laat de rest van het model onaangeroerd, wat volgens de auteurs de catastrofale vergeetachtigheid van fine-tuning kan vermijden. Ik zou dat als hypothese behandelen: het Gemma-resultaat laat zien dat de edit alleen werkt wanneer er één schuldige te vinden is. Het bredere wensenlijstje van de auteurs, van het auditen van modellen op backdoors zonder ze te draaien tot het afleren van capabilities zonder data, is nog niet aangetoond.
Hoe je zelf weight-space programming kunt proberen
De meest directe manier om weight-space programming te testen is één van de experimenten te reproduceren: de logs bevatten de exacte prompts die Astra ontving, en GPT-6 Astra is beschikbaar als gpt-6-astra in de OpenAI API, in Amazon Bedrock en in de betaalde plannen van ChatGPT. Experiment 1, het spel benoemen op basis van de gewichten van een policy, is de makkelijkste start:
Haal de logs op. Clone de lm_understand-logs-repository. Elke experimentmap heeft een README die elk getal in de post aan het bronbestand koppelt.
Kies een experiment zonder tools. Experimenten 1, 2, 4 en 5 gaven Astra geen tools, dus één enkele prompt reproduceert elke run. In Experiment 1 heeft elke runmap een prompt.txt met de netwerkbeschrijving, de vraag en alle 17.253 gewichten als tekst.
Stuur het zoals de auteurs deden. Zij riepen gpt-6-astra aan via de Codex CLI (codex exec, prompt op stdin) met elke ingebouwde tool uitgeschakeld, op hoge reasoning effort voor Experiment 1. De rest van de configuratie staat in harness/codex_config.toml, maar de defaults zijn gpt-6-luna op medium effort, dus stel het model en de reasoning effort per call in, zoals de auteurs deden.
Vergelijk de antwoorden. Elke runmap bevat ook Astra’s answer.md, en eval/ bevat de scoring en de answer key.
Een run gebruikte ongeveer 73.700 inputtokens en minder dan 2.000 outputtokens, dus bij de API-tarieven van $10 en $50 per miljoen tokens kost één replay minder dan $1. De Python-sandboxexperimenten (3, 6, 7 en 8) hebben de harness/sandbox.py van de auteurs en veel meer beurten nodig, dus budgetteer dienovereenkomstig.
Wil je liever niets draaien? De bewerkte Qwen3.5-0.8B staat op Hugging Face onder Apache-2.0, met de hashes van de 2 gewijzigde tensors op de modelkaart. De Hugging Face Space laat je een probleem typen en zien hoe het basismodel in rondjes loopt terwijl het bewerkte model het oplost.
Slotgedachten
Weight-space programming laat zien dat een frontier-LLM door te redeneren netwerkgewichten kan lezen en bewerken, in elk geval voor kleine netwerken en enkele, gelokaliseerde fouten. De Qwen-fix is het resultaat dat aandacht zal krijgen, en dat verdient het, mede omdat Hugging Face het binnen een dag reproduceerde.
Ik ben voorzichtiger met de grotere claims. Eén model, kleine netwerken en geen benchmark is een smalle basis voor de framing van de auteurs dat “onze neurale netwerkgewichten binnenkort native door LLM’s geoptimaliseerd zullen worden.” Toch zijn de missers net zo zorgvuldig gerapporteerd als de successen, en dat maakt dat ik de successen serieuzer neem.
Weight-space programming is een methode waarbij een generiek LLM de ruwe gewichten van een neuraal netwerk leest en ze rechtstreeks bewerkt of schrijft vanuit een doel in natuurlijke taal, zonder gradient descent of een traininglus. De term komt uit een blogpost van november 2026 door MIT CSAIL-onderzoekers Rikiya Takehi, Jayden Teoh, Alex Zhang en Omar Khattab, die het testten met GPT-6 Astra.
Kunnen LLM’s neurale netwerkgewichten direct bewerken?⌄
Ja, tenminste voor kleine netwerken. In de experimenten van MIT CSAIL bewerkte GPT-6 Astra 3,5% van de gewichten van een falende control policy om deze van 0% naar 100% succes te brengen, en bewerkte het 0,016% van de gewichten van Qwen3.5-0.8B om zijn denkloops terug te dringen, waarbij antwoorden die de tokenlimiet raakten daalden van 93% naar 33%. Het faalde wanneer er geen enkele fout was om te verwijderen, zoals bij de rekenfouten van Gemma 3 270M.
Hoe verbeterde GPT-6 Astra Qwen3.5-0.8B zonder training?⌄
Astra herleidde de denkloops van Qwen3.5-0.8B tot één richting die door de MLP’s van lagen 15 en 19 was geschreven, en trok die vervolgens af van 64 outputkolommen in elk, waarbij 131.072 gewichten werden gewijzigd. Met 50 forward passes op oefenproblemen steeg MATH-500 van 7,9% naar 48,1%, GSM8K van 13,8% naar 67,1%, en IFEval van 21,0% naar 62,3%.
Is weight-space programming een vervanging voor fine-tuning?⌄
Nog niet. Het werkte voor een enkele, gelokaliseerde fout zoals Qwen’s denkloops, maar het kon geen vaardigheden toevoegen die een model miste, en het is alleen getest met één LLM op netwerken tot 0,8 miljard gewichten. Voor nu blijft fine-tuning de praktische manier om het gedrag van een model te veranderen.
Kan ik zelf weight-space programming proberen?⌄
Je kunt de resultaten inspecteren en testen zonder toegang tot GPT-6 Astra. De onderzoekers publiceerden volledige experimentlogs op GitHub, de bewerkte Qwen3.5-0.8B staat op Hugging Face onder Apache-2.0, en een Hugging Face Space laat je het basis- en bewerkte model op je eigen problemen vergelijken.
Tom is Data Science Editor bij DataCamp. Hij schrijft en redigeert AI-tutorials, vergelijkt nieuwe LLM-releases en bouwt AI-gestuurde workflows. Eerder werkte hij in data science bij Deutsche Telekom. Buiten het werk voorspelt hij voetbalwedstrijden met machine learning.
Weight-space programming is een methode waarbij een generieke large language model (LLM) de ruwe gewichten van een neuraal netwerk leest en ze rechtstreeks bewerkt of schrijft op basis van een doel in gewone taal, zonder gradient descent en zonder traininglus. In een blogpost van 2 november 2026 melden vier MIT CSAIL-onderzoekers dat GPT-6 Astra dit nu al kan: het bewerkte 0,016% van de gewichten van Qwen3.5-0.8B en tilde de MATH-500-score van het model van 7,9% naar 48,1%.
De auteurs zijn Rikiya Takehi, Jayden Teoh, Alex Zhang en Omar Khattab, eerste auteur van het oorspronkelijke DSPy-artikel. De resultaten zijn vroeg en komen van één LLM, maar het team publiceerde elke prompt, respons en evaluatie erachter.
In dit artikel bespreek ik wat weight-space programming is, wat de experimenten lieten zien, waar de methode hapert en wat dit voor jouw werk betekent. Heb je een opfrisser nodig over het model dat de edits doet? Zie onze gids voor GPT-6 Astra.
Wat is weight-space programming?
Weight-space programming is de praktijk om een LLM een neuraal netwerk’s gewichten direct te laten lezen, repareren of schrijven rond een specificatie in natuurlijke taal, soms helemaal zonder feedback uit de omgeving. De LLM werkt uit wat elk deel van het netwerk berekent, of zou moeten berekenen, en stelt de getallen dienovereenkomstig in.
Dat is een andere route dan hoe gewichten normaal ontstaan. Vandaag komen gewichten voort uit gradient descent met optimizers zoals Adam of Muon, uit netwerken die zijn getraind om de gewichten van andere netwerken te genereren, of uit compilers die formele programma’s in netwerken omzetten. In de MIT-opzet schrijft GPT-6 Astra geen traininglus. Het redeneert over de gewichten zoals een engineer over code redeneert.
LLM’s optimaliseren al prompts, programma’s en trainingcode. Het argument van de auteurs is dat deze op redeneren gebaseerde optimalisatie nu de gewichten zelf bereikt.
Wat de MIT-onderzoekers lieten zien
De 8 experimenten vallen in drie groepen: gewichten lezen, ze repareren en ze vanaf nul schrijven. De meeste gebruiken kleine netwerken waarvan de gewichten als tekst in Astra’s contextvenster passen; de grotere voegen een Python-sandbox toe en sommige een budget aan forward passes.
De gewichten van een netwerk lezen
Het team trainde vier policies met proximal policy optimization (PPO), het standaard reinforcement learning-algoritme voor game-agents, op gridversies van Breakout, Pong, Pac-Man en Freeway, allemaal met dezelfde architectuur van 17.253 gewichten. Zonder de lijst met games te krijgen, noemde Astra het juiste spel voor alle 4 netwerken, door aanwijzingen te lezen zoals de eerste-laag-gewichten van de Breakout-agent langs de onderste rij, waar het batje is.
Er volgden twee moeilijkere varianten:
Een kapotte policy repareren
Een PPO-policy, getraind gedurende 1 miljard stappen op een auto-en-schakelbaanlevel in de Kinetix-omgeving, reed elke keer recht op de schans af en liep vast. Gegeven de 171.664 gewichten, de scène en één opgenomen episode, legde Astra de fout uit en schreef een fix in één antwoord zonder tools. De edit veranderde 3,5% van de gewichten en bracht het succespercentage van 0% naar 100% over 1.024 episodes.
De fix is leesbaar: een klein extra pad dat de auto laat terugrijden en uitschakelt zodra de auto de strook voorbij is.
Netwerken vanaf nul schrijven
Voor drie MinAtar-games kreeg Astra de regels, de broncode en een volledig nul-netwerk, en schreef vervolgens elk gewicht als tekst in één antwoord, zonder data, gradients of tools. Alle drie de netwerken versloegen PPO-agents die 100 miljoen stappen waren getraind.
Breakout is de uitschieter omdat Astra het als een programma schreef: de eerste laag berekent waar de bal zal landen, de tweede beweegt het batje daarheen. Een 9x9 Go-netwerk met 1.480.274 gewichten, geschreven in een Python-sandbox, versloeg een even groot PPO-netwerk getraind op 20 miljoen partijen zodra Astra 50 forward passes had om tegen te testen.
Denkloops in Qwen3.5-0.8B repareren
Het meest praktische resultaat richt zich op een bekende fout. Qwen’s eigen modelkaart waarschuwt dat Qwen3.5-0.8B gevoelig is voor denkloops, en in de MIT-tests liep 93,0% van zijn MATH-500-antwoorden tegen de limiet van 32.768 tokens aan. Werkend in een Python-kernel met 50 forward passes op oefenproblemen uit GSM8K en MATH herleidde Astra de loops tot één richting die door de MLP’s van lagen 15 en 19 is geschreven en trok die af van 64 outputkolommen in elk.
Het aandeel antwoorden dat de tokenlimiet raakte, daalde naar 33,1%, en omdat loops niet specifiek voor wiskunde zijn, verbeterde ook de instructieopvolging. Budget deed ertoe: met 10 of 25 forward passes verdwenen de loops nauwelijks. Ahsen Khaliq van Hugging Face bouwde de bewerkte checkpoint uit de logs opnieuw en draaide MATH-500 nogmaals met dezelfde instellingen, en haalde 51,0%.
Waar weight-space programming tekortschiet
Weight-space programming schiet tekort waar het probleem geen enkele, gelokaliseerde fout in de gewichten is. De auteurs melden twee duidelijke missers, en beide zijn leerzaam.
De bredere kanttekeningen: elk experiment gebruikt één LLM, het grootste netwerk heeft 0,8 miljard gewichten, en dit is een blogpost met vroege resultaten, geen peer-reviewed paper. De auteurs zeggen dat ze nog werken aan een benchmark voor de taak.
Wat dit betekent voor data- en AI-practitioners
Voor practitioners is weight-space programming vandaag een onderzoekssignaal, maar nog geen tool. Twee onderdelen zijn nu al het volgen waard.
Het eerste is interpreteerbaarheid. Attributiemethoden zoals SHAP leggen een model uit via zijn inputs, en mechanistische interpreteerbaarheid heeft tools nodig die voor de taak zijn gebouwd. Astra herstelde induction heads met een bekende matrixvermenigvuldigingsmethode die de onderzoekers het nooit noemden. Als dat standhoudt op grotere modellen, wordt “vraag een frontiermodel wat deze laag doet” een eerste stap vóór het zware gereedschap.
Het tweede is gerichte reparatie. Wanneer een klein model één smalle fout heeft, zoals Qwen’s loops, is de gebruikelijke fix om het te fine-tunen op nieuwe data. Een edit van 131.072 gewichten laat de rest van het model onaangeroerd, wat volgens de auteurs de catastrofale vergeetachtigheid van fine-tuning kan vermijden. Ik zou dat als hypothese behandelen: het Gemma-resultaat laat zien dat de edit alleen werkt wanneer er één schuldige te vinden is. Het bredere wensenlijstje van de auteurs, van het auditen van modellen op backdoors zonder ze te draaien tot het afleren van capabilities zonder data, is nog niet aangetoond.
Hoe je zelf weight-space programming kunt proberen
De meest directe manier om weight-space programming te testen is één van de experimenten te reproduceren: de logs bevatten de exacte prompts die Astra ontving, en GPT-6 Astra is beschikbaar als
gpt-6-astrain de OpenAI API, in Amazon Bedrock en in de betaalde plannen van ChatGPT. Experiment 1, het spel benoemen op basis van de gewichten van een policy, is de makkelijkste start:Haal de logs op. Clone de lm_understand-logs-repository. Elke experimentmap heeft een README die elk getal in de post aan het bronbestand koppelt.
Kies een experiment zonder tools. Experimenten 1, 2, 4 en 5 gaven Astra geen tools, dus één enkele prompt reproduceert elke run. In Experiment 1 heeft elke runmap een
prompt.txtmet de netwerkbeschrijving, de vraag en alle 17.253 gewichten als tekst.Stuur het zoals de auteurs deden. Zij riepen
gpt-6-astraaan via de Codex CLI (codex exec, prompt op stdin) met elke ingebouwde tool uitgeschakeld, op hoge reasoning effort voor Experiment 1. De rest van de configuratie staat inharness/codex_config.toml, maar de defaults zijngpt-6-lunaopmediumeffort, dus stel het model en de reasoning effort per call in, zoals de auteurs deden.Vergelijk de antwoorden. Elke runmap bevat ook Astra’s
answer.md, eneval/bevat de scoring en de answer key.Een run gebruikte ongeveer 73.700 inputtokens en minder dan 2.000 outputtokens, dus bij de API-tarieven van $10 en $50 per miljoen tokens kost één replay minder dan $1. De Python-sandboxexperimenten (3, 6, 7 en 8) hebben de
harness/sandbox.pyvan de auteurs en veel meer beurten nodig, dus budgetteer dienovereenkomstig.Wil je liever niets draaien? De bewerkte Qwen3.5-0.8B staat op Hugging Face onder Apache-2.0, met de hashes van de 2 gewijzigde tensors op de modelkaart. De Hugging Face Space laat je een probleem typen en zien hoe het basismodel in rondjes loopt terwijl het bewerkte model het oplost.
Slotgedachten
Weight-space programming laat zien dat een frontier-LLM door te redeneren netwerkgewichten kan lezen en bewerken, in elk geval voor kleine netwerken en enkele, gelokaliseerde fouten. De Qwen-fix is het resultaat dat aandacht zal krijgen, en dat verdient het, mede omdat Hugging Face het binnen een dag reproduceerde.
Ik ben voorzichtiger met de grotere claims. Eén model, kleine netwerken en geen benchmark is een smalle basis voor de framing van de auteurs dat “onze neurale netwerkgewichten binnenkort native door LLM’s geoptimaliseerd zullen worden.” Toch zijn de missers net zo zorgvuldig gerapporteerd als de successen, en dat maakt dat ik de successen serieuzer neem.
Ben je benieuwd naar de transformerinterna die de edits targetten? Dan raad ik onze track Developing Large Language Models aan.