🤖 AI

Context as an Environment: Programmatic Context Management for Long-Horizon Agents

O artigo apresenta o Scroll, um sistema de gerenciamento de contexto programático que trata sessões de agentes como ambientes executáveis com um log de eventos de apenas adição e um kernel Python persistente, permitindo que LLMs gerenciem dinamicamente estados de longo horizonte por meio de código enquanto alcançam desempenho de estado da arte em benchmarks de contexto longo.

Autores originais: Yin Lin, Elaine Ang, Erkang Zhu, Bolin Ding, Jingren Zhou

Publicado 2026-08-25

📖 6 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Yin Lin, Elaine Ang, Erkang Zhu, Bolin Ding, Jingren Zhou

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine uma conversa que nunca termina. Você está conversando com um programa de computador muito inteligente, um que pode ajudá-lo a escrever código, planejar viagens complexas ou pesquisar tópicos profundos. No início, a conversa é fácil. O programa se lembra de tudo o que você disse nos últimos minutos. Mas conforme a conversa se estende por horas ou dias, a quantidade de informação cresce. Eventualmente, torna-se demais para o programa manter em sua memória imediata. No mundo da inteligência artificial, essa memória imediata é chamada de janela de contexto. É um tamanho fixo, como uma mesa que só pode conter um certo número de papéis. Quando a pilha de papéis fica muito alta, o programa deve descartar alguns para abrir espaço para novos.

O problema é que o programa não sabe quais papéis são importantes até que seja tarde demais. Se você fizer uma pergunta sobre algo que mencionou três dias atrás, o programa pode já ter descartado aquele papel. As soluções tradicionais tentam resolver isso tentando resumir os papéis antigos em uma nota curta ou selecionando alguns fatos para manter em um caderno separado. Mas esses métodos são arriscados. Se o programa descartar um detalhe específico, como uma data ou um número, esse detalhe se perde para sempre. Não pode ser recuperado. Para tarefas que exigem olhar para trás em um longo histórico para encontrar fatos exatos ou rastrear como uma situação mudou ao longo do tempo, perder um único detalhe pode fazer o programa falhar.

Uma equipe de pesquisadores propôs uma maneira diferente de lidar com essa conversa crescente. Eles chamam seu sistema de Scroll. Em vez de tentar encaixar todo o histórico na memória imediata do programa, eles tratam o histórico como um ambiente separado e permanente que o programa pode visitar sempre que precisar. Pense nisso como um arquivo vasto e organizado que fica logo fora da mesa do programa. O programa não lê todo o arquivo de uma vez. Em vez disso, ele escreve uma pequena instrução, como uma consulta de busca ou um comando, para ir ao arquivo, encontrar a página específica de que precisa e trazer apenas aquela página de volta para a mesa.

O núcleo deste sistema é um registro permanente de cada interação, chamado de Registro de Eventos (Event Log). Este registro é como um gravador de fita que nunca para, capturando cada mensagem, o resultado de cada ferramenta e cada decisão em detalhes exatos. Ele é armazenado com segurança fora da memória imediata do programa, de modo que nada seja perdido. Ao lado deste registro, há um espaço de trabalho persistente, uma espécie de caixa de areia digital onde o programa pode manter seus pensamentos e cálculos atuais. Quando o programa precisa se lembrar de algo do passado, ele não depende de um resumo. Ele escreve um código para pesquisar o Registro de Eventos, encontrar o momento exato que está procurando e carregar essa informação em seu espaço de trabalho.

Essa abordagem muda a forma como o programa pensa sobre sua própria memória. Em vez de adivinhar o que manter, o programa decide o que procurar no momento em que é necessário. Se o programa estiver planejando uma viagem e precisar se lembrar de uma preferência que o usuário mencionou semanas atrás, ele escreverá um comando para buscar essa preferência específica. Ele então carrega as palavras exatas que o usuário usou e as utiliza para tomar uma decisão. O programa traz apenas a informação necessária para sua visão imediata. O restante do histórico da conversa permanece guardado com segurança no arquivo, esperando para ser recuperado se o programa precisar dele mais tarde.

Para evitar que a visão imediata fique cheia demais, o sistema tem uma maneira de limpar informações antigas que não estão sendo usadas no momento. Quando o espaço de trabalho fica lotado, o sistema move as partes mais antigas da conversa de volta para o arquivo. No entanto, ao contrário de outros sistemas que podem deletar ou resumir essas partes antigas, o Scroll as mantém exatamente como são. Ele cria um pequeno mapa, um índice, que diz ao programa exatamente onde essas partes antigas estão armazenadas. Se o programa perceber mais tarde que precisa verificar uma conversa antiga, ele pode usar este mapa para saltar diretamente para o lugar certo e recuperar o texto original. Isso garante que o programa possa sempre voltar à fonte, mesmo que a informação não esteja mais em sua visão imediata.

Os pesquisadores testaram este sistema em vários desafios difíceis projetados para ver quão bem uma inteligência artificial consegue lidar com conversas longas. Em um teste, o sistema teve que responder perguntas baseadas em um histórico de mais de um milhão de palavras de conversa. Em outro, teve que agir como um agente que toma decisões ao longo de um longo período, usando ferramentas para reunir informações e resolver problemas. Os resultados mostraram que este novo método foi altamente eficaz. Em um teste medindo o quão bem o sistema conseguia lembrar e raciocinar sobre históricos longos, ele alcançou uma pontuação de 94,8 por cento. Em outro teste envolvendo dez milhões de palavras de histórico, ele obteve 73,1 por cento, o que é superior a qualquer outro sistema publicado anteriormente. Em um teste onde o sistema tinha que gerenciar um ambiente crescente enquanto resolvia tarefas complexas, atingiu 86,7 por cento, superando em muito os melhores resultados anteriores.

O sucesso deste sistema vem de sua capacidade de tratar a memória como uma tarefa de programação. Ao permitir que o programa escreva suas próprias instruções para encontrar e usar informações, o sistema aproveita a capacidade crescente do programa de escrever código. Ele não força o programa a comprimir seu histórico em um resumo que pode perder detalhes importantes. Em vez disso, dá ao programa as ferramentas para acessar o histórico completo e não editado sempre que necessário. Os pesquisadores descobriram que este método funciona bem em diferentes tipos de programas poderosos, sugerindo que a habilidade de gerenciar a memória de longo prazo através de código é uma habilidade geral que pode ser aprendida por vários sistemas.

Este trabalho sugere uma mudança na forma como construímos agentes inteligentes. Em vez de tentar tornar a memória imediata do programa maior ou melhor em resumir, podemos dar a ele acesso a um registro permanente e pesquisável de sua própria vida. O programa aprende a navegar neste registro, decidindo o que trazer para frente e o que deixar para trás. Isso mantém a visão imediata clara e focada, enquanto garante que a verdade total do passado esteja sempre disponível. Os pesquisadores acreditam que esta abordagem pode ajudar a inteligência artificial a lidar com tarefas ainda mais longas e complexas no futuro, permitindo que ela aprenda com um histórico muito mais profundo sem perder os detalhes que importam.

Resumo Técnico: Scroll – Gestão de Contexto Programática para Agentes de Longo Horizonte

1. Formulação do Problema

Tarefas de longo horizonte para agentes de Grandes Modelos de Linguagem (LLMs) — como engenharia de software em nível de repositório e pesquisa profunda na web — geram históricos de interação que excedem vastamente a janela de contexto de um único modelo. As soluções existentes baseiam-se primariamente em compressão de contexto (truncamento, sumarização ou descarte de intervalos obsoletos) ou memória externa (extração de fatos para um armazenamento separado). Ambas as abordagens são fundamentalmente perdedoras (lossy): elas se comprometem com o que a informação deve preservar antes que as necessidades futuras sejam conhecidas. Consequentemente, se uma sumarização falhar em capturar um detalhe específico ou se uma extração perder uma nuance, essa informação torna-se irrecuperável, mesmo que o registro bruto exista no disco. Essa limitação impede que os agentes realizem comparações históricas exatas ou computações não triviais sobre eventos passados onde a informação necessária não é conhecida de antemão.

2. Metodologia: O Framework Scroll

O artigo introduz o Scroll, um gestor de contexto que reformula o histórico da sessão não como texto a ser serializado em prompts, mas como um Ambiente de Sessão Executável. Este ambiente permite que o agente interaja programaticamente com seu próprio histórico.

Componentes Principais

Log de Eventos de Somente Adição ( $L_t$ ): Um registro durável e de verdade fundamental (ground-truth) de todas as interações (mensagens do usuário, respostas do modelo, chamadas de ferramenta, resultados). Cada evento recebe um endereço de sequência imutável e monotonicamente crescente (seq). O log é armazenado em SQLite, utilizando BM25 para busca de texto completo determinística em vez de embeddings.
Armazenamento Durável ( $P_t$ ): Os payloads brutos (ex: saídas completas de ferramentas, artefatos) são armazenados externamente (JSON, sistema de arquivos) e referenciados pelo Log de Eventos via handles diferidos. Isso garante que o log permaneça leve enquanto preserva a fidelidade total.
Kernel Python Persistente ( $V_t$ ): Um kernel Python isolado (sandboxed) que persiste entre as chamadas do modelo. Ele mantém um namespace tipado de variáveis residentes (objetos Python, DataFrames, handles diferidos). Crucialmente, computações intermediárias e resultados de ferramentas permanecem neste kernel e não são serializados no prompt, a menos que sejam explicitamente solicitados.

Interface Programática

O modelo constrói seu contexto escrevendo código executado dentro do kernel persistente. A interface, exposta via um objeto de capacidade ms, fatia a construção do contexto em quatro operações:

LOCATE: ms.search(query, k, ...) encontra registros candidatos no Log de Eventos via busca de texto completo e filtros estruturados, retornando endereços seq estáveis.
MATERIALIZE: ms.expand(seq) recupera turnos ou intervalos exatos e carrega payloads externos como objetos Python.
COMPUTE: O modelo realiza filtragem, junção, agregação e derivação usando Python padrão e interfaces de banco de dados permitidas sobre variáveis residentes.
EXPOSE: print(value) é o único mecanismo que atravessa a fronteção para a visão de trabalho do modelo. Apenas projeções explicitamente impressas entram no próximo contexto do modelo.

Expulsão e Navegação

À medida que a visão de trabalho se aproxima do orçamento de tokens, o Scroll emprega um procedimento de expulsão que remove intervalos obsoletos da visão, mas nunca do Log de Eventos.

Recuperabilidade: Eventos expulsos permanecem na íntegra no Log de Eventos.
Índice de Expulsão: Para evitar a necessidade de buscas em todo o log, o Scroll mantém um índice em camadas de "manchetes" (headlines: tarefa, estado, próxima ação) para os intervalos expulsos. Este índice permite que o agente navegue diretamente para regiões expulsas usando âncoras de endereço, consolidando entradas mais antigas em intervalos mais amplos para manter a complexidade $O(k \log k n)$ .

3. Principais Contribuições

O artigo apresenta três contribuições primárias:

Política de Seleção Diferida: Ao contrário dos métodos existentes que fixam o mapa de contexto antes que as necessidades futuras sejam conhecidas, o Scroll difere a seleção da visão de trabalho para o tempo de consulta. O modelo escreve um programa $\pi_t$ em cada etapa para decidir o que recordar, computar e expor.
Substrato de Contexto Executável: A implementação de um kernel Python persistente e isolado combinado com um Log de Eventos de somente adição. Isso desloca a gestão de contexto de processamento de texto para programação, aproveitando as habilidades de codificação do LLM para pesquisar, transformar e materializar o estado.
Algoritmo de Navegação Sem Perdas: Um mecanismo de expulsão que mantém a visão de trabalho limitada sem perder o histórico. Os intervalos expulsos permanecem intactos e são indexados por entradas compactas ancoradas por endereço, permitindo que o agente navegue diretamente para regiões expulsas em vez de pesquisar todo o log.

4. Resultados Experimentais

Os autores avaliaram o Scroll utilizando o Qwen3.8-Max como backbone através de três benchmarks:

LongMemEvalS (Recuperação de Memória de Longo Prazo): O Scroll alcançou 94,8% de precisão, performando competitivamente com sistemas de estado da arte.
BEAM10M (Histórico de 10M de Tokens): O Scroll alcançou 73,1%, superando o melhor sistema de memória publicado em 5,1 pontos. Destacou-se notavelmente em categorias que exigem evidência histórica exata, como atualização de conhecimento (92,5%) e resolução de contradição (88,1%), onde a sumarização perdedora tipicamente falha.
LOCA256K (Atuação de Longo Horizonte): O Scroll alcançou 86,7% de precisão. Em comparação direta com outras estratégias de gestão de contexto usando o mesmo backbone, o Scroll demonstrou estabilidade superior conforme o contexto crescia, com uma queda de apenas 2,6% de 128K para 256K tokens, comparado a quedas de ~21% para agentes de sumarização e recuperação.

Estudos de Ablação confirmaram que o Log de Eventos sem perdas é crítico (a remoção causou uma queda para ~20% no BEAM10M), o kernel persistente melhora o desempenho em 7,3 pontos ao permitir agregação dentro do kernel, e o índice de expulsão fornece um ganho de 1,8 ponto ao auxiliar a navegação em históricos dispersos.

Eficiência de Custo: O Scroll expõe apenas uma pequena fração do corpus ao modelo. No BEAM10M, a contagem mediana de tokens de entrada foi de ~105K (aproximadamente 1% do corpus), com tokens de saída uma ordem de magnitude menor.

5. Significância e Alegações

O artigo alega que o Scroll muda fundamentalmente a gestão de contexto de um problema de compressão para uma tarefa de programação. Ao tratar a sessão como um ambiente executável, o agente herda as capacidades de codificação em evolução dos LLMs para gerir seu próprio contexto dinamicamente.

Os autores enfatizam que o Scroll não dita qual estado manter ou como escrever o código de recuperação; essas decisões são deixadas para o modelo. Essa flexibilidade permite que o sistema escale com as capacidades do modelo. O artigo sugere que trajetórias bem-sucedidas podem ser destiladas de modelos de fronteira para modelos menores via ajuste fino supervisionado, mantendo os mecanismos de contexto subjacentes fixos.

O trabalho postula que, para tarefas de longo horizonte que exigem evidência histórica exata ou computação complexa sobre eventos passados, a recuperação sem perdas via acesso programático é superior à sumarização pré-computada ou stores de memória fixos, pois evita a perda irrecuperável de informação inerente aos paradigmas de compressão atuais.