GPT-6 Astra, le bistouri d’OpenAI qui répare les modèles d’IA sans les réentraîner

Data / IA

GPT-6 Astra, ce chirurgien des modèles IA capable de réparer directement leurs poids

Par Laurent Delattre, publié le 11 novembre 2026

Des chercheurs du MIT CSAIL ont demandé au modèle frontière d’OpenAI de faire ce que les humains savent difficilement faire : comprendre, corriger et réécrire les poids d’un réseau de neurones, sans le moindre réentraînement. Une capacité insoupçonnée des modèles frontières qui souffre encore d’importantes limites.

Un modèle d’IA ne se répare pas. Il se réentraîne. Ses poids, ces milliards de nombres qui déterminent son comportement, ne sont écrits par personne : ils sont ajustés automatiquement pendant l’entraînement, et personne ne peut facilement identifier lequel de ces nombres provoque une erreur, comme on repérerait une ligne de code défectueuse.

Quand un modèle déraille, les équipes relancent donc un entraînement, procèdent à un affinage (« fine-tuning ») au risque de dégrader d’autres compétences, ou contournent le défaut à coups de consignes système et de garde-fous.

Peut-on corriger un modèle sans le réentraîner ? Oui, mais jusqu’ici, c’était une affaire de spécialistes. Dès 2022, la méthode ROME a montré qu’on pouvait corriger une information mémorisée par une IA en retouchant une partie bien précise de ses poids. Avec l’« ablitération », on repère ce qui pousse le modèle à refuser certaines demandes, puis on efface ce signal pour lever ces refus.

Reste que tout ceci ne se faisait pas en discutant simplement avec un chatbot. Il fallait accéder aux poids du modèle, écrire des scripts en Python, utiliser des bibliothèques comme PyTorch et des outils capables d’observer les calculs réalisés dans ses différentes couches. Il fallait aussi des jeux de tests à n’en plus finir, au moins un GPU si ce n’est plusieurs et, surtout, une solide expertise des réseaux deep learning pour choisir quoi modifier sans perturber le reste.

C’est précisément cette barrière que l’expérience du MIT commence à bousculer : un modèle généraliste pourrait désormais effectuer lui-même une partie de ces manipulations.

Huit expériences, de la lecture à l’écriture

Tel est justement le propos de « Sparks of Weight-Space Programming », publié le 2 novembre par Rikiya Takehi, Jayden Teoh, Alex Zhang et Omar Khattab, chercheurs au MIT CSAIL. Il s’agit d’un billet de recherche exploratoire, accompagné des journaux d’exécution des expériences, et non d’un article scientifique évalué par des pairs.

Les auteurs y soumettent GPT-6 Astra, le modèle frontière d’OpenAI, à huit expériences, des plus simples aux plus ambitieuses.

Côté lecture, d’abord. Les chercheurs ont entraîné quatre petits réseaux à jouer chacun à un jeu vidéo rudimentaire : Breakout, Pong, Pac-Man et Freeway. Petite subtilité, les quatre sont bâtis exactement sur le même moule : mêmes entrées, mêmes actions possibles, mêmes dimensions. Impossible donc de deviner le jeu en regardant l’architecture, il faut vraiment lire les nombres.

Ils ont ensuite envoyé à Astra les 17 253 poids de chaque réseau, copiés tels quels en texte dans le prompt, sans le moindre outil et sans même lui communiquer la liste des jeux possibles. Surprise, le modèle a trouvé le bon jeu à tous les coups ! Son raisonnement sur Breakout est d’ailleurs assez amusant. Le modèle a d’abord constaté que les poids qui « regardent » le joueur se concentrent sur la rangée du bas de l’écran, donc qu’il y avait une raquette en bas. Puis il a remarqué que ceux qui guettent les récompenses se massent dans les rangées du haut, et donc qu’il y avait là des points à gagner donc des briques à casser. Enfin, il a noté que la couche des poids de sortie faisait nettement la différence entre « gauche » et « droite ». Son verdict : ce jeu ne peut être que Breakout, avec 99 % de confiance.

Même exercice avec des modèles de diffusion miniatures, ces générateurs d’images, entraînés l’un à dessiner des cercles, l’autre des carrés, le dernier des triangles. Là encore, Astra n’a droit qu’aux poids, soit 23 824 nombres. Sans aucun outil tiers et sans faire « tourner » le modèle, il a su repérer la forme dans la dernière couche du modèle, celle où chaque neurone trace en quelque sorte un petit bout du contour. Détail amusant, il redessine toujours des formes vides, de simples contours, alors que les modèles génèrent des formes pleines. Une erreur qui, aux yeux des auteurs, montre justement qu’Astra ne simule pas les calculs du réseau : il lit directement la géométrie inscrite dans les poids ! Surprenant.

Mais les chercheurs ne se sont pas arrêtés là. Ils ont cherché à corser davantage le challenge. Jusque-là, Astra pouvait se contenter de lire la première ou la dernière couche des modèles soumis, les plus faciles à interpréter. Mais dans un vrai modèle de langage, c’est dans les couches du milieu que tout se joue. Les chercheurs ont donc entraîné trois petits transformeurs de 7,2 millions de paramètres à deviner le caractère suivant d’un texte : le premier sur du code Python, le deuxième sur de l’anglais, le troisième sur du japonais écrit en alphabet latin (le romaji). Puis ils leur ont retiré la couche d’entrée et la couche de sortie. Plus rien n’indique alors quelle lettre est quoi, et le réseau ne peut même plus être exécuté. Astra a le droit d’analyser les poids avec Python, mais pas de faire tourner le modèle. Résultat : il nomme la bonne langue dans les trois cas, et à chacune de ses deux tentatives, même s’il ne s’en dit sûr qu’à 50 ou 60 % environ.

Alors, comment fait-il ? Pour Python, il part à la chasse aux « têtes de copie ». Ce sont de petits rouages du modèle qui servent à recopier un mot déjà vu : le texte commence par « tot », ils proposent « total » parce que le mot est apparu plus haut. Or le code, ça répète sans arrêt les mêmes noms de variables. Beaucoup de têtes de copie, donc sans doute du Python. Et il les trouve toutes, sans en signaler une seule à tort. Au passage, il applique tout seul une méthode publiée en 2021 par des chercheurs d’Anthropic, que personne ne lui avait soufflée. Pour le romaji, l’indice est plus discret : le réseau semble avoir moins de lettres à distinguer. Normal, le romaji n’utilise jamais le q, le l, le v ou le x.

Astra en réparateur de modèles

Après lui avoir fait lire les poids de plusieurs réseaux, les chercheurs sont ensuite logiquement passés à l’étape suivante : demander à Astra de les modifier directement pour réparer un modèle qui ne fonctionne pas comme prévu.

Le cobaye, cette fois, est un petit modèle qui pilote une voiture dans un simulateur physique. Son but : franchir une rampe. L’astuce, c’est qu’il faut d’abord reculer pour prendre de l’élan, puis foncer. Sauf que le réseau, entraîné par renforcement, n’a jamais compris la manœuvre. Conséquence : il s’évertue à foncer droit sur la rampe, perd rapidement sa vitesse et reste coincé… à chaque fois !
Les chercheurs ont donc donné à Astra les poids de ce modèle avec une description de la scène et l’enregistrement d’une partie ratée. Consigne : expliquer la panne, puis la réparer. Astra a rapidement « visualisé » le problème : le modèle ne cherche jamais à reculer. Il modifie alors une petite partie des poids pour créer un circuit parallèle, réparti sur plusieurs couches du réseau. Ce circuit utilise la position et la vitesse de la voiture pour la faire d’abord reculer, puis accélérer à fond. Une fois l’obstacle franchi, il cesse d’agir et laisse le réseau d’origine reprendre la main. Le tout en une seule réponse, sans outil, en touchant à peine 3,5 % des poids. Résultat : 1 024 réussites sur 1 024 essais, contre zéro avant.

Reste l’expérience la plus bluffante : écrire un réseau de A à Z ! Les chercheurs ont pris trois jeux d’arcade simplifiés : Breakout, Seaquest et Asterix. Ils ont donné à Astra les règles, le code source du jeu et un réseau vide, avec tous ses poids à zéro. En revanche, ils ne lui ont fourni ni données spécifiques, ni entraînement, ni outil, ni même le droit de tester en amont. Le modèle devait écrire tous les nombres lui-même, d’un seul jet. Et, surprise, ça marche ! À Breakout, son réseau marque 517,4 points en moyenne. Un réseau de même taille entraîné par renforcement pendant 500 millions d’étapes plafonne, lui, à 25,3 points. Vingt fois moins ! Le secret ? Astra raisonne comme un programmeur. Il décide d’abord ce que le réseau doit faire, puis il le traduit en poids : la première couche calcule où la balle va retomber, rebonds compris, et la deuxième amène la raquette au bon endroit. Basique mais efficace… sur Breakout spécifiquement. Car sur les deux autres jeux, le résultat est un peu moins parlant. Face au réseau spécialement entraîné sur 500 millions d’étapes, Astra fait presque jeu égal à Asterix mais il n’atteint que 60 % de son score à Seaquest.

Les chercheurs sont même allés jusqu’au jeu de go, avec un réseau de 1,5 million de paramètres, bien trop gros pour qu’Astra le lise d’un bloc. Il a cette fois fallu lui offrir un environnement Python pour lire et écrire les poids, mais toujours sans entraînement. Et le modèle d’OpenAI a construit le réseau comme un petit programme de go, couche par couche, en repérant les pierres et leurs libertés, en suivant les chaînes pour trouver les groupes en danger, puis en notant chaque coup possible (capturer, sauver un groupe, éviter de se mettre en atari…). Sans jouer une seule partie d’essai, son réseau gagne déjà plus de la moitié de ses matchs face à deux réseaux plus petits entraînés par renforcement. Et quand on l’autorise à faire des parties d’essai pour corriger le tir, il finit par battre un réseau de même taille entraîné sur 20 millions de parties.

Qwen dépanné en retouchant 0,016 % de ses poids

Tout ceci est très fun mais assez éloigné de l’univers des entreprises. Ce qui n’est pas le cas de la dernière expérience menée sur le modèle Qwen3.5-0.8B, un « petit » modèle ouvert d’Alibaba. Ce dernier souffre d’un défaut connu : lorsqu’il cherche à résoudre un exercice de maths, il se met souvent à tourner en rond et répète son raisonnement jusqu’à atteindre la limite de 32 768 tokens, sans jamais donner de réponse. Ainsi, sur le bench MATH-500, ce phénomène se produit dans 93 % des essais.

Alors les chercheurs ont eu l’idée de donner à Astra un accès aux poids de ce modèle Qwen en lui procurant non seulement un environnement Python mais également des exercices pour vérifier ses hypothèses. Astra disposait de 50 passes de vérification au maximum : à chaque passe, il pouvait faire résoudre à Qwen un lot de problèmes pour mesurer l’effet de ses modifications. En revanche, pas question de réentraîner le modèle. En fouillant dans les paramètres de Qwen, Astra repère dans les couches 15 et 19 un signal qui semble entretenir ces boucles. Il modifie les poids concernés pour le neutraliser, un peu comme on corrige un mauvais réflexe. Et il lui suffit de toucher à 131 072 paramètres sur 800 millions, soit seulement 0,016 % du modèle ! Les résultats changent nettement : sur MATH-500, le score passe de 7,9 à 48,1 %, et sur GSM8K de 13,8 à 67,1 %. La part des réponses qui atteignent la limite de tokens sans aboutir tombe de 93 à 33 %. En clair, Astra n’a pas appris de nouvelles mathématiques à Qwen. Il lui a surtout permis de mieux utiliser ce qu’il savait déjà faire. Le modèle corrigé est disponible sur Hugging Face, et il a même atteint 51 % sur MATH-500 lors d’un nouveau test.

Un bistouri à double tranchant

Que nous apprennent ces expérimentations ? D’abord que le comportement entier d’un modèle peut dépendre d’une poignée de paramètres, localisables et effaçables. Ceux qui planchent sur les réseaux ouverts et la fragilité de leurs garde-fous le savaient déjà, mais l’expérience du MIT le confirme différemment. Ensuite, elles nous révèlent que les modèles frontières sont aujourd’hui capables de manier les techniques de l’interprétabilité avec une aisance jusqu’ici réservée à une poignée de spécialistes. Enfin, elles nous alertent sur les risques liés à l’usage des modèles frontières pour altérer des modèles ouverts. Une altération de 0,016 % des paramètres ne se voit pas à l’œil nu, même sur les plus petits modèles : sans contrôle d’intégrité des poids, la chaîne d’approvisionnement des modèles hérite donc d’une fragilité de plus.

Un obstacle retiré, pas une compétence ajoutée

Faut-il dès lors céder à la panique ? Nullement. Car si ces expériences sont riches d’enseignements, les limites mises en avant par les chercheurs restent très nombreuses. Et ce qui fonctionne avec Qwen ne fonctionne pas forcément avec tous les modèles.

Ainsi, à partir des seuls poids, Astra n’a jamais su dire lequel de deux modèles Gemma 3 270M avait été entraîné à la complaisance : quatre échecs sur quatre tentatives. Il aura fallu que les chercheurs autorisent Astra à observer les mécanismes d’attention pour qu’il finisse par réussir le test.
Sur ce même Gemma, modifier les poids n’a presque rien changé aux résultats en maths. Et pour cause : contrairement à Qwen, ce modèle tourne rarement en rond. Ses erreurs viennent surtout de mauvais calculs ou de raisonnements faux, sans blocage précis à supprimer. Bref, retoucher les poids peut débloquer une capacité déjà présente, mais pas compenser une incapacité.

Même sur Qwen, la « réparation » ne s’est pas faite en un claquement de doigts. Il a fallu utiliser les 50 passes de vérification autorisées pour obtenir un vrai progrès : avec seulement 10 ou 25 passes, les boucles restaient presque aussi fréquentes.
Et après correction, une réponse sur trois atteint encore la limite de tokens sur MATH-500. Preuve que la réparation du modèle est encore imparfaite.

Enfin, il faut aussi remarquer que les chercheurs n’ont rien testé sur des modèles de plus d’un milliard de paramètres, et que les effets des manipulations réalisées par Astra sur d’autres usages restent à explorer.

Ce billet est d’ailleurs loin de faire l’unanimité. Dès le lendemain de sa publication, Matthew Honnibal, auteur de la bibliothèque spaCy et cofondateur d’Explosion, l’a jugé « extrêmement trompeur ». Selon lui, les chercheurs mélangent des techniques très différentes : la lecture des poids bruts, sans outil, ne concerne que trois des huit expériences, menées sur de tout petits réseaux, alors que la réparation de Qwen repose sur Python et sur 50 passes de vérification. Au fond, Astra ferait surtout ce qu’un ingénieur en apprentissage automatique saurait faire. Simon Willison, cocréateur du framework Django, a de son côté reproduit l’expérience Breakout sur son ordinateur portable avec un modèle Qwen exécuté en local. Un résultat « impressionnant », reconnaît-il, mais qu’un spécialiste armé d’un crayon et de beaucoup de patience pourrait sans doute atteindre.

Quoi qu’il en soit, ces expériences montrent que les modèles frontières ont désormais des capacités d’action sur les poids des modèles qu’on ne leur connaissait pas et peuvent manier une sorte de bistouri pour modèles qui pourrait à l’avenir éviter d’avoir à réentraîner des modèles pour les personnaliser… avec tous les risques qu’une telle perspective sous-entend !

Photo : LX Studio / CC 2.0

À LIRE AUSSI :