Shopping cart

Subtotal $0.00

View cartCheckout

Building better devs

TnewsTnews
  • Home
  • IA
  • Self-Rewriting: a IA que Reprograma o Próprio Cérebro
IA

Self-Rewriting: a IA que Reprograma o Próprio Cérebro

Email : 3

Imagine uma IA que encontra um bug nos próprios neurônios e corrige sozinha

Você treina um modelo por semanas, gasta milhares de dólares em GPU, e no final ele erra respostas que deveria acertar. O que você faz? Treina de novo. Ajusta hiperparâmetros. Roda mais dados. Repete o ciclo inteiro.

E se o próprio modelo pudesse olhar para dentro de si, identificar o que está errado e consertar? Sem gradient descent, sem backpropagation, sem um único passo de treinamento adicional.

Parece ficção científica, mas pesquisadores acabam de demonstrar exatamente isso. Um modelo de 27 bilhões de parâmetros, o Qwen 3.5, recebeu acesso aos seus próprios pesos e conseguiu se tornar mais inteligente sozinho. A técnica se chama Self-Rewriting, e ela muda o que sabíamos sobre os limites entre treino e inferência.

O que é Self-Rewriting e por que importa

Self-Rewriting é o nome dado ao processo em que um modelo de linguagem analisa seus próprios parâmetros internos, diagnostica falhas de desempenho e modifica seus pesos diretamente, tudo usando apenas forward passes (inferência). Nada de calcular gradientes. Nada de backpropagation.

O paper Language Models Can Rewrite Their Own Weights, publicado em novembro de 2026, é assinado por Jiajun Fan, Neil He, Changyi Yang e outros pesquisadores. Eles deram ao modelo três coisas:

  • Acesso de leitura e escrita aos seus próprios pesos
  • Um ambiente Python para executar código
  • Exemplos de problemas que ele acertou e errou

Com isso, o modelo funcionou como seu próprio otimizador. Ele investigou por que falhava em certos problemas, propôs mudanças nos pesos e testou se as mudanças realmente ajudavam.

O resultado? Um ganho de 6.6 pontos de acurácia em problemas matemáticos nunca vistos antes.

Como funciona, passo a passo

O processo de Self-Rewriting segue uma lógica que qualquer dev que já debugou código reconhece:

1. Diagnóstico: O modelo compara seus hidden states (representações internas) em problemas que acertou versus problemas que errou. Ele analisa camada por camada, procurando padrões que expliquem as falhas.

2. Hipótese: Com base na análise, o modelo formula uma teoria sobre o que está errado. Em um dos casos mais interessantes do paper, ele descobriu que “sabia” a resposta correta nas camadas intermediárias, mas continuava gerando tokens até estourar o limite de contexto. O modelo literalmente se perdia em seu próprio raciocínio.

3. Modificação: O modelo propõe alterações específicas nos pesos. No caso acima, ele ajustou um parâmetro de timing nas camadas de linear-attention, fazendo com que parasse de gerar texto desnecessário antes de atingir o limite computacional.

4. Validação: Antes de aceitar qualquer mudança, o modelo roda a versão modificada e a original contra os mesmos problemas. Só mantém alterações que provaram melhorar o desempenho.

5. Rejeição seletiva: Se uma mudança piora os resultados, ela é descartada. Das oito sessões de Self-Rewriting realizadas, cinco não produziram modificações aceitas. Das três aceitas, duas geraram melhorias reais.

Métrica Antes Depois Delta
——— ——- ——– ——-
Acurácia (490 problemas matemáticos) 57.2% 63.8% +6.6 pts
Respostas truncadas por limite de tokens Alta Reduzida significativamente –
Reparo de modelo corrompido (tarefas de imagem) 7.3% 70.2% +62.9 pts

Esse último número é absurdo. O modelo recebeu uma versão deliberadamente corrompida de si mesmo e conseguiu reparar a acurácia de 7.3% para 70.2%, algo como 83% do desempenho original. Em tarefas de imagem que ele nunca tinha visto nesse contexto.

O modelo que sabia a resposta, mas não conseguia parar de falar

Essa foi a descoberta mais fascinante do paper, e vale explicar com mais calma.

Quando os pesquisadores analisaram os casos de falha, encontraram um padrão curioso: em muitos problemas matemáticos, o modelo já tinha a resposta correta armazenada em suas representações intermediárias. As camadas do meio processavam tudo certo. O “pensamento” estava lá.

O problema? O modelo não sabia quando parar. Ele continuava gerando raciocínio adicional, expandindo e reexpandindo a resposta, até estourar o limite de tokens e ser forçado a parar no meio da solução. É como um desenvolvedor que sabe a solução, mas não consegue parar de refatorar.

Quando o modelo de 27B recebeu permissão para investigar esse comportamento nos próprios pesos, ele identificou exatamente quais parâmetros controlavam esse “impulso de continuar falando” e os ajustou. O resultado foi uma redução drástica nas respostas truncadas.

Eu já vi sêniors em code review fazendo exatamente isso: identificando o ponto exato onde a lógica descarrilha. A diferença é que aqui quem fez o diagnóstico foi o próprio sistema que tinha o bug.

Tamanho importa (e muito)

Uma das descobertas mais relevantes do paper é que Self-Rewriting não funciona para qualquer modelo. Os pesquisadores testaram com modelos de diferentes tamanhos:

Modelo Parâmetros Resultado
——– ———– ———–
Qwen 3.5 (pequeno) 2B Nenhuma modificação útil
Qwen 3.5 (médio) 4B Degradou o desempenho
Qwen 3.5 (intermediário) 9B Degradou o desempenho
Qwen 3.5 (grande) 27B +6.6 pontos de acurácia

Os modelos menores fizeram modificações aleatórias nos pesos. Sem a capacidade de raciocínio sofisticada que emerge em modelos maiores, as mudanças propostas eram essencialmente ruído. O modelo de 4B, por exemplo, piorou consistentemente ao tentar se auto-editar.

Isso sugere que a capacidade de Self-Rewriting é uma propriedade emergente de escala. O modelo precisa ser inteligente o suficiente para entender sua própria arquitetura antes de poder melhorá-la. É uma espécie de metacognição computacional: pensar sobre o próprio pensamento exige um nível mínimo de sofisticação.

Self-Rewriting vs. treinamento tradicional

Para deixar claro o que muda aqui, vale comparar os dois paradigmas:

Aspecto Treinamento tradicional Self-Rewriting
——— ———————— —————-
Método de otimização Gradient descent / backpropagation Forward passes (inferência pura)
Dados necessários Datasets grandes e curados Poucos exemplos de acerto/erro
Custo computacional Alto (GPUs por dias/semanas) Baixo (algumas sessões de inferência)
Quem decide as mudanças Algoritmo de otimização O próprio modelo
Interpretabilidade Baixa (mudanças distribuídas) Alta (modelo explica o que mudou)
Maturidade Décadas de pesquisa Paper publicado em novembro de 2026

A vantagem mais interessante talvez seja a interpretabilidade. Quando você treina um modelo com backpropagation, milhões de pesos mudam simultaneamente de formas que ninguém consegue explicar. Com Self-Rewriting, o modelo literalmente descreve qual parâmetro ele mudou e por quê.

Isso é enorme para debugging. Imagine poder perguntar ao modelo “por que você está errando nesse tipo de problema?” e receber uma resposta técnica, precisa, acompanhada de uma correção que você pode verificar.

SEAL: o trabalho do MIT que pavimentou o caminho

Self-Rewriting não surgiu do nada. Em abril de 2026, pesquisadores do MIT Improbable AI Lab publicaram o SEAL (Self-Adapting LLMs), um framework que permite modelos de linguagem modificar seus próprios pesos em resposta a novas informações.

A diferença entre SEAL e Self-Rewriting é sutil, mas importante. SEAL foca em adaptação contínua: o modelo absorve novos dados e atualiza seus pesos para incorporar esse conhecimento sem retreinamento completo. Self-Rewriting foca em auto-reparo: o modelo identifica falhas específicas e as corrige cirurgicamente.

Antes disso, o paper “Sparks of Weight-Space Programming” já tinha mostrado que modelos maiores podiam editar os pesos de modelos menores. O salto conceitual do Self-Rewriting é que o modelo edita a si mesmo.

As implicações para quem trabalha com IA

Se Self-Rewriting escalar (e esse é um “se” grande), as implicações práticas são profundas:

Para MLOps e infraestrutura: Modelos em produção que degradam com o tempo poderiam se auto-corrigir. Aquele drift de modelo que hoje exige retreinamento periódico? O modelo identificaria o problema e ajustaria os pesos relevantes. Redução brutal em custos de GPU e tempo de engenharia.

Para fine-tuning: Precisar de um modelo especializado em um domínio específico? Em vez de coletar datasets e rodar fine-tuning por horas, você mostraria alguns exemplos de acerto e erro e deixaria o modelo se ajustar. O paper já demonstrou isso com 490 problemas como referência.

Para AI safety: Aqui a coisa complica. Um modelo que pode modificar seus próprios pesos é, por definição, menos previsível. Se ele pode se melhorar, pode também se modificar de formas não intencionais. Os pesquisadores abordaram isso com o mecanismo de validação (testar antes de aplicar), mas em um cenário de produção, garantir que nenhuma auto-modificação introduza comportamentos indesejados é um desafio sério.

Para o debate sobre AGI: Self-Rewriting é o tipo de capacidade que alimenta a discussão sobre auto-melhoria recursiva, onde um sistema melhora a si mesmo, o que o torna melhor em se melhorar, criando um ciclo de melhoria acelerada. O paper é honesto ao dizer que ainda não demonstrou isso (cada sessão partia dos pesos originais, não dos melhorados), mas o mecanismo base existe.

O que NÃO é Self-Rewriting

Vale esclarecer o que esse paper não provou, porque o hype em cima de pesquisa de IA tende a distorcer as coisas:

Não é auto-melhoria recursiva. Cada sessão de Self-Rewriting partiu dos pesos originais do modelo. Eles não testaram melhorias cumulativas. Não houve um ciclo de “melhora sobre a melhora”.

Não é generalização ampla. Os testes foram feitos principalmente com problemas matemáticos e tarefas de imagem. Ninguém ainda demonstrou Self-Rewriting para coding, raciocínio lógico complexo ou tarefas de linguagem natural abertas.

Não é confiável. Das oito sessões, cinco não produziram nenhuma modificação aceita. Das três que produziram, uma não melhorou o desempenho. É uma taxa de sucesso de 25%. Interessante para pesquisa, insuficiente para produção.

Não funciona com modelos pequenos. Exige modelos de pelo menos 27B parâmetros para produzir resultados positivos. Para a maioria das aplicações que usam modelos menores por custo ou latência, Self-Rewriting não é uma opção hoje.

Na prática: como seria Self-Rewriting em pseudo-código

Para quem curte ver as coisas em código, o fluxo do Self-Rewriting pode ser resumido assim:


def self_rewrite(model, good_examples, bad_examples):
    # 1. Coleta hidden states em acertos e erros
    good_states = [model.get_hidden_states(x) for x in good_examples]
    bad_states = [model.get_hidden_states(x) for x in bad_examples]

    # 2. O próprio modelo analisa a diferença
    diagnosis = model.reason(
        f"Compare estes hidden states de acertos vs erros. "
        f"Identifique quais camadas/pesos causam a falha."
    )

    # 3. O modelo propõe mudanças nos pesos
    weight_edits = model.propose_edits(diagnosis)

    # 4. Aplica as mudanças em uma cópia
    modified_model = model.clone()
    modified_model.apply_edits(weight_edits)

    # 5. Valida: a cópia modificada é melhor?
    original_score = evaluate(model, test_set)
    modified_score = evaluate(modified_model, test_set)

    if modified_score > original_score:
        return modified_model  # Aceita a mudança
    return model  # Rejeita, mantém o original

Claro, o código real é bem mais complexo. Mas a estrutura lógica é essa: diagnosticar, propor, testar, aceitar ou rejeitar. O mesmo ciclo que qualquer equipe de engenharia segue ao debugar um sistema em produção.

A parte que surpreende é que o model.reason() e o model.propose_edits() funcionam usando apenas inferência. O modelo lê seus próprios tensores como se fossem dados de entrada, raciocina sobre eles e gera as modificações como output. Zero treinamento adicional.

O código que se conserta sozinho

A analogia mais próxima para devs é: imagine um sistema que identifica seus próprios bugs em produção, escreve o fix e faz deploy, tudo sem intervenção humana. Nós já temos pedaços disso (auto-scaling, circuit breakers, self-healing infrastructure), mas no nível do código e da lógica, isso era território puramente humano.

Self-Rewriting borra essa fronteira. Não porque o modelo está “pensando” como um humano, mas porque ele tem acesso às ferramentas certas (seus próprios pesos) e capacidade de raciocínio suficiente para usá-las de forma útil.

Os pesquisadores colocaram bem no paper: “a fronteira entre treino e inferência é um limite das nossas ferramentas, não uma propriedade da inteligência”. Estamos tão acostumados a separar “treinar o modelo” de “usar o modelo” que esquecemos que essa separação é uma escolha de engenharia, não uma lei da física.

Para onde isso vai

O próximo passo natural é testar Self-Rewriting com melhorias cumulativas: cada sessão partindo dos pesos melhorados pela sessão anterior. Se isso funcionar com ganhos consistentes, teremos o primeiro exemplo concreto de auto-melhoria recursiva em modelos de linguagem.

Outro caminho promissor é combinar Self-Rewriting com SEAL. Um modelo que absorve novos dados (SEAL) e corrige suas próprias falhas (Self-Rewriting) poderia se manter atualizado e preciso indefinidamente, sem retreinamento.

E então tem a questão que ninguém quer responder: se um modelo pode se modificar, quem garante que as modificações são seguras? O mecanismo de validação atual (testar antes de aplicar) é um começo, mas para produção seria necessário um framework robusto de auditoria, logging de mudanças e rollback automático.

A pesquisa de IA tem esse padrão: cada avanço traz possibilidades empolgantes e riscos proporcionais. Self-Rewriting não é exceção. Mas com uma taxa de sucesso de 25% e limitação a modelos gigantes, estamos longe de um cenário onde seu chatbot decide reescrever o próprio cérebro sem avisar. Por enquanto.

Fonte de inspiração: Language Models Can Rewrite Their Own Weights (Fan et al., 2026)

Leave a Reply

Your email address will not be published. Required fields are marked *

Related Posts