- CoRT (Chain of Recursive Thoughts) é um projeto em que o modelo de IA não fixa uma resposta de uma vez, mas cria e avalia várias alternativas por conta própria antes de escolher a resposta final
- O fluxo de funcionamento é composto por geração da resposta inicial, determinação do número de rodadas de pensamento necessárias, geração de 3 alternativas por rodada, avaliação de todas as respostas e seleção da melhor resposta
- Nos testes com o Mistral 3.1 24B, o projeto afirma que a qualidade das respostas melhorou significativamente para um modelo pequeno, especialmente em tarefas de programação
- A Web UI ainda está em estágio inicial de desenvolvimento; no Windows usa-se o fluxo com
start_recthink.bat, e no Linux o fluxo com pip, npm e recthink_web.py
- Os principais componentes são autoavaliação, geração competitiva de alternativas, refinamento iterativo e profundidade dinâmica de pensamento, e o projeto é distribuído sob licença MIT
O que o CoRT faz
- CoRT é uma abordagem que faz o modelo de IA revisar recursivamente sua própria resposta, gerar alternativas e então escolher a melhor resposta
- O objetivo é fazer a IA não usar diretamente a primeira resposta produzida, mas repetir o processo de questionar a si mesma e tentar de novo
- O README descreve isso como um “AI battle royale”, em que a resposta que sobrevive entre vários candidatos é usada como resultado final
Como as respostas são geradas
- O fluxo de processamento é composto pelas seguintes etapas
- A IA gera uma resposta inicial
- A IA decide o número de rodadas de pensamento necessárias
- Em cada rodada, gera 3 respostas alternativas
- Avalia todas as respostas
- Seleciona a melhor resposta
- A resposta final é o resultado escolhido após repetidas gerações e avaliações de alternativas
Testes e exemplos
- O CoRT foi testado com o Mistral 3.1 24B
- O README informa que a versão com CoRT produziu resultados melhores do que a versão sem CoRT, especialmente em tarefas de programação
- Como exemplo, há uma imagem com os resultados de Mistral 3.1 24B + CoRT e Mistral 3.1 24B non CoRT
Como executar
- A Web UI ainda está em estágio inicial de desenvolvimento
- No Windows, a instrução é abrir
start_recthink.bat e aguardar a conclusão da instalação das dependências
- No Linux, o procedimento de execução é o seguinte
pip install -r requirements.txt
cd frontend && npm install
cd ..
python ./recthink_web.py
- Em um novo shell, execute o frontend
cd frontend
npm start
Execução direta e componentes
- Para executar diretamente, instale as dependências, configure
OPENROUTER_API_KEY e depois execute o script Python
pip install -r requirements.txt
export OPENROUTER_API_KEY="your-key-here"
python recursive-thinking-ai.py
- Os quatro elementos principais destacados pelo projeto são os seguintes
-
Autoavaliação
- Geração competitiva de alternativas
- Refinamento iterativo
- Profundidade dinâmica de pensamento
- Contribuições podem ser enviadas via PR, e a licença é MIT
1 comentários
Opiniões no Hacker News
Vejo muito a tendência de achar que, se colocarmos vários modelos para se enfrentar ou rodarmos um bando deles, uma inteligência coletiva vai surgir magicamente, mas depois de experimentar diretamente e ver o trabalho da ASU/Microsoft Research, cheguei a uma conclusão mais simples: LLMs são péssimos validadores de outros LLMs
Na apresentação “(How) Do LLMs Reason/Plan?”, de Subbarao Kambhampati, o GPT-4 produz com confiança uma prova de coloração de grafos comprovadamente errada, até que um solucionador SAT simbólico entra como juiz https://www.youtube.com/watch?v=0u2hdSpNS2o
O artigo de Stechly et al. quantifica que, quando o GPT-4 é levado a criticar sua própria resposta, a precisão na verdade cai, enquanto acoplar um verificador externo e sound melhora cerca de 30 p.p. em tarefas de planejamento e quebra-cabeças em geral https://arxiv.org/abs/2402.08115
Ou seja, para os modelos autorregressivos atuais, verificar é mais difícil do que gerar, e é preciso ter verificadores que de fato raciocinem sobre o mundo, como compiladores, linters, solucionadores SAT e datasets com respostas corretas
Por isso, empilhar vários LLMs normalmente não ajuda muito. O position paper “LLM-Modulo” também considera que modelos autorregressivos não conseguem fazer autoverificação ou planejamento de longo prazo por conta própria, e que devem ser tratados como geradores de ideias de alta revocação, envolvidos por um único verificador sound https://arxiv.org/abs/2402.01817
Testando diretamente, trocar um debate entre 5 modelos por um único modelo forte mais um verificador produziu respostas iguais ou melhores, com latência e custo de orquestração muito menores
Livros e filmes são bons exemplos: é fácil dizer que um personagem é raso, mas criar um personagem profundo e interessante é surpreendentemente difícil
Em engenharia de software acontece algo parecido: um LLM, ao receber um prompt para encontrar vulnerabilidades de segurança, consegue apontar trechos que podem ser vulneráveis no código gerado
Mas, se você espera que outro LLM encontre erros de raciocínio em uma prova matemática, ele basicamente precisa refazer todo o raciocínio, então é duvidoso que haja um ganho de desempenho significativo
Ele também está profundamente incorporado à avaliação de pipelines RAG em frameworks como LangChain e LlamaIndex https://arxiv.org/abs/2411.15594
Fico curioso sobre uma abordagem em que o LLM também crie testes unitários para o código que gerou e, em seguida, execute todos eles junto com os testes unitários existentes da aplicação
Verificar se o código compila e se os testes unitários passam permite uma validação fundamentada em alguma medida, e a IA pode ler os resultados dos testes e usá-los para corrigir seus próprios erros
Treinar com dados de corpus pode gerar saltos de uma ordem de grandeza, mas treinar com dados de interação que tenham um loop OODA capaz de observar e se adaptar é muito mais poderoso
Se eu estivesse trabalhando com IA, acho que faria isso. Mas, na prática, estou criando o BrowserBox
Generate-and-test exige um algoritmo de verificação confiável, relativamente rápido e eficiente em memória, e é especialmente útil quando um algoritmo de geração exato, que só produz respostas corretas, é lento ou consome muita memória
Aqui, o gerador é o LLM, e o checador ou “verificador” seriam compiladores, linters, solucionadores SAT, datasets com respostas corretas etc.
Generate-and-test também se relaciona com tentativa e erro, e tentativa e erro provavelmente existe desde o Paleolítico
Um método que uso às vezes é primeiro fazer o modelo de chat de IA me dar a resposta para o problema e depois pedir que escreva um relatório explicando por que aquela resposta está correta, de modo que alguém — ou uma IA — que não conheça o problema inicial nem a área técnica consiga entender
Em seguida, faço um segundo modelo de IA que não conhece o problema avaliar o relatório e escrever outro relatório exigindo explicações que o modelo original não forneceu ou apontando inconsistências na lógica
Devolvo esse relatório ao modelo original, peço que reescreva a resposta incorporando as informações ou correções necessárias, e repito até que o segundo modelo seja convencido ou o primeiro modelo incorpore todas as solicitações de mudança
É bem rudimentar, mas, nas vezes em que tentei, deu resultados muito bons
O plano final normalmente fica muito mais equilibrado e refletido
Curiosamente, essa técnica funciona bem até quando aplicada a si mesmo. Procurar falhas antes de revisar o plano realmente ajuda
Por exemplo, um com foco técnico, outro com foco em marketing e outro com contexto relacionado a objetivos pessoais
Colocar a mesma pergunta em chats com contextos diferentes é parecido com olhar o mesmo problema por vários ângulos, e as conclusões também podem variar bastante conforme o contexto
Parecia uma ideia muito boa, mas imagino que o uso de tokens aumente bastante
Também me preocupa que, se o LLM usado como julgador não for capaz de produzir uma resposta suficientemente boa em primeiro lugar, ele talvez também tenha dificuldade para avaliá-la corretamente
Tenho vontade de experimentar algo assim em uma escala maior, na forma de um senado de debate sempre ligado
Em vez de responder a prompts pontuais, você daria uma lista de tarefas, talvez com prazos, e o senado trabalharia nelas, dividindo-se em grupos para subtarefas, contestando resultados e fazendo propostas
Indo além, também daria para criar uma árvore de analistas em que os nós pais só elevassem propostas quando julgassem que uma análise subordinada é particularmente perspicaz
Vejo claramente que instruir um modelo a abordar um problema a partir de uma perspectiva específica pode melhorar ou piorar os resultados. Criar várias perspectivas junto com uma análise crítica dos resultados delas pode produzir resultados impressionantes
Esse método geraria uma quantidade enorme de tokens, mas o custo por token está indo na direção de tornar isso viável. Também existe a possibilidade de criar um servidor IRC dedicado a IA, ao qual qualquer pessoa poderia conectar seu próprio modelo e usar como uma sala de debate compartilhada
Quando eu passava tempo tentando, ficava bloqueado e voltava, ele dizia de forma leve “Sim, você encontrou bem isso! Está quase lá! O próximo passo é X e Y”, e então entregava o mesmo tutorial detalhado de antes, só mudando levemente partes como a flag que estava errada
Parece lidar com um estagiário excessivamente entusiasmado que joga coisas sem conferir o trabalho, e acho que melhoraria bastante colocar um segundo bot diante do primeiro para perguntar “você tem mesmo certeza?”
Modelei isso a partir do conceito dos conselheiros de Civilization II, e funcionou razoavelmente bem, mas havia certa limitação por estar preso a um único LLM, o Mistral
E era pesado a ponto de quase incendiar meu computador
Seria interessante ver o que isso produziria com tempo e tokens suficientes
Uma estratégia muito mais simples e limitada que uso com frequência é acrescentar ao fim da mensagem: “antes de responder, pense uma vez dentro de tags, faça uma autocrítica uma vez dentro de tags e, por fim, escreva a resposta final”
Funciona muito bem. De modo parecido, apenas dizer “encontre os 5 maiores problemas da proposta” também é bom, mas forçar 5 faz com que ele encontre alguma coisa, mesmo que a maioria seja pouco relevante
Na etapa 1, peço que ele faça um plano; na etapa 2, que aponte falhas no plano; na etapa 3, que atualize o plano refletindo essas falhas
Outras perguntas que faço com frequência são coisas como “o que estamos deixando passar?” e “quais são as considerações de desempenho, segurança, jurídico e custo?”
Também dá para repetir algumas vezes prompts de indução como “tem mais alguma coisa?”, especialmente quando você orienta os temas a considerar. Ao final de cada rodada, peço que ele atualize o plano levando essas considerações em conta
Um pouco diferente do que eu esperava pelo título. Achei que seria explicitamente um procedimento adversarial
Não testei isso diretamente e nem sei se funcionaria. Mas ajuda perguntar ao ChatGPT, em prompts separados, “XYZ é verdadeiro, explique por quê” e “XYZ é falso, explique por quê”, e ver qual lado é mais convincente
https://github.com/evalstate/fast-agent
Não sei por que alguém acharia isso novo. Talvez mostre o estado do HN
A abordagem em si parece boa, mas você nunca deve insinuar diretamente “você está errado”. Normalmente ele simplesmente assume que está errado
Pelo contrário, é impressionante quando ele de fato rebate e se defende mesmo fazendo algo assim
Experimentos desse tipo são bem interessantes, então estou criando um editor de grafos no estilo Blueprint da Unreal Engine para que as pessoas possam projetar esses workflows
O prompt do usuário entra em um agente, que cria uma tentativa inicial; esse histórico de conversa passa para outro “agente” com um prompt de sistema diferente, que se torna um crítico rigoroso, emite um sinal de aprovado/reprovado, e o fluxo entra em loop até o crítico julgar que passou, então a saída é mostrada ao usuário
O ideal seria um site pequeno que chamasse o endpoint de LLM do próprio usuário e permitisse salvar, carregar e compartilhar grafos de workflow
Mistral Small 3.1 e Gemma 3 parecem os primeiros modelos meio competentes que dá para rodar localmente, mas essa competência é só a semente; é preciso um framework para mantê-los no rumo
Se você der permissão para executar Python dentro do loop iterativo e mandar explorar o mundo, eles começam a baixar e ler coisas como notícias
Por exemplo, ao instruir o GPT a ser maldoso, deu para imitar no GPT, até certo ponto, a capacidade do Gemini de apontar besteiras ou raciocínios frágeis. Parece que a polidez filtra muita coisa valiosa
Mas o resultado fica desagradável de ler. O Gemini parece ter resolvido isso tratando em duas etapas no treinamento e transformando a primeira etapa em “pensamento” privado
Então acho que o necessário é uma abordagem em duas etapas que dê uma lapidada humana nessa saída “maldosa”. Trabalhar assim fica bem cansativo depois de pouco tempo
Uma UI de chat em grupo com diferentes personalidades de LLM também poderia ter muito valor. O formato dos objetos de mensagem parece pensado para vários usuários e várias IAs, com nome em cada mensagem, mas ainda não vi uma UI assim
Seria ainda melhor se suportasse vários provedores. Eles têm pontos fortes diferentes, então é parecido com pedir uma segunda opinião
O consortium envia o mesmo prompt em paralelo para vários modelos e manda todas as respostas para um modelo mediador avaliar. O mediador decide se é preciso iterar mais
Também é possível forçar mais iterações até atingir um limiar de confiança ou um número mínimo de iterações
Com o PR que fiz para o llm-openrouter, dá para salvar aliases de modelo incluindo várias opções de modelo. Por exemplo, é possível criar um especialista em pesquisa online com
llm openrouter save -m qwen3 -o online -o temperature 0, system "research prompt" --name qwen-researcherOutro membro pode fazer extração de objetos em modo JSON, e outro pode escrever um rascunho às cegas. O mediador usa tudo isso para sintetizar uma boa resposta
Precisamos encontrar logo um jeito de rodar essas GPUs com energia limpa. Caso contrário, as IAs vão derreter o planeta discutindo entre si sobre a solução ótima do jogo da velha
Às vezes é o jeito mais fácil de concluir uma tarefa bem pequena, mas a diferença de custo no backend deve ser enorme. No fim, o usuário simplesmente não liga. Porque não há sensação de realidade
Já é tratado quase como fato consumado que a IA precisa continuar rodando contra si mesma
Acho que é assim que se faz modelos de machine learning gerarem novas ideias
Diagonalizar, por meio de autoargumentação, contra todas as ideias já tentadas e descartadas, mantendo certas restrições de consistência. Claro que isso é muito menos fácil do que parece
É como o Game of Life de Conway, mas em vez de quadrados coloridos com regras, são LLMs com certos pesos conversando sem parar entre si, e em algum lugar isso emerge como fala ou ação
https://news.ycombinator.com/item?id=43835798
Até onde isso vai chegar? Será que vai surgir uma equipe scrum de agentes de IA, fazendo reuniões stand-up a cada poucas horas?
Será que vamos replicar a burocracia governamental com agentes debatendo um tema o dia inteiro para encontrar a melhor visão?
Agentes de IA com papéis diferentes operavam uma equipe scrum, e os prompts de cada agente eram configurados para discordar de todos ou apresentar seu próprio ponto de vista de forma muito crítica; a decisão final ficava a cargo de um mediador
O palestrante afirmou que, para eles, funcionou bem
Humanos têm experiências e perspectivas diferentes, embora LLMs tenham isso em menor grau. Ainda assim, às vezes um outro chapéu já basta. Por exemplo, como a diferença entre um revisor de código e um programador
Em algum momento haverá um ponto em que o efeito se estabiliza, e provavelmente também surgirá um comitê de IA para definir esse ponto
Afinal, ninguém vai querer ferver o oceano
É bom que tenham tornado isso fácil de fazer fork e brincar
Acabei de começar minha iteração adicionando Nash Equilibrium e reformulando “engenharia de prompts” como negociação multiagente. Estou curioso para saber o que outras pessoas pensam
https://github.com/faramarz/NECoRT/
Minha avaliação é que LLMs corporativos não terão grandes problemas com o custo computacional adicional e preferirão ajustar finanças complexas por meio de várias otimizações de modelagem
Não tenho muita familiaridade com repositórios públicos e contribuições, então gostaria que alguém apontasse se eu estiver fazendo algo errado
A intenção é fazer fork da base de código original, testar a teoria e, por fim, enviar como PR