Anthropic · Applied AI · 2026
Apresentação Técnica
Volume 02 — Série Harness & Contexto
§ 00 — FRONTISPÍCIO

Context
Engineering.

A disciplina de curar, dinamicamente, o conjunto de tokens que entra na janela de contexto de um LLM — para que agentes operem de forma coerente ao longo de horas, não apenas minutos.
Fonte primária

Effective context engineering for AI agents. Prithvi Rajasekaran, Ethan Dixon, Carly Ryan & Jeremy Hadfield — Anthropic Applied AI Team.

Audiência

Italo — engenheiro sênior operando o ecossistema AIOX/Synkra. Complemento conceitual à pesquisa sobre harness design.

Escopo

Cobertura integral do ensaio original. Nenhuma seção omitida. Analogias concretas acompanham cada conceito técnico, sem substituí-lo.

§ 01 — ÍNDICE

Sumário.

§ 02 Introdução
Prompt · Context · Engineering

De prompt engineering para context engineering.

Depois de alguns anos em que o prompt engineering ocupou o centro das atenções da IA aplicada, um novo termo ganhou proeminência: context engineering. Construir com modelos de linguagem deixou de ser uma questão de encontrar as palavras certas para o prompt; passou a ser uma pergunta mais ampla — "qual configuração de contexto é mais provável de gerar o comportamento desejado?"

Contexto, aqui, é o conjunto de tokens incluídos no momento de amostragem de um LLM. O problema de engenharia em pauta é otimizar a utilidade desses tokens contra as limitações inerentes ao modelo — de modo a atingir, consistentemente, o resultado desejado. Operar LLMs com eficácia exige pensar em contexto: considerar o estado holístico disponível ao modelo em qualquer instante e que comportamentos ele pode produzir.

Prompt engineering é como escrever a lista de compras perfeita antes de ir ao mercado. Context engineering é arrumar a cozinha antes de começar a cozinhar: a tábua está limpa, a faca está ao lado, os temperos que a receita pede estão na bancada, a panela certa está no fogão. A lista pode estar perfeita; se a cozinha está uma bagunça, o almoço atrasa e sai pior.

Na Anthropic, tratamos context engineering como a progressão natural do prompt engineering. Enquanto prompt engineering foca em como escrever instruções efetivas — especialmente system prompts — context engineering cobre o conjunto de estratégias para curar e manter o conjunto ótimo de tokens (informação) durante a inferência: system instructions, tools, MCP (Model Context Protocol), dados externos, message history, e tudo o mais que possa cair na janela.

Nos primórdios da engenharia com LLMs, prompting era o componente central: a maioria dos casos de uso fora do chat cotidiano precisava de prompts otimizados para classificação one-shot ou geração de texto pontual. À medida que construímos agentes mais capazes, operando em múltiplos turnos e horizontes longos, precisamos de estratégias para gerenciar o estado de contexto inteiro.

Um agente rodando em loop gera, a cada turno, mais dados que poderiam ser relevantes para o próximo turno — e essa informação precisa ser ciclicamente refinada. Context engineering é a arte e ciência de curar o que entra na janela limitada de contexto a partir desse universo de informação em constante evolução.

§ 03 Fundamento
Context Rot · Attention Budget

Por que context engineering
é essencial para agentes capazes.

Apesar de sua velocidade e capacidade crescente de lidar com volumes maiores de dados, LLMs — como humanos — perdem o foco ou entram em confusão após certo ponto. Estudos em benchmarks do tipo needle-in-a-haystack descobriram um fenômeno que ficou conhecido como context rot, documentado pela pesquisa da Chroma: conforme o número de tokens na janela de contexto aumenta, a capacidade do modelo de recuperar informação corretamente diminui.

Context rot = "apodrecimento do contexto". É o WhatsApp com 5 mensagens não lidas: você abre, lê, responde cada uma. Agora imagine 500 não lidas em um grupo só. Mesmo que a mensagem importante da sua mãe esteja ali, você rola, rola, desiste — e mais tarde nem lembra que passou por ela. A informação está lá. Mas a atenção colapsa antes de chegar.

Alguns modelos exibem degradação mais suave que outros — mas a característica emerge em todos. Contexto, portanto, deve ser tratado como um recurso finito com retornos marginais decrescentes. Assim como humanos têm capacidade limitada de memória de trabalho, LLMs têm um "attention budget" — um orçamento de atenção — do qual sacam ao processar grandes volumes de contexto. Cada novo token introduzido deprecia esse orçamento em alguma medida, aumentando a necessidade de curar com cuidado o que é disponibilizado ao modelo.

Attention budget = mochila de estudante no dia da prova. Cabe exatamente o necessário: caderno, estojo, lanche, garrafa de água — e ainda sobra espaço pra uma caneta reserva. Se você tentar enfiar todo o material da escola na mesma mochila, o zíper não fecha e, pior, na hora da prova você não acha a caneta no meio do caos. Atenção é esse espaço: finito, e cada item a mais empurra outro pra margem.

A raiz arquitetural da escassez

Essa escassez de atenção deriva de restrições arquiteturais dos LLMs. Eles são baseados na arquitetura transformer, que permite que cada token atenda a todos os outros tokens em toda a extensão do contexto (attention is all you need). Isso resulta em n² relações pareadas para n tokens.

Tokens
n
Pares de atenção
Implicação
Dobrar o contexto quadruplica o custo de modelagem das relações.

À medida que o comprimento do contexto cresce, a capacidade do modelo de capturar essas relações pareadas fica esticada, criando uma tensão natural entre tamanho do contexto e foco de atenção. Além disso, modelos desenvolvem seus padrões de atenção a partir de distribuições de dados de treino nas quais sequências mais curtas são tipicamente mais comuns do que sequências longas — o modelo tem menos experiência, e menos parâmetros especializados, para dependências em escala de contexto inteiro.

Técnicas como position encoding interpolation permitem que modelos lidem com sequências mais longas adaptando-as ao contexto menor originalmente treinado — com alguma degradação na compreensão de posição do token.

Esses fatores criam um gradiente de performance — não um penhasco. Modelos continuam altamente capazes em contextos longos, mas podem mostrar precisão reduzida para recuperação de informação e raciocínio de longo alcance em comparação com contextos curtos.

Essas realidades tornam context engineering thoughtful uma exigência, não um luxo, para construir agentes capazes.

§ 04 Anatomia
Prompts · Tools · Examples · History

A anatomia do contexto
efetivo.

Dado que LLMs são restringidos por um orçamento finito de atenção, bom context engineering significa encontrar o menor conjunto possível de tokens de alto sinal que maximize a probabilidade de algum resultado desejado. Implementar essa prática é muito mais fácil dito do que feito — o que se segue é como esse princípio orientador se materializa em cada componente.

01

System prompts componente

System prompts devem ser extremamente claros e usar linguagem simples e direta, apresentando ideias na altitude certa para o agente. A altitude certa é a zona Goldilocks entre dois modos comuns de falha.

Extremo A — Rigidez

Engenheiros hardcodam lógica complexa e frágil em prompts para elicitar comportamento agentico exato. Resultado: fragilidade e complexidade crescente de manutenção.

Extremo B — Vagueza

Engenheiros fornecem orientação vaga ou de alto nível demais, falha em dar sinais concretos, ou falsamente presume contexto compartilhado.

Zona Goldilocks = a rubrica de redação do ENEM. Imagine um corretor que só recebesse "essa redação é boa?" — ele daria notas erráticas, humor do dia manda. Agora imagine um manual que obriga ele a contar cada vírgula: um erro de formatação e a redação zera. A rubrica certa fica no meio: cinco competências claras, cada uma com níveis — o mesmo corretor entrega notas consistentes e justas. System prompt ideal é essa rubrica: específica o bastante pra guiar; flexível o bastante pra caber redação boa que fugiu do script.

Recomenda-se organizar prompts em seções distintas — algo como <background_information>, <instructions>, ## Tool guidance, ## Output description — usando XML tagging ou Markdown headers para delinear, ainda que o formato exato venha se tornando menos relevante conforme os modelos ficam mais capazes.

Qualquer que seja a estrutura, o esforço deve ser pelo conjunto mínimo de informação que descreva o comportamento esperado. (Atenção: mínimo não é sinônimo de curto; ainda é preciso dar ao agente informação suficiente de saída para ele aderir ao comportamento desejado.) A melhor prática: começar com um prompt mínimo no melhor modelo disponível, observar performance na tarefa, e então adicionar instruções e exemplos para endereçar os failure modes encontrados.

# Esqueleto recomendado
<background_information>
  ...contexto de domínio mínimo e inequívoco...
</background_information>

## Instructions
  - objetivo primário (em uma linha)
  - heurísticas de decisão (3–7 regras)
  - casos limite canônicos (não todos)

## Tool guidance
  ...quando usar cada ferramenta; não duplicar docstring...

## Output description
  ...formato esperado, com 1 exemplo canônico...
02

Tools componente

Tools permitem que agentes operem no ambiente e puxem novo contexto conforme trabalham. Como ferramentas definem o contrato entre agentes e seu espaço de informação/ação, é extremamente importante que elas promovam eficiência — tanto retornando informação token-efficient quanto incentivando comportamento agentico eficiente.

Em Writing tools for AI agents — with AI agents, a Anthropic discute construir tools bem compreendidas pelos LLMs e com overlap mínimo em funcionalidade. Similar às funções de uma base de código bem projetada, tools devem ser self-contained, robustas a erro e extremamente claras quanto ao uso pretendido. Parâmetros de entrada devem ser descritivos, não-ambíguos e aproveitar os pontos fortes do modelo.

Tool design = controle remoto com 40 botões quase iguais. Você quer trocar pra Netflix e fica passando o dedo por "AV", "Source", "Input", "TV/Video" — aperta o errado, cai numa tela azul, perde 3 minutos voltando. Controle bom tem poucos botões, cada um com um trabalho claro: liga, volume, canal, Netflix. Se você hesita entre dois botões, o agente vai hesitar mais ainda. Tool bem desenhada é igual controle bom: cada uma faz uma coisa, e o nome não deixa dúvida.

Um dos modos de falha mais comuns observados é tool sets inflados — que cobrem funcionalidade demais ou levam a pontos de decisão ambíguos sobre qual tool usar. Se um engenheiro humano não consegue dizer definitivamente qual tool deveria ser usada em dada situação, um agente de IA não pode ser esperado fazer melhor.

Como será discutido mais adiante, curar um conjunto mínimo viável de tools para o agente também leva a manutenção e poda de contexto mais confiáveis em interações longas.

03

Examples (few-shot) componente

Fornecer exemplos — o que também se conhece como few-shot prompting — é uma best practice consolidada e a Anthropic continua a recomendá-la fortemente. Contudo, times frequentemente entopem o prompt com uma lista de lavanderia de edge cases na tentativa de articular toda regra possível que o LLM deve seguir. Isso não é recomendado.

Em vez disso, recomenda-se trabalhar para curar um conjunto diverso e canônico de exemplos que efetivamente retratem o comportamento esperado do agente. Para um LLM, exemplos são as "imagens" que valem por mil palavras.

Few-shot canônico = quando alguém pergunta "que tipo de música você curte?" e você responde com 5 a 8 músicas bem escolhidas — uma pagodinho, uma MPB, uma rock nacional, um funk, um sertanejo. Em 8 músicas a pessoa entende seu gosto. Se você mandar uma playlist de 300 músicas quase iguais, ela desiste antes da décima e não formou ideia nenhuma. Poucos exemplos bem escolhidos dizem mais que uma enciclopédia de casos.

Guidance integradora

"Através dos diferentes componentes do contexto — system prompts, tools, examples, message history — seja criterioso: mantenha seu contexto informativo, porém enxuto."

§ 05 Retrieval
Embeddings · Just-in-Time · Híbrido

Retrieval de contexto
e busca agentica.

Em Building effective AI agents, a Anthropic destacou as diferenças entre workflows LLM-based e agentes. Desde então, o time gravitou para uma definição simples, atribuída a Simon Willison: agentes são LLMs usando tools em loop, autonomamente.

Trabalhando com clientes, a Anthropic viu o campo convergindo nesse paradigma simples. Conforme os modelos subjacentes ficam mais capazes, o nível de autonomia dos agentes pode escalar: modelos mais inteligentes permitem que agentes naveguem espaços-problema nuançados de forma independente e se recuperem de erros.

Agora, observa-se uma mudança de paradigma em como engenheiros pensam o design do contexto. Hoje, muitas aplicações AI-native empregam alguma forma de retrieval baseado em embeddings em tempo de pré-inferência — para expor contexto importante que o agente raciocine sobre. À medida que o campo transita para abordagens mais agenticas, vê-se cada vez mais times aumentando esses sistemas de retrieval com estratégias "just in time".

Just-in-time retrieval — identificadores, não dados

Em vez de pré-processar todo dado relevante à frente, agentes construídos com a abordagem just in time mantêm identificadores leves — file paths, stored queries, web links etc. — e usam essas referências para dinamicamente carregar dado no contexto, em tempo de execução, via tools. O Claude Code, solução de coding agentica da Anthropic, usa essa abordagem para realizar análises complexas sobre bases de dados grandes: o modelo escreve queries direcionadas, armazena resultados, e aproveita comandos Bash como head e tail para analisar grandes volumes sem nunca carregar os objetos completos no contexto.

Just-in-time retrieval = ir ao mercado na hora de fazer o almoço, em vez de estocar todos os temperos e legumes do mundo na despensa. Você olha a receita de hoje, anota o que falta, e busca só aquilo. Menos desperdício, menos mofo no fundo da gaveta, menos tempo procurando. O agente faz igual: guarda só o endereço (file_path, url, query_id) e vai buscar o conteúdo quando a tarefa precisar — com read_file ou grep, no instante certo.

Essa abordagem espelha a cognição humana: em geral, não memorizamos corpora inteiros — introduzimos sistemas externos de organização e indexação (file systems, inboxes, bookmarks) para recuperar informação relevante sob demanda.

Metadata como sinal refinador

Além da eficiência de storage, metadata das referências provê um mecanismo para refinar comportamento — explícita ou intuitivamente. Para um agente operando em file system, a presença de um arquivo chamado test_utils.py em uma pasta tests implica propósito diferente de um arquivo com o mesmo nome em src/core_logic/. Hierarquias de pastas, convenções de nomenclatura e timestamps todos provêm sinais importantes que ajudam tanto humanos quanto agentes a entender como e quando utilizar a informação.

src/
 ├─ core_logic/
 │   └─ test_utils.py   ← utilidades reais, prod
 └─ components/

tests/
 ├─ test_utils.py       ← mocks, helpers de teste
 └─ integration/
          

Mesmo nome de arquivo, propósitos opostos. O path é o sinal — antes mesmo do conteúdo.

Progressive disclosure — montar entendimento em camadas

Deixar agentes navegar e recuperar dado autonomamente também habilita progressive disclosure — divulgação progressiva: o agente incrementalmente descobre contexto relevante por exploração. Cada interação produz contexto que informa a próxima decisão: tamanho de arquivo sugere complexidade; convenções de nomenclatura insinuam propósito; timestamps podem ser proxy para relevância. Agentes montam entendimento camada por camada, mantendo na working memory apenas o necessário e aproveitando estratégias de note-taking para persistência adicional.

Progressive disclosure = receita de bolo que revela um passo por vez. "Bata 3 ovos." Feito. "Agora adicione 2 xícaras de farinha." Feito. "Agora leve ao forno a 180°." A receita não joga os 20 ingredientes e as 15 etapas de uma vez — cada passo termina e abre o próximo. Se você tentasse memorizar tudo de cara, no meio do caminho misturaria fermento com açúcar. O agente faz igual: descobre o contexto em camadas, e cada descoberta afia a próxima pergunta. Foco vem da sequência, não do volume despejado de uma vez.

Esse self-managed context window mantém o agente focado em subsets relevantes, em vez de se afogar em informação exaustiva mas potencialmente irrelevante.

O trade-off

Existe um trade-off: runtime exploration é mais lento que retrieval de dado pré-computado. Mais que isso, engenharia opinionated e thoughtful é necessária para garantir que o LLM tenha as tools e heurísticas certas para navegar efetivamente sua paisagem de informação. Sem guidance apropriado, um agente pode desperdiçar contexto com uso errado de tools, perseguindo becos sem saída ou falhando em identificar informação-chave.

Estratégia híbrida — o melhor dos dois mundos

Em certos ambientes, os agentes mais efetivos empregam uma estratégia híbrida: fazem retrieval de alguns dados up-front para velocidade e prosseguem com exploração autônoma a sua discrição. A fronteira de decisão para o 'nível correto' de autonomia depende da tarefa.

Caso de estudo — Claude Code

O Claude Code é um agente que emprega esse modelo híbrido: arquivos CLAUDE.md são ingenuamente drop-ados no contexto up-front, enquanto primitivos como glob e grep permitem navegar seu ambiente e recuperar arquivos just-in-time — efetivamente bypassando os problemas de stale indexing e sintaxe de ASTs complexas.

Pre-inference embedding

Quando aplicar: conteúdos pouco dinâmicos, onde o custo de exploração runtime supera ganho de relevância. Ex.: legal, finanças.

Just-in-time

Quando aplicar: ambientes altamente dinâmicos (código, filesystems vivos), onde indexação prévia envelhece em horas.

Híbrido

Quando aplicar: trade-off explícito — up-front acelera arranque; autonomia cobre ambiguidade. Padrão do Claude Code.

A estratégia híbrida pode ser melhor para contextos com conteúdo menos dinâmico — como trabalho legal ou financeiro. Conforme capacidades de modelo melhoram, design agentico tenderá a deixar modelos inteligentes agirem inteligentemente, com curadoria humana progressivamente menor.

Dado o ritmo rápido de progresso no campo, "faça a coisa mais simples que funciona" provavelmente continuará sendo o melhor conselho para times construindo agentes sobre Claude.
§ 06 Long-Horizon
Compaction · Notes · Sub-agents

Context engineering para
tarefas de longo horizonte.

Tarefas de longo horizonte exigem que agentes mantenham coerência, contexto e comportamento orientado a objetivo ao longo de sequências de ações em que o token count excede a janela de contexto do LLM. Para tarefas que se estendem por dezenas de minutos a múltiplas horas de trabalho contínuo — como grandes migrações de codebase ou projetos de pesquisa compreensivos — agentes precisam de técnicas especializadas para driblar a limitação de tamanho da janela.

Esperar janelas de contexto maiores pode parecer tática óbvia. Mas é provável que, no futuro previsível, janelas de contexto de todos os tamanhos permaneçam sujeitas a poluição e preocupações de relevância — pelo menos em situações onde se deseja a performance agentica mais forte. Para habilitar agentes a trabalharem efetivamente em horizontes temporais estendidos, a Anthropic desenvolveu três técnicas que endereçam essas restrições de poluição de contexto diretamente:

01
Compaction
02
Structured
Note-Taking
03
Sub-Agent
Architectures
01

Compaction

Compaction é a prática de pegar uma conversa aproximando-se do limite da janela de contexto, sumarizar seu conteúdo, e reinicializar uma nova janela com o sumário. Compaction tipicamente serve como primeira alavanca em context engineering para dirigir melhor coerência de longo prazo. Em seu núcleo, compaction destila o conteúdo de uma janela de contexto de forma de alta fidelidade, permitindo que o agente continue com degradação de performance mínima.

Compaction = transcrever uma reunião de 2 horas em uma ata de 1 página. Tudo que importava — decisões, bloqueios em aberto, próximos passos — sobrevive; o que era ruído (quem interrompeu quem, as piadas) é cortado. Você sai da sala com a ata na mão e consegue continuar a próxima reunião sem reler a transcrição inteira. Compaction faz isso para o histórico de mensagens.

Diagrama — fluxo de compaction no Claude Code
        ┌─────────────────────────────────────────┐
        │  Context Window (próximo do limite)     │
        │  ═══════════════════════════════════    │
        │  • system prompt                         │
        │  • tool defs                             │
        │  • message history [t₀ ... tₙ]          │
        │  • tool outputs (muitos, verbosos)       │
        │  • arquivos lidos (5 mais recentes)      │
        └─────────────┬───────────────────────────┘
                      │  modelo sumariza
                      ↓
        ┌─────────────────────────────────────────┐
        │  Sumário high-fidelity                   │
        │  ─ decisões arquiteturais                │
        │  ─ bugs em aberto                        │
        │  ─ detalhes de implementação             │
        │  ─ [descartado] tool outputs redundantes │
        └─────────────┬───────────────────────────┘
                      │  reinicializa janela
                      ↓
        ┌─────────────────────────────────────────┐
        │  New Context Window                      │
        │  • sumário comprimido                    │
        │  • 5 arquivos acessados mais recentes    │
        │  • agente continua sem fricção percebida │
        └─────────────────────────────────────────┘

No Claude Code, isso é implementado passando o message history ao modelo para sumarizar e comprimir os detalhes mais críticos. O modelo preserva decisões arquiteturais, bugs não resolvidos e detalhes de implementação enquanto descarta tool outputs redundantes ou mensagens supérfluas. O agente pode então continuar com este contexto comprimido mais os cinco arquivos acessados mais recentemente. Usuários recebem continuidade sem se preocupar com limitações de janela.

A arte da compaction reside na seleção do que manter versus do que descartar — compaction agressiva demais pode resultar em perda de contexto sutil mas crítico, cuja importância só se revela mais tarde. Para engenheiros implementando sistemas de compaction, a recomendação: ajustar cuidadosamente o prompt em traces complexos de agentes. Começar maximizando recall — garantir que a compaction capture toda peça relevante do trace — e então iterar para melhorar precision, eliminando conteúdo supérfluo.

Tune dial — recall → precision

Passo 1 — maximize recall: a compaction captura tudo que poderia ser relevante? (nada perdido).
Passo 2 — refine precision: elimine o que foi capturado mas é ruído (nada supérfluo).
A ordem importa: precision antes de recall = risco de jogar fora o que nem sabia que importava.

Um exemplo de conteúdo supérfluo de baixo risco é clearing tool calls and results: uma vez que uma tool foi chamada fundo no message history, por que o agente precisaria ver o resultado cru novamente? Uma das formas mais seguras e leves de compaction é tool result clearing — lançada recentemente como feature no Claude Developer Platform.

Tool result clearing = quando você termina uma ligação com o banco para confirmar um saldo, você não carrega a gravação da ligação para sempre. Você lembra do número e descarta o áudio. O agente faz o mesmo: manteve o fato ("saldo é R$ X"), descartou o verboso tool output que o produziu.

02

Structured note-taking

Structured note-taking — ou agentic memory — é uma técnica na qual o agente regularmente escreve notes persistidas em memória fora da janela de contexto. Essas notes são puxadas de volta à janela em momentos posteriores.

Essa estratégia provê memória persistente com overhead mínimo. Como o Claude Code criando uma to-do list, ou seu agente customizado mantendo um arquivo NOTES.md, esse padrão simples permite que o agente rastreie progresso ao longo de tarefas complexas, mantendo contexto crítico e dependências que de outra forma se perderiam ao longo de dezenas de tool calls.

Structured note-taking = a lista de compras grudada no ímã da geladeira. Durante a semana, cada vez que acaba um item — café, sabão, pão — você vai lá e anota. No sábado, pega a lista e vai ao mercado. Você não precisou lembrar de 14 coisas: anotou uma por uma, no momento em que faltavam. Sua cabeça ficou livre pra trabalhar, estudar, assistir série. Para o agente, o NOTES.md é a lista na geladeira: ele anota fora da cabeça pra liberar atenção pro que está fazendo agora.

Caso emblemático — Claude Plays Pokémon

Claude playing Pokémon demonstra como memória transforma capacidades do agente em domínios non-coding. O agente mantém contagens precisas ao longo de milhares de passos de jogo — rastreando objetivos como:

"For the last 1,234 steps I've been training my Pokémon in Route 1, Pikachu has gained 8 levels toward the target of 10."

Sem nenhum prompting sobre estrutura de memória, o agente desenvolve mapas de regiões exploradas, lembra quais achievements-chave foram desbloqueados, e mantém notas estratégicas de combate que o ajudam a aprender quais ataques funcionam melhor contra diferentes oponentes.

Após resets de contexto, o agente lê suas próprias notas e continua sequências de treino de múltiplas horas ou explorações de dungeon. Essa coerência ao longo de summarization steps habilita estratégias de longo horizonte que seriam impossíveis mantendo toda informação apenas na janela do LLM.

Como parte do launch do Sonnet 4.5, a Anthropic lançou uma memory tool em beta público no Claude Developer Platform que torna mais fácil armazenar e consultar informação fora da janela de contexto através de um sistema file-based. Isso permite que agentes construam knowledge bases ao longo do tempo, mantenham estado de projeto entre sessões, e referenciem trabalho anterior sem manter tudo em contexto.

03

Sub-agent architectures

Sub-agent architectures provêem outra saída para limitações de contexto. Em vez de um agente tentando manter estado ao longo de um projeto inteiro, sub-agentes especializados podem lidar com tarefas focadas com janelas de contexto limpas. O agente principal coordena com um plano high-level enquanto sub-agentes performam trabalho técnico profundo ou usam tools para achar informação relevante.

Cada sub-agente pode explorar extensivamente, usando dezenas de milhares de tokens ou mais — mas retorna apenas um sumário condensado e destilado do seu trabalho (frequentemente 1.000–2.000 tokens).

Sub-agent architecture = grupos separados de WhatsApp pra cada assunto. Um do trabalho, um da família, um do condomínio, um dos amigos da escola. Se fosse tudo num grupo só, você nunca acharia nada: o boleto do condomínio perdido entre fotos do churrasco e memes do primo. Cada grupo só tem o que importa pra ele, e quando você precisa de uma informação, sabe em qual abrir. Sub-agentes funcionam igual: cada um mergulha fundo no seu assunto (10k, 30k, 25k tokens), e só volta com um resumo de uma página pro agente principal. Quem decide no topo nunca precisa ler todas as mensagens de todos os grupos.

Diagrama — arquitetura multi-agente
                    ┌──────────────────────────┐
                    │   LEAD AGENT             │
                    │   (plano high-level)     │
                    │   context: enxuto        │
                    └────────┬─────────────────┘
                             │ delega subtarefas
             ┌───────────────┼───────────────┐
             ↓               ↓               ↓
      ┌────────────┐  ┌────────────┐  ┌────────────┐
      │ SUB-AGENT  │  │ SUB-AGENT  │  │ SUB-AGENT  │
      │    A       │  │    B       │  │    C       │
      │ context    │  │ context    │  │ context    │
      │ limpa &    │  │ limpa &    │  │ limpa &    │
      │ profunda   │  │ profunda   │  │ profunda   │
      │ (10k tok)  │  │ (30k tok)  │  │ (25k tok)  │
      └─────┬──────┘  └─────┬──────┘  └─────┬──────┘
            │ resumo        │ resumo         │ resumo
            │ 1.5k tok      │ 1k tok         │ 2k tok
            └───────────────┼────────────────┘
                            ↓
                    ┌──────────────────────────┐
                    │   LEAD AGENT             │
                    │   sintetiza & analisa    │
                    │   contexto total: ~5k    │
                    └──────────────────────────┘

Essa abordagem atinge uma clara separação de responsabilidades — o contexto de busca detalhado permanece isolado dentro dos sub-agentes, enquanto o lead agent foca em sintetizar e analisar os resultados. Esse padrão, discutido em How we built our multi-agent research system, mostrou melhoria substancial sobre sistemas single-agent em tarefas complexas de pesquisa.

Matriz de escolha — qual técnica quando?

A escolha entre essas abordagens depende das características da tarefa. Do ensaio original:

Compaction

Mantém fluxo conversacional para tarefas que requerem extensivo back-and-forth.

Note-taking

Excelente para desenvolvimento iterativo com milestones claros.

Multi-agent

Lida com pesquisa e análise complexas, onde exploração paralela paga dividendos.

Mesmo conforme modelos continuam a melhorar, o desafio de manter coerência ao longo de interações estendidas permanecerá central para construir agentes mais efetivos.

§ 07 Conclusão
Takeaways · Princípio norteador

Contexto como
recurso precioso e finito.

Context engineering representa uma mudança fundamental em como construímos com LLMs. À medida que os modelos ficam mais capazes, o desafio deixa de ser apenas escrever o prompt perfeito — torna-se curar cuidadosamente que informação entra no limitado attention budget do modelo, a cada passo.

Seja implementando compaction para tarefas de longo horizonte, projetando tools token-efficient, ou habilitando agentes a explorar seu ambiente just-in-time, o princípio norteador permanece o mesmo:

Encontre o menor conjunto de high-signal tokens que maximize a probabilidade do seu resultado desejado.

As técnicas delineadas continuarão evoluindo à medida que os modelos melhorem. Já se observa que modelos mais inteligentes requerem engenharia menos prescritiva — permitindo que agentes operem com mais autonomia. Mas mesmo que capacidades escalem, tratar contexto como um recurso precioso e finito permanecerá central para construir agentes confiáveis e efetivos.

Começar com context engineering no Claude Developer Platform hoje, e acessar dicas e best practices via o cookbook de memory and context management.

Takeaways derivados do ensaio

  1. 01
    Contexto é recurso finito com retornos marginais decrescentes. Cada token adicional deprecia o attention budget. Trate como mala de viagem: espaço fixo, cada peça a mais rouba espaço de outra.
  2. 02
    A arquitetura transformer impõe custo n² — a escassez é estrutural. Não é bug nem configuração — é a matemática por baixo da atenção. Context rot existe em todos os modelos, só varia a suavidade.
  3. 03
    System prompts na "altitude certa" — nem hardcoded, nem vago. Zona Goldilocks: específico para guiar; flexível para generalizar. Use seções distintas; comece mínimo; itere sobre failure modes.
  4. 04
    Tools enxutas, inequívocas e sem overlap. Se um engenheiro humano hesitaria entre duas tools, o agente hesitará mais. Conjunto mínimo viável > tool set inchado.
  5. 05
    Examples canônicos e diversos, não lista de lavanderia de edge cases. Few-shot bem curado comunica comportamento; few-shot inchado afoga o sinal.
  6. 06
    Just-in-time retrieval > pre-loading cego em ambientes dinâmicos. Identificadores leves + tools que carregam on demand. Metadata (path, nome, timestamp) é sinal próprio.
  7. 07
    Progressive disclosure: entendimento em camadas, não em bloco. Agente descobre contexto por exploração, mantém só o necessário na working memory, externaliza o resto em notes.
  8. 08
    Híbrido vence quando o domínio é mais estático (legal, finanças). Algumas coisas up-front para velocidade; autonomia para o resto. Padrão usado pelo Claude Code.
  9. 09
    Long-horizon exige compaction + notes + sub-agents. Janela maior não resolve rot; resolve os sintomas. Use as três técnicas como ferramentas complementares, não alternativas.
  10. 10
    "Do the simplest thing that works" permanece o melhor conselho. Modelos mais inteligentes requerem engenharia menos prescritiva. Evite superestruturar a partir do dia zero.
§ 08 Referências
Papers · Posts · Produtos

Referências citadas.

Papers & estudos
Posts & artigos irmãos
Agradecimentos (tradução livre da nota do ensaio original)

Escrito pelo Applied AI Team da Anthropic: Prithvi Rajasekaran, Ethan Dixon, Carly Ryan e Jeremy Hadfield, com contribuições dos membros do time Rafi Ayub, Hannah Moran, Cal Rueb e Connor Jennings. Agradecimentos especiais a Molly Vorwerck, Stuart Ritchie e Maggie Vo pelo suporte.