Programação no espaço de pesos: como LLMs leem e editam pesos de redes neurais

Programação no espaço de pesos é um método em que um modelo de linguagem de uso geral (LLM) lê os pesos brutos de uma rede neural e os edita ou escreve diretamente a partir de um objetivo em linguagem natural, sem descenso de gradiente e sem loop de treinamento. Em um post publicado em 2 de novembro de 2026, quatro pesquisadores do MIT CSAIL relatam que o GPT-6 Astra já faz isso: ele editou 0,016% dos pesos do Qwen3.5-0.8B e elevou a pontuação do modelo no MATH-500 de 7,9% para 48,1%.

Os autores são Rikiya Takehi, Jayden Teoh, Alex Zhang e Omar Khattab, primeiro autor do paper original do DSPy. Os resultados ainda são iniciais e vêm de um único LLM, mas o time publicou todos os prompts, respostas e avaliações por trás deles.

Neste artigo, vou explicar o que é programação no espaço de pesos, o que os experimentos mostraram, onde o método falha e o que isso significa para o seu trabalho. Se você precisa relembrar o modelo que faz as edições, confira nosso guia do GPT-6 Astra.

O que é programação no espaço de pesos?

Programação no espaço de pesos é a prática de pedir a um LLM que leia, corrija ou escreva diretamente os pesos de uma rede neural, com base em uma especificação em linguagem natural, às vezes sem nenhum feedback do ambiente. O LLM deduz o que cada parte da rede computa, ou deveria computar, e define os números de acordo.

Isso é bem diferente da forma como os pesos são produzidos hoje. Atualmente, os pesos vêm de descenso de gradiente com otimizadores como Adam ou Muon, de redes treinadas para gerar pesos de outras redes, ou de compiladores que transformam programas formais em redes. Na configuração do MIT, o GPT-6 Astra não escreve nenhum loop de treinamento. Ele raciocina sobre os pesos como um engenheiro raciocina sobre código.

LLMs já otimizam prompts, programas e código de treinamento. O argumento dos autores é que essa otimização guiada por raciocínio agora chega aos próprios pesos.

O que os pesquisadores do MIT mostraram

Os 8 experimentos se dividem em três grupos: ler pesos, corrigí-los e escrevê-los do zero. A maioria usa redes pequenas cujos pesos cabem na janela de contexto do Astra como texto; as maiores adicionam um sandbox em Python e, em alguns casos, um orçamento de forward passes.

Lendo os pesos de uma rede

O time treinou quatro políticas com proximal policy optimization (PPO), o algoritmo padrão de aprendizado por reforço para agentes de jogos, em versões em grade de Breakout, Pong, Pac-Man e Freeway, todas com a mesma arquitetura de 17.253 pesos. Sem receber a lista de jogos, o Astra nomeou o jogo correto para todas as 4 redes, lendo pistas como os pesos da primeira camada do agente de Breakout alinhados na linha inferior, onde fica a barra.

Duas versões mais difíceis vieram em seguida:

• Modelos de difusão: a partir dos pesos de 3 DDPMs pequenos, sem permitir forward pass, o Astra identificou qual gera círculos, quadrados ou triângulos. Ele desenhou contornos embora os modelos produzam formas preenchidas, um indício de que leu a geometria dos pesos em vez de simular a rede.
• Modelos de linguagem: recebendo apenas os 4 blocos intermediários de transformers de modelos de caracteres com 7,2 milhões de parâmetros, o Astra nomeou o idioma de treinamento (Python, japonês em romaji ou inglês) nos 3 casos, em ambas as tentativas. Ele também encontrou todas as copying heads, também chamadas de induction heads, e não classificou nenhuma outra head como tal. Nosso guia sobre multi-head attention explica o que essas heads fazem.

Consertando uma política com falha

Uma política PPO treinada por 1 bilhão de passos em um nível de carro e rampa no ambiente Kinetix acelerava reto para a rampa e empacava sempre. Diante dos 171.664 pesos, da cena e de um episódio gravado, o Astra explicou a falha e escreveu uma correção em uma única resposta, sem ferramentas. A edição mudou 3,5% dos pesos e levou a taxa de sucesso de 0% para 100% ao longo de 1.024 episódios.

A correção é legível: um pequeno caminho extra que dá ré no carro e depois desliga assim que ele passa da faixa.

Escrevendo redes do zero

Para três jogos MinAtar, o Astra recebeu as regras, o código-fonte e uma rede zerada, então escreveu todos os pesos como texto em uma única resposta, sem dados, gradientes ou ferramentas. As três redes superaram agentes PPO treinados por 100 milhões de passos.

Breakout foge da curva porque o Astra o escreveu como um programa: a primeira camada calcula onde a bola vai cair, a segunda move a barra até lá. Uma rede de Go 9x9 com 1.480.274 pesos, escrita em um sandbox Python, superou uma rede PPO de mesmo tamanho treinada em 20 milhões de jogos quando o Astra teve 50 forward passes para testar.

Corrigindo ciclos de raciocínio no Qwen3.5-0.8B

O resultado mais prático mira uma falha conhecida. O model card do Qwen alerta que o Qwen3.5-0.8B é propenso a ciclos de pensamento e, nos testes do MIT, 93,0% das respostas no MATH-500 chegavam ao limite de 32.768 tokens. Trabalhando em um kernel Python com 50 forward passes em problemas de prática do GSM8K e do MATH, o Astra rastreou os ciclos até uma direção escrita pelos MLPs das camadas 15 e 19 e a subtraiu de 64 colunas de saída em cada uma.

A parcela de respostas que batiam no limite de tokens caiu para 33,1% e, como os loops não são específicos de matemática, o seguimento de instruções também melhorou. O orçamento importou: com 10 ou 25 forward passes, os loops mal diminuíram. Ahsen Khaliq, da Hugging Face, reconstruiu o checkpoint editado a partir dos logs e reexecutou o MATH-500 com as mesmas configurações, chegando a 51,0%.

Onde a programação no espaço de pesos falha

A programação no espaço de pesos falha sempre que o problema não é uma única falha localizada nos pesos. Os autores relatam duas falhas claras, e ambas são informativas.

• Bajulação foi invisível nos pesos. Diante de um fine-tune honesto e um bajulador do Gemma 3 270M, o Astra não conseguiu distingui-los apenas pelos pesos em nenhuma de suas quatro tentativas. Quando pôde ver os padrões de atenção, identificou o bajulador em todos os três pares.
• O Gemma 3 270M não ficou melhor em matemática. O Gemma raramente entra em loops, então não havia uma única falha a remover, e a melhor edição do Astra levou o MATH-500 de 6,8% para 7,7%. Como colocam os autores, editar pesos pode remover um obstáculo que escondia uma habilidade, mas não pode adicionar uma habilidade que o modelo não tinha.

Os alertas mais amplos: todo experimento usa um único LLM, a maior rede tem 0,8 bilhão de pesos, e isto é um post com resultados iniciais, não um artigo revisado por pares. Os autores dizem que ainda estão construindo um benchmark para a tarefa.

O que isso significa para profissionais de dados e IA

Para quem trabalha na prática, programação no espaço de pesos é hoje um sinal de pesquisa, mas ainda não uma ferramenta. Duas partes valem acompanhar desde já.

A primeira é a interpretabilidade. Métodos de atribuição como o SHAP explicam um modelo pelos seus insumos, e a interpretabilidade mecanicista precisa de ferramentas específicas. O Astra recuperou induction heads com um método conhecido de multiplicação de matrizes que os pesquisadores nem citaram a ele. Se isso se sustentar em modelos maiores, "perguntar a um modelo de ponta o que esta camada faz" vira um primeiro passo antes das ferramentas pesadas.

A segunda é a correção direcionada. Quando um modelo pequeno tem uma falha estreita, como os loops do Qwen, o conserto usual é fazer fine-tuning com novos dados. Uma edição de 131.072 pesos deixa o resto do modelo intocado, o que, segundo os autores, evita o esquecimento catastrófico que o fine-tuning pode causar. Eu trataria isso como hipótese: o resultado com o Gemma mostra que a edição só funciona quando há um único culpado a encontrar. A lista de desejos mais ampla dos autores — de auditar modelos por backdoors sem executá-los a desfazer capacidades sem dados — ainda não foi demonstrada.

Como testar programação no espaço de pesos por conta própria

A forma mais direta de testar programação no espaço de pesos é reproduzir um dos experimentos: os logs trazem os prompts exatos que o Astra recebeu, e o GPT-6 Astra está disponível como gpt-6-astra na OpenAI API, na Amazon Bedrock e nos planos pagos do ChatGPT. O Experimento 1, identificar o jogo a partir dos pesos de uma política, é o melhor ponto de partida:

1. Baixe os logs. Faça clone do repositório lm_understand-logs. Cada pasta de experimento tem um README que mapeia cada número do post para o arquivo de origem.

2. Escolha um experimento sem ferramentas. Os Experimentos 1, 2, 4 e 5 não deram ferramentas ao Astra, então um único prompt reproduz cada execução. No Experimento 1, cada pasta de execução tem um prompt.txt com a descrição da rede, a pergunta e todos os 17.253 pesos como texto.

3. Envie do mesmo jeito que os autores. Eles chamaram o gpt-6-astra via Codex CLI (codex exec, prompt no stdin) com todas as ferramentas internas desligadas, em alto esforço de raciocínio no Experimento 1. O restante da configuração está em harness/codex_config.toml, mas os padrões são gpt-6-luna em esforço medium, então defina o modelo e o esforço de raciocínio em cada chamada, como os autores fizeram.

4. Compare as respostas. Cada pasta de execução também traz o answer.md do Astra, e eval/ contém a pontuação e o gabarito.

Uma execução usou cerca de 73.700 tokens de entrada e menos de 2.000 tokens de saída, então, nas tarifas da API de US$ 10 e US$ 50 por milhão de tokens, uma reprodução sai por menos de US$ 1. Os experimentos com sandbox em Python (3, 6, 7 e 8) precisam do harness/sandbox.py dos autores e de muito mais interações, então ajuste o orçamento.

Se preferir não rodar nada, o Qwen3.5-0.8B editado está na Hugging Face sob Apache-2.0, com os hashes dos 2 tensores alterados no seu model card. O Space na Hugging Face permite digitar um problema e ver o modelo base entrar em loop enquanto o editado resolve.

Considerações finais

A programação no espaço de pesos mostra que um LLM de fronteira consegue ler e editar pesos de redes neurais por raciocínio, ao menos para redes pequenas e falhas localizadas e únicas. A correção no Qwen é o resultado que vai chamar atenção — com razão, em parte porque a Hugging Face a reproduziu em um dia.

Sou mais cauteloso com as afirmações mais amplas. Um único modelo, redes pequenas e nenhum benchmark formam uma base frágil para o enquadramento de que "nossos pesos de redes neurais em breve serão otimizados nativamente por LLMs". Ainda assim, as falhas são relatadas com o mesmo cuidado que os acertos, e isso me faz levar os acertos mais a sério.

Se você quer entender melhor os internos de transformers que essas edições miram, recomendo nossa trilha Developing Large Language Models.