O que é auto-aperfeiçoamento recursivo (RSI)?
Auto-aperfeiçoamento recursivo é a ideia de um sistema que melhora a sua própria capacidade de melhorar: cada rodada de automodificação torna a seguinte mais eficaz, de modo que os ganhos se acumulam. Partes estreitas desse laço são reais e estão medidas hoje — um modelo que refina a própria resposta, que gera os próprios dados de treinamento, ou que busca um prompt e um conjunto de ferramentas melhores. A recursão acumulativa que o termo realmente nomeia não foi demonstrada. Os laços medidos estagnam, precisam de um sinal externo de correção para funcionar, e um sistema treinado com a própria saída degrada em vez de melhorar.
Definição
Auto-aperfeiçoamento recursivo é um processo em que um sistema de IA se modifica — a sua saída, os seus prompts e andaime, os seus dados de treinamento ou os seus pesos — para aumentar a própria capacidade de continuar a se modificar, de maneira que cada iteração melhore a seguinte.
Pontos-chave
- O que se afirma é a recursão, não o auto-aperfeiçoamento: uma rodada de refinamento próprio é engenharia rotineira; rodadas que se acumulem não estão demonstradas.
- Todo laço de auto-aperfeiçoamento medido se apoia num sinal externo de correção — testes, um verificador, uma recompensa — e para sem ele.
- Um modelo treinado com a própria saída degrada (colapso do modelo); o laço precisa de verdade de campo nova, que é um problema de fornecimento e não algorítmico.
- O que de fato entra em produção é de andaime: sistemas que reescrevem prompts, ferramentas e baterias de avaliação, com pessoas segurando o botão de mesclar.
- Trate “melhorou sozinho” como uma afirmação de medida e pergunte qual era o verificador, quanto a recursão avançou e onde parou.
Contexto
A ideia é antiga e a evidência é escassa. I. J. Good sustentou em 1965 que uma máquina capaz de projetar máquinas melhores desencadearia uma “explosão de inteligência”, e esse enquadramento marcou a discussão desde então, mais como argumento do que como medida. Sessenta anos depois a pergunta útil não é se a explosão vem, mas quais partes do laço foram construídas e o que as limitou.
Três desenvolvimentos o reabriram como tema de engenharia e não de filosofia. Os modelos podem gastar mais computação raciocinando na inferência; o aprendizado por reforço contra recompensas verificáveis automaticamente funciona bem onde a correção é verificável por máquina; e os agentes agem sobre código, que é o único substrato em que um sistema pode editar aquilo que o produziu.
Isso importa especificamente para o trabalho de harness. Se você opera agentes que escrevem código, escolhem ferramentas e ajustam os próprios prompts, já opera parte de um laço de auto-aperfeiçoamento, com uma pessoa no caminho da mesclagem. A pergunta de engenharia é onde essa pessoa se senta e que evidência permite que ela aprove, não se o laço existe.
Arquitetura
Um sistema pode se modificar em quatro profundidades, e elas não são igualmente difíceis. A mais superficial é a saída: dentro de uma mesma execução, o modelo critica e reescreve a própria resposta. É rotineiro, ajuda em algumas tarefas e é limitado — os resultados publicados mostram que, sem retorno externo, um modelo muitas vezes não distingue de forma confiável as respostas erradas das certas, então iterar sobre o próprio julgamento pode deixar a qualidade igual ou pior.
Depois vêm o prompt e o andaime: buscar entre instruções, definições de ferramentas, ajustes de recuperação e orquestração, ficando com o que pontua melhor num conjunto reservado. É aí que vivem hoje quase todos os ganhos reais, porque o que se melhora é código e configuração em vez do modelo, e porque a nota vem de fora do sistema.
Mais fundo estão os dados: o sistema gera os próprios exemplos de treinamento, guarda os que um verificador aceita e treina com esses. Funciona onde a correção é verificável — um teste passa, uma prova fecha, uma partida é ganha — e é o mecanismo por trás dos melhores resultados recentes. Onde a correção é questão de julgamento, degenera: o sistema otimiza o verificador em vez da tarefa.
O mais fundo são os pesos, retreinados ou reforçados com sinal autogerado. É aí que a afirmação acumulativa teria de ser resolvida, e é aí que a evidência é mais fraca, porque o modo de falha não é uma queda e sim um estreitamento lento: treine com a própria distribuição e ela se contrai, geração após geração.
Nas quatro, o componente que sustenta o peso não é o modelo, é o verificador. A profundidade da recursão é limitada pelo quanto você consegue distinguir melhor de pior sem perguntar ao sistema que o produziu. Por isso o laço corre longe em código e em jogos, e quase não corre em trabalho aberto.
Componentes
Benefícios
- Laços estreitos com um verificador duro são de fato produtivos: onde a correção é verificável por máquina, os dados autogerados e a busca dão ganhos medidos.
- A melhoria de andaime é barata e reversível: prompts, ferramentas e ajustes de recuperação são configuração, então uma rodada ruim é uma reversão.
- Pressiona a avaliação, que é onde está o trabalho de verdade: um laço vale o que vale a nota que ele otimiza.
- O enquadramento esclarece a governança: a pergunta “o que este sistema pode mudar em si mesmo, e quem aprova” tem resposta e é auditável.
Riscos
- Colapso do modelo: treinar com saída autogerada estreita a distribuição e degrada a qualidade de uma geração para a seguinte, então um laço sem verdade de campo nova decai em vez de acumular.
- Manipulação da recompensa: com um verificador fraco o sistema melhora a nota e não a tarefa, e a métrica informa um sucesso que a capacidade não acompanha.
- Afirmações infalsificáveis: “o sistema melhorou sozinho” não é verificável sem o verificador, a linha de base e a profundidade da recursão, e essas são justamente as partes que costumam ser omitidas.
- Perda do caminho de supervisão: quanto mais funda a automodificação, mais difícil dizer o que mudou e por quê, que é exatamente o que uma auditoria precisa.
- Opacidade de capacidade: um sistema que reescreve o próprio andaime pode adquirir um alcance que ninguém lhe concedeu, o que é uma questão de contenção antes de ser de capacidade.
Ferramentas e tecnologias
Exemplos
- Um agente de código que escreve um patch, executa a bateria de testes e tenta de novo ao falhar: uma rodada de auto-aperfeiçoamento com verificador duro, e o mecanismo por trás do progresso medido em benchmarks sobre repositórios reais.
- Um modelo que aprende a usar uma ferramenta a partir de exemplos que ele mesmo gerou e filtrou, guardando só as chamadas que melhoravam a sua previsão.
- Aprendizado por reforço sobre problemas cuja resposta pode ser verificada automaticamente, em que o sinal de treinamento vem do verificador e não de uma etiqueta humana.
- Uma busca de prompt e andaime que propõe variantes, pontua cada uma num conjunto reservado e promove a vencedora: melhoria sem tocar no modelo.
FAQs
- Algum sistema já fez auto-aperfeiçoamento recursivo de verdade?
- Nenhum demonstrou o laço acumulativo que o termo nomeia. O que existe são rodadas isoladas contra um verificador externo, e busca sobre andaimes: reais as duas, e limitadas as duas. Os resultados publicados sobre um modelo se corrigindo sem retorno externo são notavelmente fracos, e treinar com dados autogerados degrada a qualidade entre gerações. Esses dois achados são o que qualquer afirmação de recursão tem de superar.
- É a mesma coisa que a singularidade?
- O argumento da singularidade usa o auto-aperfeiçoamento recursivo como motor, mas são afirmações distintas. RSI é um mecanismo que se pode procurar e medir; a singularidade é uma previsão sobre consequências. Você pode levar o mecanismo a sério como tema de engenharia sem sustentar posição alguma sobre a previsão, e essa é a postura útil para construir sistemas.
- Por que o verificador importa tanto?
- Porque melhorar significa “melhor”, e isso tem de ser decidido por algo externo ao que está sendo melhorado. Onde uma máquina pode verificar a correção — os testes passam, a prova fecha, a partida é ganha — o laço corre e os ganhos são reais. Onde a correção é questão de julgamento, o sistema acaba otimizando o proxy que você deu. A profundidade da recursão é uma propriedade do seu verificador, não do seu modelo.
- Devo deixar os agentes melhorarem os próprios prompts e ferramentas em produção?
- É razoável e muitas equipes fazem, desde que três coisas se cumpram: que a nota venha de um conjunto reservado que o laço não possa ver, que toda mudança adotada seja atribuível a uma execução, e que uma pessoa ou uma política controle a adoção. Sem isso você não automatizou a melhoria, automatizou o desvio.
- O que contaria como evidência de recursão real?
- Um laço que corra várias gerações sem que a taxa de melhoria caia, um verificador que o sistema não consiga manipular, e uma linha de base que separe a contribuição do laço da computação gasta. Informar as três coisas é raro o bastante para que a sua ausência seja a primeira coisa a verificar.
Referências
- Shinn et al. — Reflexion: Language Agents with Verbal Reinforcement Learning (2023)
- Schick et al. — Toolformer: Language Models Can Teach Themselves to Use Tools (2023)
- Jimenez et al. — SWE-bench: Can Language Models Resolve Real-World GitHub Issues? (2023)
- DeepSeek-AI — DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning (2025)
- Huang et al. — Large Language Models Cannot Self-Correct Reasoning Yet (2023)
- Shumailov et al. — The Curse of Recursion: Training on Generated Data Makes Models Forget (2023)
- Anthropic — Responsible Scaling Policy
- Santa María, S. — The next generation of AI: Self-Improvement and Autonomous Learning (2025)