Os 6 desafios em aberto da engenharia de contexto (Harrison Chase)

Os 6 desafios em aberto da engenharia de contexto (Harrison Chase)
6técnicas de contexto que já são quase padrão
6desafios que, segundo Chase, continuam totalmente em aberto
+1,5 anodesde o lançamento do Claude Code, talvez o primeiro exemplo famoso dessa arquitetura
6 open challenges for AI agents (Harrison Chase, LangChain)
Também explico isso neste vídeo, em inglês, no meu canal Articulator EN. Este vídeo não tem versão em português, mas você pode ativar as legendas traduzidas automaticamente. As figuras deste post são fotogramas desse vídeo, por isso estão em inglês.

Todos chegam à mesma arquiteturalink

Chase começa com uma observação: parece que todo mundo está convergindo para a mesma arquitetura de agente. Um modelo de linguagem que roda em loop, chama ferramentas e é executado dentro de um ambiente isolado (um sandbox), para que o que ele executa não quebre nada lá fora.

O padrão não é novo. O Claude Code, que ele aponta como talvez a primeira manifestação famosa dessa arquitetura, saiu há mais de um ano e meio. O Deep Agents, o harness de agentes do LangChain, foi lançado há mais de um ano. A ideia vem se firmando há algum tempo.

O loop de um agente: o modelo pensa, chama uma ferramenta, olha o resultado e recomeça, dentro de um sandbox
A arquitetura em que todo mundo está chegando.
Um modelo de linguagem em loop que chama ferramentas dentro de um ambiente isolado
A arquitetura a que todos estão chegando: um modelo em loop, ferramentas e um ambiente isolado.

Essa convergência não é ruim em si. Mas, segundo ele, criou uma sensação entre alguns engenheiros com quem conversou: que «todos os problemas difíceis estão resolvidos», que não sobram problemas novos de engenharia de IA. Construir agentes teria ficado chato.

O que já está mais ou menos resolvidolink

Para Chase, quem diz isso está falando principalmente de engenharia de contexto: tudo o que fazemos para que o modelo tenha à frente a informação certa em cada passo. E, em parte, tem razão: há um punhado de soluções «quase padrão» a que todos chegamos. Ele lista seis:

  • Resumir as conversas longas quando elas já não cabem na janela de contexto: a parte antiga é resumida e o agente continua trabalhando a partir desse resumo.
  • Tirar do contexto os resultados grandes das ferramentas: se uma chamada devolve milhares de linhas, elas são salvas em um arquivo e o modelo só vê uma referência e uma prévia.
  • Skills, para revelar a informação aos poucos: o agente vê o nome e uma linha de cada habilidade, e só carrega as instruções completas quando precisa delas.
  • Busca de ferramentas quando há muitíssimas: em vez de passar todas, o agente ganha um buscador para encontrar as que precisa.
  • Subagentes para isolar o contexto: o agente principal delega uma tarefa a outro, que trabalha com sua própria janela limpa e só devolve o resultado.
  • Bash como ferramenta principal: em vez de uma função sob medida para cada coisa, o agente escreve comandos em um terminal.

Atenção ao detalhe: Chase não diz que estão totalmente resolvidas. Ele as chama de soluções «quase padrão» e, na figura dele, a coluna se chama Mostly solved, «mais ou menos resolvido». Ao lado ele desenha outra coluna, Wide open, com seis desafios que continuam completamente em aberto.

Duas colunas: o que está mais ou menos resolvido e o que está totalmente em aberto
A figura do artigo, redesenhada: seis técnicas quase padrão e seis desafios em aberto.
Duas colunas: seis técnicas mais ou menos resolvidas e seis desafios totalmente em aberto
A figura do artigo, redesenhada: seis técnicas quase padrão contra seis desafios em aberto.

O salto: agentes proativos e sempre ligadoslink

A boa notícia, para um fã de engenharia de contexto como ele, é que ele acha que estamos vendo um salto no que os agentes conseguem fazer, ou pelo menos em como eles estão sendo usados. Nos últimos meses, todos os construtores de agentes com quem conversou estão pensando na mesma coisa: agentes proativos, sempre ligados e orientados a objetivos.

Por dentro eles se parecem muito com os agentes de programação, mas trazem desafios novos. E aqui Chase é claro: nem o LangChain nem o resto do setor têm soluções para eles ainda, ou pelo menos não soluções gerais. Ele diz que pensar nisso foi a coisa mais divertida que fez em muito tempo. São estes seis.

1. Proativo sem ser chatolink

Esses agentes trabalham em segundo plano. Ou escutam um fluxo de eventos (e-mails, mensagens que chegam…) ou acordam de tempos em tempos com um batimento, um heartbeat, para ver se há algo a fazer.

O problema é quando falar com você. Por um lado, eles precisam conseguir avisar você por conta própria: é isso que dá a sensação de que estão ajudando. Por outro, se mandam notificações demais, sobrecarregam você. Calibrar isso para que seja uma experiência agradável, nem demais nem de menos, ainda é para Chase um desafio difícil de engenharia de contexto.

Um celular cheio de notificações de um agente
Notificações demais sobrecarregam: o desafio é achar o ponto certo.
Um agente proativo que avisa demais e sobrecarrega o usuário
Nem tão poucos avisos que não pareça que ajuda, nem tantos que sobrecarreguem.

2. Memória: o que lembrarlink

Segundo Chase, os sistemas de memória dos agentes acabam tendo duas partes:

  • A estrutura de dados por baixo, que costuma ser simples: alguns arquivos, ou até um único texto.
  • Uma camada de inteligência em volta, que é um agente.

O difícil está nessa camada e, sobretudo, em decidir o que lembrar. Assim como com os avisos, é fácil errar para qualquer um dos dois extremos: não lembrar nada ou guardar detalhes granulares demais. E como quem decide o que guardar costuma ser, por sua vez, um agente simples, a engenharia de contexto sobre o que anotar e quando continua sendo um problema em aberto.

A memória em duas partes: uma estrutura de dados simples e uma camada de inteligência, um agente, que decide o que guardar
As duas partes de um sistema de memória.
A memória de um agente: uma estrutura de dados simples e um agente que decide o que guardar
A estrutura é simples; o difícil é decidir o que entra nela.

3. Trabalho assíncronolink

Os agentes rodam por cada vez mais tempo e conversam com ferramentas e com outros agentes que também demoram cada vez mais. Mas quase sempre você quer que o agente principal, o que fala com você, continue respondendo às suas mensagens novas.

Juntando as duas coisas, chega-se a uma arquitetura em que cada vez mais trabalho é feito em ferramentas assíncronas e subagentes: o principal dispara uma tarefa, segue com o que estava fazendo e, em algum momento, o resultado volta. E aí aparecem as perguntas:

  • Como você avisa o agente principal de que esse trabalho terminou?
  • O que você faz se o principal ainda está rodando, ou se ele já tinha terminado?
  • E se ele está pausado, esperando que uma pessoa aprove algo?
Linha do tempo: o agente principal rodando, concluído e pausado esperando o usuário, com um subagente e uma ferramenta assíncrona devolvendo o resultado
A figura da linha do tempo, redesenhada: como avisar o agente principal em cada caso?
Cronograma: o agente principal rodando, terminado e pausado, e os resultados de um subagente e de uma ferramenta assíncrona que voltam
O esquema do artigo, redesenhado: o resultado pode voltar enquanto o principal roda, quando ele já terminou ou quando está esperando o usuário.

4. Perseguir objetivoslink

Os agentes estão passando de fazer tarefas para trabalhar em direção a metas; Chase cita o Hone como um ótimo exemplo. A pergunta é como projetar agentes que dividam uma meta em passos menores, façam experimentos, recebam feedback e continuem iterando em direção a algo maior. O que é difícil, segundo ele:

  • Fazer com que testem experimentos novos em busca da meta, em vez de repetir a mesma coisa.
  • Fazer com que pensem em objetivos amplos, e não só em tarefas pequenas.
  • Mantê-los coerentes ao longo de horizontes de tempo longos.

5. Alinhamentolink

Muito ligado ao anterior. Projetar um objetivo já é difícil por si só, e Chase acha que vai ser muito difícil para os usuários projetar objetivos em que o agente não consiga trapacear. Se um agente otimiza uma meta às cegas, pode ser que a cumpra, mas por caminhos que não conseguimos prever.

O exemplo dele é o clássico (uma ilustração do que se chama specification gaming, não algo que ele diga ter acontecido): você pede «elimine todos os bugs do código» e o agente apaga o código inteiro. Sem código, sem bugs. Objetivo cumprido.

Terminal: goal: get rid of all bugs in the codebase, rm -rf src/, npm test, 0 bugs found, goal complete
O exemplo clássico: sem código, sem bugs.
Terminal: o objetivo de eliminar todos os bugs, o agente apaga o código e declara zero bugs
O exemplo clássico: o objetivo é cumprido ao pé da letra, e o código desaparece.

A pergunta que fica: como projetar um harness que mantenha o agente focado nas suas metas, mas sem otimizá-las demais?

Para os agentes de programação, a ferramenta mais importante era o bash, que deixa executar código. Para muitos desses agentes de uso geral, segundo Chase, essa ferramenta está passando a ser o navegador. E pilotar um navegador é muito mais complicado do que pilotar um terminal.

O agente interage com imagens da página (capturas de tela) ou com o DOM, a árvore de elementos? As duas coisas são objetos grandes, então como você gerencia o contexto com isso? E, como ele diz, essas são só algumas das perguntas que aparecem.

Uma captura de tela ao lado da árvore do DOM, as duas grandes demais para o contexto
Capturas ou DOM? Os dois são objetos enormes.
Uma página web: capturas de tela ou a árvore de elementos?
Capturas de tela ou DOM? As duas coisas são enormes para a janela de contexto.

Em resumolink

Chase reconhece que, há alguns meses, talvez tivesse concordado que não sobravam muitas perguntas em aberto na engenharia de contexto. Mas com os agentes proativos e sempre ligados aparece todo um conjunto de desafios novos: avisar sem sobrecarregar, decidir o que lembrar, coordenar o trabalho assíncrono, perseguir objetivos, não trapacear e pilotar o navegador. Nenhum deles tem ainda uma solução geral. Como ele fecha: «que época para estar vivo».

Em uma frase

A arquitetura de agentes convergiu, mas os agentes proativos abriram seis problemas novos de contexto.

Qual desses desafios parece mais difícil para você?

Fonteslink

Continuar lendo

Últimos posts -->

Você viu esses projetos?

Gymnasia

Gymnasia Gymnasia
Expo
React Native
TypeScript
OpenAI
Anthropic

App de fitness com dois agentes que são executados integralmente no dispositivo, sem backend, de forma que os dados do usuário nunca saem do celular. Um coach conversacional BYOK com tools locais e system prompt remoto com fallback offline, e um estimador de refeições que tira os macronutrientes de uma foto do prato, com leitura de códigos de barras contra o OpenFoodFacts.

LangGraph Deep Researcher

LangGraph Deep Researcher LangGraph Deep Researcher
Python
LangGraph
FastAPI
React
TypeScript
Docker

Sistema multiagente de pesquisa construído com LangGraph. Um supervisor decompõe sua pergunta em tópicos e lança subagentes de busca em paralelo; cada um comprime seus achados antes de repassá-los a um agente redator que escreve o relatório final em markdown com suas fontes. Streaming ao vivo por WebSockets, modelo configurável por papel e chaves de API próprias que nunca são armazenadas no servidor.

Tau

Tau Tau
Python
LangChain

Sistema multiagente de tutoria para estudantes do ensino médio, com um agente por disciplina e material de curso elaborado e validado por uma equipe de professores. Chegou a ser usado com alunos reais em um colégio privado na Espanha e em uma escola de ensino médio na Colômbia.

Ver todos os projetos -->
>_ Disponível para projetos

Tem um projeto com IA?

Vamos conversar.

maximofn@gmail.com

Especialista em Machine Learning e Inteligência Artificial. Desenvolvo soluções com IA generativa, agentes inteligentes e modelos personalizados.

Quer assistir alguma palestra?

Últimas palestras -->

Quer melhorar com essas dicas?

Últimos tips -->

Use isso localmente

Os espaços do Hugging Face nos permitem executar modelos com demos muito simples, mas e se a demo quebrar? Ou se o usuário a deletar? Por isso, criei contêineres docker com alguns espaços interessantes, para poder usá-los localmente, aconteça o que acontecer. Na verdade, se você clicar em qualquer botão de visualização de projeto, ele pode levá-lo a um espaço que não funciona.

Flow edit

Flow edit Flow edit

Edite imagens com este modelo de Flow. Baseado em SD3 ou FLUX, você pode editar qualquer imagem e gerar novas

FLUX.1-RealismLora

FLUX.1-RealismLora FLUX.1-RealismLora
Ver todos os contêineres -->
>_ Disponível para projetos

Tem um projeto com IA?

Vamos conversar.

maximofn@gmail.com

Especialista em Machine Learning e Inteligência Artificial. Desenvolvo soluções com IA generativa, agentes inteligentes e modelos personalizados.

Você quer treinar seu modelo com esses datasets?

short-jokes-dataset

HuggingFace

Dataset com piadas em inglês

Uso: Fine-tuning de modelos de geração de texto humorístico

231K linhas 2 colunas 45 MB
Ver no HuggingFace →

opus100

HuggingFace

Dataset com traduções de inglês para espanhol

Uso: Treinamento de modelos de tradução inglês-espanhol

1M linhas 2 colunas 210 MB
Ver no HuggingFace →

netflix_titles

HuggingFace

Dataset com filmes e séries da Netflix

Uso: Análise de catálogo Netflix e sistemas de recomendação

8.8K linhas 12 colunas 3.5 MB
Ver no HuggingFace →
Ver mais datasets -->