Do MIT ao Prime Intellect modelos de linguagem recursivos aumentam a capacidade da IA para lidar com contextos muito longos

Aqui, você vai ver como os Modelos de Linguagem Recursivos (RLMs) mudam a forma de lidar com textos enormes. Em vez de forçar o modelo a ler tudo de uma vez, eles tratam o texto como um ambiente e deixam o modelo escrever código no REPL para fatiar, buscar e chamar submodelos menores. O texto apresenta o Blueprint do MIT e a implementação RLMEnv da Prime Intellect, mostra ganhos fortes em precisão e custo em tarefas muito longas e explica o que ainda precisa ser afinado para esses agentes de longo prazo.

• RLMs deixam o modelo buscar e ler pedaços do texto em vez de ler tudo de uma vez

• O modelo principal escreve código no REPL para dividir, filtrar e resumir o conteúdo

• A abordagem aumenta muito a precisão em tarefas com contexto muito longo

• RLMEnv da Prime Intellect separa ferramentas pesadas e delega trabalho a submodelos

• A técnica ainda precisa de ajuste para reduzir custo, profundidade e execuções longas

RLMs e RLMEnv: como modelos recursivos estendem o contexto dos LLMs

Pesquisadores e a equipe da Prime Intellect desenvolveram métodos que transformam o problema do contexto longo em um problema de programação. Resultados iniciais mostram ganhos relevantes em precisão e custo em tarefas que exigem leitura e raciocínio sobre grandes volumes de texto, alinhando-se às práticas de engenharia de contexto para modelos de linguagem.

O que são os Recursive Language Models (RLMs)

• RLMs tratam o texto completo como um ambiente externo.

• O modelo raiz não recebe toda a entrada em seu contexto; em vez disso, recebe instruções para inspecionar fatias do texto via REPL (geralmente Python).

• O modelo escreve código que chama submodelos menores, realiza buscas e resume partes, combinando os resultados em uma resposta final — aproveitando avanços em arquiteturas compactas e de especialistas, como variantes Mixture-of-Experts (MoE) e modelos otimizados para contexto longo.

• Assim, o tamanho do prompt deixa de depender diretamente da janela de contexto do modelo, uma ideia explorada em textos sobre tokenização e chunking.

Como funciona na prática

• A entrada completa é guardada em uma variável no REPL.

• O modelo raiz recebe um prompt de sistema que descreve como usar funções como string slicing, regex e llm_query.

• Ele cria funções auxiliares, faz chamadas recursivas a submodelos e armazena saídas intermediárias em variáveis — um fluxo que lembra abordagens híbridas entre RAG tradicional e métodos agentic, discutidos em posts sobre agentic RAG.

• No final, o sistema retorna texto normal, mantendo a interface igual a um endpoint de chat.

Resultados em benchmarks principais

A pesquisa avaliou quatro benchmarks projetados para testar recuperação e raciocínio em longo prazo. Resumo dos ganhos:

Benchmark	Tipo de tarefa	Desempenho base	Desempenho RLM
S-NIAH	Agulha no palheiro (constante)	Baixo	Muito melhor
BrowseComp-Plus	Perguntas multi-hop sobre até 1.000 doc.	Cai com mais docs	Mantém alta precisão (~91.33% com GPT-5)
OOLONG	Transformação linear e agregação	Moderado	Grande ganho
OOLONG Pairs	Agregação quadrática (pares)	Quase inútil em base	RLM alcança F1 alto (ex.: 58.00 para GPT-5)

• Em Q&A sobre documentos longos (CodeQA), GPT-5 passou de ~24% (chamada direta) para 62% com RLM; outra variante sem recursão chegou a 66%.

• Em tarefas quadráticas (OOLONG Pairs), ganhos foram dramáticos: modelos diretos tiveram F1 quase zero; RLM trouxe recuperação substancial.

• No BrowseComp-Plus, RLM manteve desempenho com 1.000 documentos e custos por consulta competitivos (~$0.99 por consulta com GPT-5), com estratégias que podem ser combinadas com técnicas de cache semântico para reduzir latência e preço por chamada.

Comportamento observado nas execuções

Execuções típicas seguem passos repetidos:

• Vislumbre inicial das primeiras milhares de caracteres.

• Filtragem tipo grep com regex ou palavras-chave.

• Partição do texto e chamadas recursivas para rotular/extrair — um processo que depende fortemente de boas estratégias de chunking.

• Agregação programática dos resultados.

Para saídas longas, o sistema salva pedaços em variáveis e junta depois, evitando limites de saída do modelo.

O que a Prime Intellect implementou: RLMEnv

• A empresa converteu a ideia em um ambiente prático chamado RLMEnv, integrado ao seu stack de verificação.

• No projeto, o modelo raiz só tem acesso ao REPL; submodelos recebem ferramentas pesadas (busca web, acesso a arquivos).

• O REPL oferece uma função llm_batch para disparar várias consultas em paralelo e uma variável answer onde o resultado final deve ser escrito.

• Testes em quatro ambientes:

• DeepDive: pesquisa web com páginas longas.

• Math Python: problemas matemáticos complexos com REPL.

• Oolong: benchmark de contexto longo adaptado.

• Verbatim Copy: reprodução exata de strings complexas (JSON, CSV, código).

• Modelos menores como GPT-5-mini e variantes MoE (ex.: INTELLECT-3-MoE) ganharam em taxa de sucesso e robustez a contextos muito grandes — resultados complementares a iniciativas de memória e agentes persistentes, como as descritas no post sobre memória persistente em SQL e em textos sobre como estender memória de agentes.

Limitações atuais e próximos passos

Implementações atuais ainda não estão otimizadas. Problemas relatados:

• Chamadas síncronas que aumentam latência.

• Profundidade de recursão limitada.

• Distribuição de custo com caudas pesadas por trajetórias muito longas.

Pesquisadores indicam que treinar políticas via aprendizado por reforço e técnicas aninhadas pode reduzir custo e tornar o método mais eficiente — temas próximos aos artigos sobre aprendizagem aninhada e propostas de nested learning. Outras abordagens práticas para escalar e reduzir memória incluem técnicas de inferência distribuída e otimizações apresentadas em posts sobre escalabilidade com menos memória.

Se aperfeiçoado, o método pode permitir agentes que processem ambientes com milhões de tokens sem degradação rápida de contexto — uma evolução natural para arquiteturas que combinam chunking, memória persistente e políticas de decisão para chunking/recursão.

Conclusão

Os RLMs transformam textos enormes em um ambiente programável: o modelo escreve código no REPL, fatiando o conteúdo e delegando tarefas a submodelos. Os ganhos são palpáveis — maior precisão, redução de custo em tarefas de contexto muito longo e robustez comprovada em benchmarks difíceis. A implementação RLMEnv da Prime Intellect mostra que a teoria funciona na prática, embora ainda seja necessário otimizar latência, profundidade de recursão e trajetórias de custo.

Se bem afinado, esse método pode permitir agentes que processem milhões de tokens sem se perder — como um alfaiate que corta e costura o tecido do texto, peça por peça, até encaixar a resposta perfeita.

Quer se aprofundar? Leia mais em https://blog.aidirectory.com.br.

Perguntas frequentes (resumo)

• O que são modelos de linguagem recursivos (RLMs)?
  RLMs tratam textos grandes como um ambiente externo; o modelo raiz escreve código no REPL para fatiar, buscar e resumir pedaços, chamando submodelos e agregando respostas — uma técnica que complementa práticas de tokenização e chunking.

• Como o REPL permite ler contextos muito longos?
  O REPL guarda todo o input numa variável; o modelo principal inspeciona partes usando slice, regex e queries a submodelos, sem precisar carregar tudo no contexto — um padrão discutido em materiais sobre engenharia de contexto.

• Os RLMs realmente melhoram precisão e custo?
  Sim. Estudos mostram ganhos grandes em tarefas longas; em alguns benchmarks, RLMs dobraram ou mais a acurácia versus chamadas diretas e reduziram custos em cenários de muitos documentos. Técnicas de redução de custo, como cache semântico e paralelismo controlado, ajudam a manter latência e preço razoáveis.

• O que a Prime Intellect fez com o RLMEnv?
  Criou um REPL padrão, moveu ferramentas pesadas para submodelos, adicionou llm_batch para paralelismo e uma variável answer para isolar saídas grandes — um fluxo que pode se integrar a pipelines de RAG e agentes descritos em posts sobre RAG nativo vs RAG agente.

• Quais são limitações e próximos passos?
  Limitações atuais incluem latência por chamadas síncronas, limites de recursão e caudas de custo; próximo passo é treinar políticas (via RL) para otimizar chunking, recursão e uso de ferramentas, aproveitando ideias de aprendizagem aninhada e modelos com memória persistente.

Se você quiser conhecer outros artigos semelhantes a Do MIT ao Prime Intellect modelos de linguagem recursivos aumentam a capacidade da IA para lidar com contextos muito longos, você pode visitar a categoria Notícias e Tendências.