Jeff Dean saiu do Google depois de mais de 20 anos para fundar a Discovery Loop, uma startup que quer construir sistemas de IA capazes de se autoaperfeiçoar de forma recursiva. Segundo o Olhardigital.com.br, o pesquisador — que liderou o Google Brain e ajudou a moldar a infraestrutura da empresa — agora aposta em um conceito que pode redefinir como treinamos modelos. Na minha visão, esse movimento diz muito sobre o momento que estamos vivendo: a fronteira de pesquisa saiu dos laboratórios das big techs e está migrando para estruturas menores e mais ágeis.
Por que a saída de Jeff Dean importa (e por que devs deveriam se importar)
Para quem não acompanha o ecossistema de IA de perto, Jeff Dean pode parecer só “mais um pesquisador famoso”. Ledo engano. Ele foi peça-chave em projetos como MapReduce, BigTable, TensorFlow e, claro, na fundação do Google Brain — o laboratório que em 2012 protagonizou o boom das redes neurais profundas com o paper sobre reconhecimento de imagens não supervisionado. Quando alguém com esse peso histórico deixa uma big tech, é sinal de que algo mudou no tabuleiro.
E mudou mesmo. A Discovery Loop não quer fazer “mais um modelo grande”. Ela quer trabalhar com autoaperfeiçoamento recursivo (recursive self-improvement): sistemas que iteram sobre o próprio código, dados e arquitetura com mínima intervenção humana. Isso é diferente de AutoML, diferente de RLHF, diferente de agentic frameworks. É uma categoria à parte.
O que é “autoaperfeiçoamento recursivo” na prática
Em termos simples, a ideia é a seguinte: um sistema de IA recebe um objetivo (ex.: “melhore sua própria latência de inferência”), propõe modificações, avalia os resultados e aplica as mudanças que performaram melhor — repetindo o ciclo várias vezes. O “recursivo” entra porque o sistema usa a si mesmo como ferramenta para projetar a próxima versão dele mesmo.
Na minha experiência com pipelines de MLOps, a parte mais dolorosa sempre foi a otimização manual de hiperparâmetros, arquitetura e pré-processamento. Se uma IA conseguir automatizar esse ciclo com qualidade, a economia de tempo é brutal.
Comparando com o que já existe hoje
Muita gente confunde recursive self-improvement com técnicas que já estão no mercado. Vou separar para ficar claro:
- AutoML (Google, Auto-sklearn, H2O): automatiza busca de arquitetura e hiperparâmetros, mas opera em um espaço de busca pré-definido. Não modifica a si mesmo.
- RLHF (OpenAI, Anthropic): usa feedback humano para alinhar o modelo. Não há autoaperfeiçoamento real, só ajuste fino supervisionado.
- Agentic frameworks (AutoGPT, LangGraph, CrewAI): orquestram LLMs em loops, mas dependem de um modelo base estático. O modelo não evolui a si mesmo.
- Recursive self-improvement: o sistema é tanto o agente que executa quanto o objeto que está sendo modificado. É meta-aprendizado em outro nível.
A diferença parece sutil, mas muda completamente o perfil de risco e o tipo de pesquisa necessária. Por isso a Discovery Loop atraiu investidores como a própria Alphabet — é o tipo de aposta que mesmo o Google quer acompanhar de perto.
Na Prática: como simular um loop de autoaperfeiçoamento em Python
Não dá pra construir uma AGI no fim de semana, mas dá pra experimentar o conceito em escala pequena. Montei um exemplo funcional usando um cenário clássico: otimização de hiperparâmetros de um modelo simples, onde o “agente” propõe novos parâmetros com base nos resultados anteriores.
import random
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import cross_val_score
class SelfImprovingAgent:
def __init__(self):
self.X, self.y = load_iris(return_X_y=True)
self.best_params = {
"n_estimators": 50,
"max_depth": 3,
"min_samples_split": 2
}
self.best_score = self.evaluate(self.best_params)
self.history = [(self.best_score, self.best_params.copy())]
def evaluate(self, params):
model = RandomForestClassifier(
n_estimators=params["n_estimators"],
max_depth=params["max_depth"],
min_samples_split=params["min_samples_split"],
random_state=42
)
scores = cross_val_score(model, self.X, self.y, cv=5)
return scores.mean()
def propose_mutation(self, params):
# "Autoaperfeiçoamento": mutação leve em torno do melhor resultado
new_params = params.copy()
new_params["n_estimators"] = max(10, params["n_estimators"] + random.choice([-10, 0, 10, 20]))
new_params["max_depth"] = max(1, params["max_depth"] + random.choice([-1, 0, 1]))
new_params["min_samples_split"] = max(2, params["min_samples_split"] + random.choice([-1, 0, 1]))
return new_params
def run_loop(self, iterations=10):
for i in range(iterations):
candidate = self.propose_mutation(self.best_params)
score = self.evaluate(candidate)
if score > self.best_score:
self.best_score = score
self.best_params = candidate
self.history.append((score, candidate.copy()))
print(f"[iteração {i}] melhoria: {score:.4f} com {candidate}")
else:
print(f"[iteração {i}] sem ganho ({score:.4f})")
print(f"\nMelhor score final: {self.best_score:.4f}")
return self.best_params
if __name__ == "__main__":
agent = SelfImprovingAgent()
agent.run_loop(iterations=15)
O exemplo é tosco — e tem que ser. A ideia é mostrar o esqueleto do conceito: o agente mantém o melhor estado conhecido, propõe variações e atualiza apenas quando há ganho mensurável. Em sistemas reais da Discovery Loop, a “mutação” pode envolver alteração de arquitetura, re-tokenização de datasets ou reescrita de parte do próprio loop. A complexidade escala rápido.
Por que isso é mais difícil do que parece
Testei variações desse loop em problemas maiores (XGBoost em datasets tabulares) e o padrão se repete: o ganho marginal cai rápido, e sem diversidade nas mutações o agente fica preso em ótimos locais. É aí que entram técnicas como:
- Exploration-exploitation trade-off: nem sempre aceitar só melhorias; às vezes aceitar uma queda controlada para escapar de platôs.
- Population-based training: manter várias versões competindo entre si, em vez de uma só.
- Meta-gradients: o agente aprende como aprender, não apenas o que aprender.
São técnicas que já existem em pesquisa (DeepMind usou bastante em AlphaGo e AlphaStar), mas juntá-las com LLMs como “meta-controladores” é território novo — exatamente onde a Discovery Loop quer atuar.
Erros Comuns que devs cometem quando tentam implementar loops autoaperfeiçoáveis
Esse é o tipo de sistema onde você aprende mais com os erros do que com os acertos. Vou listar as armadilhas que já vi (e nas quais já caí):
- Achar que “mais iterações” resolve. Não resolve. Sem diversidade nas mutações, o loop converge em 5 iterações e fica martelando o mesmo ponto por horas.
- Não definir uma métrica de parada clara. Sem critério de parada, o sistema roda até estourar budget computacional — ou pior, até degradar silenciosamente.
- Confundir autoaperfeiçoamento com prompt engineering iterativo. Trocar o prompt e ver se a resposta melhora não é self-improvement, é busca manual.
- Esquecer o controle de versão. Toda mutação precisa ser rastreável. Se não der para reverter para uma versão anterior que performava melhor, você está jogando xadrez sem saber onde está a rainha.
- Subestimar o custo de avaliação. Cada iteração precisa de uma função de avaliação barata. Se o “evaluate” demorar 10 minutos, 15 iterações viram 2,5 horas — inviável em escala.
- Ignorar viés do espaço de busca. Se o agente só consegue mutar hiperparâmetros, ele nunca vai descobrir uma mudança arquitetural que dobra a performance.
Na minha experiência, o erro número 4 é o que mais mata projetos em produção. Versionar não é glamour, mas é o que separa um experimento interessante de um sistema confiável.
O que isso significa para o ecossistema de devs
Se a Discovery Loop entregar o que promete, algumas coisas mudam no curto prazo:
- Frameworks de MLOps vão precisar incorporar loops autoaperfeiçoáveis como cidadãos de primeira classe. MLflow, Weights & Biases e Kubeflow ainda tratam isso como caso especial.
- A barreira de entrada para treinar modelos “bons” cai drasticamente. Devs sem PhD vão conseguir resultados antes reservados a times de pesquisa.
- O foco de contratação muda. Em vez de procurar “cientista de dados puro”, empresas vão querer engenheiros que entendam tanto o loop quanto a infraestrutura por trás dele.
- Questões de governança explodem. Sistemas que se modificam sozinhos levantam problemas sérios de auditoria, compliance e segurança — temas que o EU AI Act já começa a endereçar.
Recomendo acompanhar de perto. Mesmo que a Discovery Loop fracasse, o conceito vai virar feature padrão em algum framework open-source em 12 a 18 meses. Isso é padrão: toda pesquisa de fronteira vira commodity rápido.
FAQ — Perguntas que devs realmente fazem
1. O autoaperfeiçoamento recursivo é o mesmo que uma IA “se tornar consciente”?
Não. Consciência é uma categoria filosófica que nada tem a ver com otimização iterativa de parâmetros. O sistema continua sendo uma função que recebe inputs e produz outputs — só que essa função agora reescreve partes de si mesma com base em métricas.
2. Dá para usar recursive self-improvement com LLMs atuais?
Dá, mas com cuidado. Um padrão comum é usar um LLM como “controlador” que propõe mudanças em código de pipelines, prompts ou configurações, executa, mede e decide se aceita. O desafio é que LLMs são caros e lentos para esse papel — cada iteração consome tokens e tempo. Por isso, na prática, os sistemas hoje usam modelos pequenos como controladores.
3. Qual a diferença entre isso e o que a Sakana AI faz?
A Sakana AI trabalha com “model merging” e evolutionary model merging — combinar modelos diferentes para gerar novos. É uma forma de exploração do espaço de modelos, mas não há loop recursivo de autoaperfeiçoamento no sentido clássico. A sobreposição é parcial, não total.
4. Isso é perigoso?
Depende do que você considera “perigoso”. Sistemas autoaperfeiçoáveis podem otimizar para a métrica errada (problema do papel-máquina de奖励) e produzir comportamentos não intencionais. Por isso, governança e avaliação externa contínua são essenciais. Não é apocalipse, mas não é brinquedo.
5. Como começar a estudar isso na prática?
Eu recomendo três caminhos: ler os papers da DeepMind sobre population-based training, estudar o framework OpenAI’s “weak-to-strong generalization”, e implementar variações do exemplo acima em datasets do Kaggle. A melhor forma de entender é quebrar o próprio loop.
Segundo o Olhardigital.com.br, a Discovery Loop já conta com outros três pesquisadores de destaque e aporte de investidores do Vale do Silício, incluindo a Alphabet. É o tipo de movimento que, no fim das contas, beneficia a todos — mesmo quem não pretende fundar a próxima big tech. As ferramentas ficam melhores, o custo cai, e a fronteira do que é possível continua avançando.
Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.