RLM 2027 · Capítulo 10 de 24 · 11 min
Comparar métodos nas mesmas condições e ler os resultados contrários
Quem compara RLM, RAG e contexto longo com o mesmo modelo e limiares escritos antes separa o efeito do método do efeito do modelo.
Este capítulo faz parte do curso gratuito RLM 2027. Para marcar como concluído e salvar o progresso, abra este capítulo na página do curso.
Com as 120 perguntas classificadas, faltava decidir contra o quê o RLM seria medido e com quais regras. Um teste que troca o modelo e o método ao mesmo tempo produz um número que ninguém sabe atribuir: a melhora pode vir do GPT-5, da recursão ou das duas coisas.
Esse erro custa caro na Veredas porque a decisão tem prazo e orçamento. Se o protocolo nascer depois dos resultados, cada número ruim ganha uma explicação e cada número bom vira prova. Helena precisa de limiares escritos antes, para que a recomendação ao cliente dependa do que foi medido e não do humor da semana.
Ao terminar, você lê a tabela principal do artigo RLM como uma comparação controlada, conhece os cinco resultados publicados que contrariam o entusiasmo e escreve um protocolo com braços, métricas e limiares definidos antes da primeira execução.
Por que só a comparação controlada separa o método do modelo
Comparação controlada: mudar uma coisa só e manter o resto igual, como trocar o adubo de metade da horta e deixar a mesma semente, a mesma água e o mesmo sol. Na Tabela 1 da versão 3 do artigo, o modelo raiz é sempre o GPT-5, as subchamadas vão ao GPT-5-mini, as tarefas são as mesmas e o custo sai da mesma tabela de preços. O que muda é o andaime em volta do modelo.
Os braços da tabela cobrem as alternativas que um engenheiro consideraria. O modelo base recebe o texto inteiro. CodeAct é um agente que age escrevendo código, testado com busca BM25 e com subchamadas. O agente de compactação resume o histórico com o GPT-5-nano quando ele cresce. OpenCode é um agente de código aberto, com e sem o contexto gravado em arquivo. O RLM aparece com profundidade de 0 a 3.
GPT-5 como raiz: acurácia (F1 no OOLONG-Pairs) e custo médio por item
| Método | CodeQA | BrowseComp-Plus | OOLONG | OOLONG-Pairs |
|---|---|---|---|---|
| Modelo base | 24,0* (US$ 0,13) | 0,0* | 44,0 (US$ 0,14) | 0,1 (US$ 0,16) |
| CodeAct + BM25 | 22,0* (US$ 0,06) | 51,0 (US$ 0,71) | 38,0 (US$ 0,61) | 24,7 (US$ 0,75) |
| Agente de compactação | 58,0 (US$ 1,31) | 70,5 (US$ 0,57) | 46,0 (US$ 0,13) | 0,1 (US$ 0,13) |
| OpenCode + contexto em arquivo | 64,0 | 94,0 | 52,0 | 4,8 |
| RLM, profundidade 0 | 58,0 (US$ 0,18) | 88,0 (US$ 0,44) | 36,0 (US$ 0,37) | 43,9 (US$ 0,69) |
| RLM, profundidade 1 | 62,0 (US$ 0,11) | 91,3 (US$ 0,99) | 56,0 (US$ 0,43) | 58,0 (US$ 0,33) |
| RLM, profundidade 2 | 66,0 (US$ 0,15) | 92,0 (US$ 0,55) | 56,5 (US$ 1,10) | 65,5 (US$ 0,33) |
| RLM, profundidade 3 | 58,0 (US$ 0,15) | 92,0 (US$ 0,51) | 58,0 (US$ 0,51) | 76,0 (US$ 0,39) |
Asterisco: o método bateu no limite de contexto. O custo do OpenCode não foi medido no artigo.
Fonte: Zhang, Kraska e Khattab, Recursive Language Models, v3 (maio de 2026), Tabela 1
Lida com calma, a tabela mostra mais do que uma vitória. No OOLONG, o RLM de profundidade 1 vai de 44,0 para 56,0: são 12 pontos, ou 27,3% relativos. O texto do artigo fala em 28,4%, número que bate com os 56,5 da primeira versão. A diferença é pequena, e a lição é conferir a conta contra a tabela da versão que você cita.
Compare também o RLM com o agente de compactação, que é a alternativa mais parecida com o que muitas plataformas já vendem. No OOLONG-Pairs, a compactação marca 0,1 e o RLM de profundidade 1 marca 58,0. Resumir o histórico apaga justamente os detalhes de cada entrada que um par precisa. No BrowseComp-Plus, a distância é menor, 70,5 contra 91,3, porque ali a resposta depende de poucos trechos e o resumo os preserva com mais frequência.
O artigo faz ainda uma conta de referência para o BrowseComp-Plus. Só ingerir de 6 a 11 milhões de tokens com o GPT-5-mini custaria de US$ 1,50 a US$ 2,75 por item, contra US$ 0,99 em média do RLM de profundidade 1. Essa comparação é hipotética, porque nenhum modelo recebe 11 milhões de tokens numa chamada, mas mostra que ler por partes escolhidas pode sair mais barato do que ler tudo.
Profundidade maior não melhora sempre. No GPT-5, a profundidade 3 é a melhor no OOLONG-Pairs (76,0) e piora no CodeQA (58,0 contra 66,0 na profundidade 2). Com o Qwen3-Coder-480B como raiz, a história inverte: o OOLONG cai de 48,0 para 26,0 e fica em 32,0 conforme a profundidade sobe, e no CodeQA a profundidade 0, sem subchamada nenhuma, marca 66,0 e vence todas as variantes recursivas. Os autores atribuem a queda a erros de sintaxe que descem para os sub-RLMs.
Sem subchamadas, na profundidade 0, o modelo tem o REPL e o texto guardado como variável, mas não pode chamar outro modelo. É o controle mais útil da tabela. Com GPT-5, essa versão já marca 88,0 no BrowseComp-Plus e 58,0 no CodeQA. Boa parte do ganho vem, portanto, de tirar o texto da janela e deixá-lo manipulável por código. As subchamadas pesam mais onde a resposta depende de ler muitas entradas com atenção, como no OOLONG-Pairs, que sobe de 43,9 para 58,0.
Nesse ponto mora a armadilha comum da leitura: comemorar o 91,3 do RLM sobre o 0,0 do modelo base no BrowseComp-Plus. O asterisco diz que o base nem coube na janela; o zero mede o estouro, não a capacidade de raciocínio. A comparação que informa é com quem leu o mesmo material por outro caminho, e ali o OpenCode com contexto em arquivo marca 94,0, acima do RLM, embora afunde para 4,8 no OOLONG-Pairs.
Custo também pede leitura controlada. Os valores entre parênteses são médias, e o artigo publica o desvio-padrão ao lado: o RLM de profundidade 2 no OOLONG custa US$ 1,10 com desvio de US$ 3,25, quase três vezes a média. Os autores escrevem que a execução mediana do RLM sai mais barata que a mediana do modelo base e mais cara na média, puxada por trajetórias fora da curva. Média sozinha esconde a cauda que estoura o orçamento.
Os resultados que contrariam o entusiasmo
Em 3 de março de 2026, Daren Wang, da Universidade Chinesa de Hong Kong, publicou uma reprodução independente do RLM com o título “Think, But Don't Overthink”. Ele usou o DeepSeek v3.2 e o Kimi K2, 20 amostras por condição, o OOLONG restrito a contextos de 1.024 a 65.536 tokens e uma única execução num laptop. As condições são modestas, e os resultados, incômodos.
No S-NIAH, os dois modelos acertam 100% sozinhos. Com RLM, o DeepSeek v3.2 cai para 85% na profundidade 1 e 70% na profundidade 2, e o Kimi K2 cai para 90%. No OOLONG, o DeepSeek sobe de 0,0% para 42,1% na profundidade 1 e desce a 33,7% na profundidade 2. O Kimi K2, que já marcava 86,6% sozinho, cai para 60,0% e 55,0%. O autor chama o efeito de pensar demais: colapso de formato e explosão de latência e de tokens.
A reprodução independente em quatro números
100% → 70%
DeepSeek v3.2 no S-NIAH, da base à profundidade 2
20 amostras, execução única
86,6% → 55,0%
Kimi K2 no OOLONG, da base à profundidade 2
Contextos de 1.024 a 65.536 tokens
0,0% → 42,1%
DeepSeek v3.2 no OOLONG, da base à profundidade 1
O mesmo estudo registra também ganho
3,6 s → 344,5 s
Latência do DeepSeek v3.2 no S-NIAH
Da base à profundidade 2; o Kimi K2 chega a 545,5 s
Fonte: Daren Wang, Think, But Don't Overthink (março de 2026)
Outros quatro trabalhos apontam na mesma direção por caminhos diferentes. A Prime Intellect, em janeiro de 2026, viu o RLM piorar o ambiente de matemática com Python e só superar o modelo direto no DeepDive quando recebia dicas de estratégia. A Apple, no SRLM de março de 2026, relata que dentro da janela nativa o RLM com recursão muitas vezes degrada em relação ao modelo sozinho, e que a recursão em si não é o principal motor do desempenho.
No mesmo mês, o λ-RLM venceu o RLM padrão em 29 de 36 comparações, com nove modelos abertos e contextos de 8 mil a 128 mil tokens, trocando o código livre por combinadores tipados. E a própria Tabela 2 do artigo RLM mostra que, sem dicas de decomposição, o RLM com GPT-5.2 derruba o LongCoT-mini em matemática (de 26,0 para 5,6) e em computação (de 40,4 para 11,0), embora suba muito em lógica e xadrez.
Os resultados contrários, em ordem de publicação
- 1º de janeiro de 2026Concluído
Prime Intellect
RLM piora matemática com Python; DeepDive só melhora com dicas; tempo cresce em todos os ambientes
- 3 de março de 2026Concluído
Reprodução de Daren Wang
Queda no S-NIAH e no OOLONG do Kimi K2; latência até 545,5 s
- 7 de março de 2026Concluído
SRLM, da Apple
Dentro da janela, recursão muitas vezes degrada; até 22% acima do RLM com o mesmo tempo
- 20 de março de 2026Concluído
λ-RLM
Combinadores tipados vencem o RLM padrão em 29 de 36 comparações com modelos abertos
- 11 de maio de 2026Agora
Versão 3 do artigo RLM
Escala recua de duas ordens de grandeza para mais de uma; LongCoT-mini sem dicas piora em matemática
Os resultados contrários têm um padrão em comum. Quase todos aparecem em tarefas que cabem na janela, em buscas de um trecho só ou em raciocínio matemático sem leitura densa. Nenhum desmente o ganho em agregação e cruzamento sobre textos que passam da janela; eles delimitam onde o ganho existe. Amostras pequenas pedem a mesma cautela nos dois sentidos: 20 itens também não bastam para enterrar o método.
Como a Veredas escreveu o protocolo antes de rodar a primeira pergunta
Caio definiu três braços. O primeiro é o RAG atual, sem mudança, para servir de linha de base. O segundo é o contexto longo, que só cabe no recorte da mina e da barragem, com cerca de 900 mil tokens, e já tinha marcado 31 de 50 em agregação dentro deles; o acervo inteiro, com 52 milhões de tokens, não entra em janela nenhuma. O terceiro é o RLM de profundidade 1, com GPT-5 na raiz e GPT-5-mini nas subchamadas, a configuração principal do artigo.
Controlar a comparação exigiu fixar o que não aparece na tabela. Os três braços leem a mesma extração de texto do acervo, com a mesma correção de documentos escaneados. As perguntas entram com a mesma redação, e a resposta de referência é a mesma. O preço fica congelado na tabela de 23 de setembro de 2026: US$ 1,25 por milhão de tokens de entrada e US$ 10 de saída no GPT-5, US$ 0,25 e US$ 2 no GPT-5-mini. Mudança de preço depois não altera a comparação.
O teste que a Veredas quase fez e o que acabou fazendo
Comparação solta
Coluna a evitar
- RLM com um modelo novo contra o RAG com o modelo antigo
- Nota total, sem separar localização, agregação e cruzamento
- Custo médio, sem mediana nem pior caso
- Critério de sucesso decidido depois de ver o resultado
Comparação controlada
Coluna recomendada
- Mesmo modelo de linguagem e mesmas 120 perguntas nos três braços
- Nota por tipo de pergunta, sempre em três linhas
- Média, mediana, desvio e a execução mais lenta
- Cinco limiares assinados por Helena antes da primeira execução
Métricas vieram das fontes e do negócio. Acurácia por tipo de pergunta, com F1 no cruzamento. Custo por pergunta em média, mediana e desvio. Latência mediana e percentil 95, o tempo abaixo do qual ficam 95% das execuções, porque a cauda é onde o RLM sofre. Número de subchamadas, porque o Qwen3-Coder chegou a centenas ou milhares numa tarefa simples. Evidência rastreável, a métrica que só a Veredas precisava e que nenhum benchmark publica.
As métricas do protocolo e a armadilha que cada uma evita
| Métrica | O que mede | Armadilha que evita |
|---|---|---|
| Acurácia por tipo | Acertos em localização, agregação e cruzamento | Ganho num tipo escondendo perda em outro |
| F1 no cruzamento | Pares certos achados e pares listados corretos | Zerar a pergunta por um par a mais |
| Custo médio, mediano e desvio | Quanto custa a pergunta típica e a cara | Orçar pela média e estourar na cauda |
| Latência mediana e percentil 95 | Espera típica e espera ruim | Prometer ao cliente o tempo da execução boa |
| Subchamadas por pergunta | Quantas vezes o modelo raiz delegou | Explosão de chamadas sem aviso |
| Evidência rastreável | Resposta com documento citado que a sustenta | Acerto por sorte que Helena não consegue assinar |
Fonte: Veredas Ambiental, cenário composto; métricas de custo e latência seguem o artigo RLM v3 (maio de 2026)
Os limiares foram cinco. O RLM precisa somar pelo menos 15 acertos a mais que o RAG em agregação e cruzamento, onde o RAG faz 28 de 80. Não pode cair abaixo de 34 de 40 em localização, dois a menos que os 36 do RAG. O custo médio fica em até US$ 1,50 por pergunta, o que limita uma rodada completa a US$ 180 (120 vezes 1,50). A pior execução não passa de 20 minutos. Toda resposta dada como certa cita pelo menos um documento.
- Etapa 1 de 6: Congelar o conjunto
120 perguntas, referências de Helena e definição de “vencida”
- Etapa 2 de 6: Assinar os limiares
Cinco critérios com número, antes de qualquer execução
- Etapa 3 de 6: Rodar os três braços
RAG, contexto longo onde couber e RLM de profundidade 1
- Etapa 4 de 6: Repetir o cruzamento
As 30 perguntas rodam duas vezes para medir a variação
- Etapa 5 de 6: Auditar a evidência
Helena confere o documento citado em cada acerto
- Etapa 6 de 6: Decidir pelos limiares
Passa, passa com ressalva ou volta para ajuste
Repetir as 30 perguntas de cruzamento responde a uma lição do artigo: trajetórias de RLM têm variância alta, e uma rodada única pode ter caído no lado bom ou no ruim da cauda. Com duas rodadas, Caio consegue dizer se uma diferença de três ou quatro perguntas é método ou sorte.
Helena acrescentou uma regra para o resultado intermediário. Se o RLM passar em quatro limiares e falhar por pouco no quinto, a decisão é “passa com ressalva”: o piloto segue restrito ao tipo de pergunta em que o ganho apareceu, e o limiar que falhou vira meta da rodada seguinte. Sem essa regra, um custo de US$ 1,55 por pergunta derrubaria um método que dobrou o acerto em cruzamento, e ninguém quer uma régua que decide por centavos.
A Veredas agora tem um protocolo que cabe numa página e que Helena assinou antes de ver qualquer número. Escreva o seu no mesmo formato: braços, métricas e limiares com número. Ele está pronto quando cada limiar puder ser checado por outra pessoa sem perguntar nada a você; o próximo passo é instalar a biblioteca oficial e preparar o acervo para o primeiro braço recursivo.
Seu caderno neste capítulo
Abrir o caderno completoSelecione um trecho do capítulo para destacar ou anotar. No teclado, selecione com Shift e as setas e use Alt+Shift+D para destacar ou Alt+Shift+N para anotar.
Salvo neste navegador. Entre na sua conta para levar o caderno a outros aparelhos.
Entre na sua conta para compartilhar o que aprendeu e convidar alguém para estudar com você.
Voltar ao capítulo anterior: Julgar um benchmark antes de acreditar no número dele
Todos os capítulos de RLM 2027
- 01Descobrir onde o modelo encontra cada informação que usa
- 02Medir o limite real do contexto e dividir o problema
- 03Guardar o acervo numa variável e deixar o modelo programar a leitura
- 04Desenhar a árvore de chamadas e decidir a profundidade
- 05Explorar o acervo antes de decidir onde cortar
- 06Processar as partes e juntar as respostas sem perder a evidência
- 07Comparar contexto longo, RAG e compactação antes de escolher o RLM
- 08Situar agentes, híbridos e RLM numa matriz de decisão
- 09Julgar um benchmark antes de acreditar no número dele
- 10Comparar métodos nas mesmas condições e ler os resultados contrários
- 11Preparar o acervo e rodar a biblioteca oficial rlm
- 12Montar o protótipo com dspy.RLM e auditar o rastro de cada resposta
- 13Decompor o custo de uma execução e pôr teto em cada parte
- 14Baixar o custo por pergunta e vigiar o que a média esconde
- 15Isolar o código gerado e tratar cada documento como dado
- 16Impedir que o erro de uma folha chegue à resposta final
- 17Treinar um modelo pequeno para decidir quando delegar
- 18Provar uma auto-melhoria antes de acreditar nela
- 19Julgar as apostas de recursão aprendida e execução previsível
- 20Mapear híbridos, imagem e trabalho prolongado com evidência e lacuna
- 21Ler 2027 por sinais observáveis em vez de apostar numa previsão
- 22Escolher onde o RLM entra primeiro e decidir o piloto
- 23Definir o problema e construir quatro alternativas comparáveis
- 24Avaliar as alternativas e dizer em quais condições o RLM compensa