Domínio 5 — Context Management & Reliability · Lição 2 de 5

Compaction, context editing, scratchpad e delegação

Objetivos de aprendizagem

Diferenciar compaction (resume o histórico server-side) de context editing (limpa tool_results antigos sem resumir).
Usar scratchpad em arquivos para persistir achados-chave através de fronteiras de contexto.
Aplicar delegação a subagentes para isolar exploração verbosa do contexto do coordenador.
Projetar crash recovery com manifests de estado estruturado que o coordenador carrega no resume.
Saber quando usar /compact no Claude Code e memória persistente entre sessões.

Compaction vs. context editing: dois mecanismos diferentes

A API oferece dois recursos beta de gerenciamento de contexto server-side, e a prova adora confundi-los:

	Compaction	Context editing
Beta header	`compact-2026-01-12`	`context-management-2025-06-27`
Edit type	`compact_20260112`	`clear_tool_uses_20250919` (e `clear_thinking_20251015`)
O que faz	Resume o contexto anterior em um bloco `compaction` quando a conversa se aproxima do limite da janela	Limpa (remove) tool results antigos e blocos de thinking com base em thresholds configuráveis — sem resumir
Preserva informação?	Sim, de forma comprimida (resumo com perda)	Não: o conteúdo limpo é descartado
Quando usar	Conversas que tendem a atingir/exceder a janela e cujo histórico antigo ainda importa	Contexto cheio de tool results velhos e irrelevantes (staleness), sem valor futuro
Cuidado crítico	Repassar `response.content` completo nos requests seguintes — o bloco `compaction` deve ser preservado	Não usar quando resultados antigos ainda serão referenciados

Ambos são beta. Exigem client.beta.messages.create(...) com o header correto em betas=[...]. Usar o beta header de um com o edit type do outro é erro — e a prova pode cobrar exatamente essa associação.

Exemplo (beta): compaction server-side

import anthropic

# BETA: compaction server-side (compact-2026-01-12)
client = anthropic.Anthropic()
messages = []

def chat(user_message: str) -> str:
    messages.append({"role": "user", "content": user_message})

    response = client.beta.messages.create(
        betas=["compact-2026-01-12"],
        model="claude-opus-5",
        max_tokens=16000,
        messages=messages,
        context_management={
            "edits": [{"type": "compact_20260112"}]
        },
    )

    # CRITICO: anexar response.content COMPLETO, nao apenas o texto.
    # O bloco "compaction" retornado precisa ser preservado no historico.
    messages.append({"role": "assistant", "content": response.content})

    return next(block.text for block in response.content if block.type == "text")

print(chat("Me ajude a construir um web scraper em Python"))
print(chat("Adicione suporte a paginas renderizadas com JavaScript"))
# A compaction dispara automaticamente quando o contexto cresce

Para context editing, a mesma estrutura usa betas=["context-management-2025-06-27"] e context_management={"edits": [{"type": "clear_tool_uses_20250919"}]} — tool results antigos são removidos do contexto conforme thresholds, mantendo a transcrição enxuta sem custo de sumarização.

Panorama das estratégias

flowchart TD
    A[Contexto crescendo em sessao longa] --> B{O historico antigo ainda importa?}
    B -- "Sim, de forma resumida" --> C[Compaction beta compact-2026-01-12
resume em bloco compaction]
    B -- "Nao: tool results velhos e irrelevantes" --> D[Context editing beta context-management-2025-06-27
limpa tool_results antigos]
    A --> E{Precisa sobreviver a crash ou nova sessao?}
    E -- "Achados da exploracao" --> F[Scratchpad em arquivos
registrar e reler achados]
    E -- "Estado entre sessoes" --> G[Memoria persistente
diretorio de memories]
    E -- "Retomada apos falha" --> H[Manifest de estado por agente
coordenador carrega no resume]
    A --> I{Exploracao verbosa a fazer?}
    I -- "Sim" --> J[Delegar a subagentes
so o sumario volta ao coordenador]

Scratchpad em arquivos

Em exploração de grandes codebases, o antídoto para a degradação de contexto é persistir achados-chave em arquivos scratchpad: o agente registra descobertas (classes encontradas, dependências traçadas, decisões tomadas) e as relê ao responder perguntas subsequentes, em vez de depender do histórico degradado. O arquivo sobrevive a fronteiras de contexto — e a compactações.

Padrão complementar: ao encerrar uma fase de exploração, resumir os achados-chave e injetar esse resumo no contexto inicial dos subagentes da próxima fase.

Delegação a subagentes

Exploração verbosa (ex.: "encontre todos os arquivos de teste", "trace as dependências do fluxo de reembolso") gera milhares de tokens de output intermediário. Delegando a um subagente, todo esse volume fica no contexto dele; apenas o resumo estruturado volta ao coordenador, que preserva contexto limpo para a coordenação de alto nível.

Crash recovery com manifests de estado

Pipelines longos falham. O padrão resiliente:

Cada agente exporta seu estado (fase atual, achados, pendências) para uma localização conhecida, em formato estruturado;
No restart, o coordenador carrega um manifest que aponta os estados salvos e injeta-os nos prompts dos agentes retomados;
O trabalho continua de onde parou, sem re-executar fases concluídas.

No Claude Code: /compact e memória

/compact reduz o uso de contexto durante sessões estendidas, resumindo a conversa quando ela enche de output verboso de descoberta;
CLAUDE.md e /memory mantêm instruções e conhecimento persistente entre sessões;
Subagentes (Task tool) isolam exploração do contexto principal — o mesmo princípio da API.

Combine as estratégias. Agentes long-running maduros usam as três camadas: context editing para poda dentro da sessão, compaction perto do limite da janela, e memória/arquivos para persistência entre sessões.

Pegadinhas da prova

Distrator típico: tratar context editing como "resumo automático". Ele não resume — remove tool results antigos. Quem resume é compaction.
Distrator típico: após compaction, repassar apenas o texto da resposta. Errado: é preciso anexar response.content completo, preservando o bloco compaction.
Distrator típico: usar esses recursos sem o beta header (ou com o header trocado) — retorna 400. Compaction = compact-2026-01-12; context editing = context-management-2025-06-27.
Distrator típico: "guarde os achados no histórico da conversa" como estratégia de crash recovery. Histórico em memória morre com o processo — recovery exige estado exportado em local conhecido + manifest carregado no resume.
Distrator típico: fazer o coordenador executar a exploração verbosa "para ter todo o contexto". Isso lota o contexto de coordenação — o padrão correto é delegar e receber só o sumário estruturado.

Resumo em 5 linhas

Compaction (beta compact-2026-01-12) resume o histórico em um bloco compaction que deve ser repassado via response.content completo.
Context editing (beta context-management-2025-06-27, clear_tool_uses_20250919) limpa tool results antigos — descarta, não resume.
Scratchpad em arquivos persiste achados através de fronteiras de contexto e combate a degradação em sessões longas.
Subagentes isolam exploração verbosa; só o resumo estruturado retorna ao coordenador.
Crash recovery: cada agente exporta estado para local conhecido; o coordenador carrega o manifest no resume e injeta nos prompts.

Documentação oficial

Questões de fixação

1. Qual é a diferença essencial entre compaction e context editing na API?

A) Compaction é client-side; context editing é server-side. B) Compaction resume o contexto anterior em um bloco compaction; context editing remove tool results antigos sem resumir. C) Context editing resume o histórico; compaction apaga tool results. D) São o mesmo recurso com dois nomes de beta header.

2. Uma equipe habilitou compaction e, após a primeira compactação, o agente "esqueceu" tudo que veio antes. O código anexa ao histórico apenas o texto da resposta (response.content[0].text). Qual é a causa?

A) O modelo não suporta compaction e ignorou o parâmetro. B) Faltou aumentar max_tokens para caber o resumo. C) O bloco compaction retornado em response.content foi descartado — é preciso anexar o content completo ao histórico. D) Compaction exige reenviar o histórico bruto junto com o resumo.

3. Durante exploração de um monorepo, o agente coordenador precisa mapear todos os testes e traçar dependências de um fluxo crítico — tarefas que geram output enorme. Qual arquitetura preserva o contexto do coordenador?

A) Delegar cada investigação a um subagente e receber apenas resumos estruturados. B) O coordenador executa tudo, pois precisa de visibilidade completa dos detalhes. C) Aumentar o effort do modelo para ele processar mais output. D) Rodar as buscas e apagar manualmente as mensagens antigas do array antes de cada chamada.

4. Um pipeline multi-agente de análise que roda por horas precisa sobreviver a crashes sem re-executar fases concluídas. Qual padrão atende a esse requisito?

A) Aumentar max_retries do SDK para o pipeline nunca falhar. B) Manter todo o progresso no histórico de mensagens do coordenador. C) Habilitar compaction para o histórico caber na janela indefinidamente. D) Cada agente exporta estado estruturado para local conhecido; no resume, o coordenador carrega um manifest e injeta os estados nos prompts.

5. No Claude Code, uma sessão de exploração estendida encheu o contexto com output verboso de descoberta. Qual comando reduz o uso de contexto resumindo a conversa?

A) /memory B) /compact C) /clear-tools D) Reiniciar o Claude Code, que preserva o contexto automaticamente.