🧠FFVAcademy
🧠

Context Engineering: prompt caching, subagents e skills

16 min de leitura·+80 XP
Pré-requisitos (0/1)0%

Recomendamos completar os pré-requisitos antes de seguir, mas nada te impede de continuar.

Em 2026, janelas de 1M tokens são commodity — mas "enfiar tudo" continua sendo a forma mais cara e lenta de usar um LLM. Context engineering é a disciplina de gerenciar o que entra na janela: o que cachear, o que resumir, o que delegar, em que ordem posicionar, quando truncar. É onde um agent de US$5/query vira US$0.30/query sem perder qualidade.

A janela não é grátis

💡
Preço típico (abril 2026): input em torno de US$3/1M tokens (Sonnet), US$0.25/1M (Haiku). Contextos de 100k tokens a cada chamada, em agent com loop de 10 passos, custam US$3 por execução. Em produto com 10k usuários/mês → US$30k/mês só de input. Cortar 50% do contexto = US$15k economizados. Context engineering paga salário.
🗺️ Anatomia de uma chamada LLM em agent

 ┌──────────────────────────────────────────────────────────┐
 │ INPUT (janela)                                           │
 │ ┌────────────────────┐                                   │
 │ │ System prompt      │   ← estável, CACHEÁVEL            │
 │ │ Tool definitions   │   ← estável, CACHEÁVEL            │
 │ │ Few-shot examples  │   ← estável, CACHEÁVEL            │
 │ ├────────────────────┤                                   │
 │ │ RAG context        │   ← volátil por query             │
 │ │ Conversation hist. │   ← volátil, cresce               │
 │ │ Tool results       │   ← volátil, podem ser grandes    │
 │ └────────────────────┘                                   │
 └──────────────────────────────────────────────────────────┘
                           │
                           ▼
 ┌──────────────────────────────────────────────────────────┐
 │ OUTPUT (tokens gerados)                                  │
 │ + thought / tool_use / final answer                      │
 └──────────────────────────────────────────────────────────┘
Ordem importa: coloque o estável primeiro. Prompt caching só funciona em prefixos idênticos — qualquer mudança invalida o cache dali pra frente.

Prompt caching: o ganho de 90% que poucos usam

Anthropic, OpenAI e Google oferecem caching de prefixo. A mecânica: você marca blocos "cacheáveis" no início; o provider armazena o KV cache por ~5 min; chamadas dentro dessa janela pagam muito menos pelo prefixo.

ProviderComo ativarPreço cacheado vs normal
Anthropiccache_control: { type: "ephemeral" } nos blocosWrite 125% / read 10%
OpenAIAutomático para prefixos repetidos (>1024 tok)Read ~50% do preço normal
Google GeminicachedContent API — criar cache explícitoRead ~25% do preço + taxa de storage
python
# Anthropic: marcar blocos cacheáveis
from anthropic import Anthropic
client = Anthropic()

r = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": LONG_SYSTEM_PROMPT,      # 5k tokens
            "cache_control": {"type": "ephemeral"},
        },
    ],
    tools=[
        # tools também podem entrar no cache
        *TOOL_DEFS,
    ],
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": LARGE_DOC,       # 50k tokens, revisitado em várias queries
                    "cache_control": {"type": "ephemeral"},
                },
                {
                    "type": "text",
                    "text": user_query,      # volátil, NÃO cacheado
                },
            ],
        },
    ],
)
# r.usage.cache_creation_input_tokens: primeira chamada, escreve o cache
# r.usage.cache_read_input_tokens:     chamadas seguintes, leem o cache

📋 Agent que faz 20 chamadas por sessão repetindo system prompt de 8k tokens

Ativar prompt caching em system + tools

Sem cache: 20 × 8k = 160k tokens de input repetido. Com cache: 1 write + 19 reads ≈ 10% do custo. Economia ~90% em um item só.

Alt: Reduzir system promptútil, mas tem limite de quanto dá pra cortar

Alt: Mudar para Haikuganha preço mas perde qualidade em tarefas complexas

Compaction: resumo de conversa para janela cresce sem estourar

Conversas longas estouram janela rapidamente. A estratégia padrão é compaction: quando a janela atinge X% do limite, um LLM barato resume a conversa mais antiga em uma mensagem "system summary", e apaga as originais. O agent continua como se nada tivesse acontecido.

python
# Compaction simples — mantém últimas N mensagens + summary do resto
def compact_if_needed(messages: list[dict], max_tokens: int = 100_000) -> list[dict]:
    total = sum(estimate_tokens(m) for m in messages)
    if total < max_tokens * 0.7:
        return messages                # ainda cabe folgado

    keep_tail = 8                       # mantém últimas 8 em original
    to_summarize = messages[:-keep_tail]
    tail = messages[-keep_tail:]

    summary_text = llm_call(
        model="claude-haiku-4-5-20251001",
        system="Resuma a conversa em 300 palavras, mantendo fatos, decisões e tool results relevantes para continuar.",
        messages=to_summarize,
    )
    summary_msg = {
        "role": "user",
        "content": f"<conversation_summary>\n{summary_text}\n</conversation_summary>",
    }
    return [summary_msg] + tail
⚠️
Compaction é lossy. Tudo que foi resumido perde fidelidade. Para ações críticas (auditoria, decisão financeira), persista o trace original fora da janela e use summary apenas como contexto de continuação, não como verdade.

Subagent delegation: manter o principal limpo

Subagents rodam em janela isolada. O principal os invoca via Task tool (Claude Code) ou sub-agent (OpenAI Agents SDK), recebe apenas o output estruturado e continua. Isso mantém a janela principal enxuta e permite paralelismo.

Incluir no contexto principalDelegar a subagent
Fato curto e relevante semprePesquisa que exige ler 10+ arquivos
Instrução global do sistemaGeração de sub-relatório com contexto próprio
Resultado já sintetizadoExploração cujo output é um resumo
Tool pequena e frequenteTool que gera outputs grandes (grep em monorepo)
💡
Padrão Anthropic: dar ao subagent uma task clara, contexto necessário (não o histórico), e o formato esperado de retorno. O principal deve conseguir "entender o output sem ler como o subagent chegou lá".

Agent Skills: instruções carregadas sob demanda

Skills (Anthropic, 2024+) são módulos de instruções + scripts que o agent carrega quando a situação o exige. Cada skill tem uma description curta no índice; o agent decide invocar a skill completa apenas quando a task corresponder. Alternativa a enfiar todas as políticas no system prompt.

markdown
---
name: pdf-extraction
description: Extrai texto e tabelas de PDFs complexos usando pdfplumber + VLM para imagens.
allowed-tools: Read, Bash, Write
---

# PDF Extraction

Quando o usuário pedir para extrair dados de PDF:

1. Use `pdfplumber` para texto e tabelas limpas.
2. Para PDFs escaneados, rode OCR (`tesseract`) ou envie a página como imagem para Claude Vision.
3. Sempre valide que a extração preservou estrutura (tabelas não podem virar texto corrido).
4. Salve output em `extracted/` com mesmo nome do PDF + `.md`.

Exemplo de script:

```bash
pdfplumber dump tables input.pdf > tables.json
```
Skills viram o anti-padrão "system prompt gigante". Em vez de 20 políticas para 20 tipos de task, você tem 20 skills curtas com descriptions, carregadas on-demand. Contexto médio cai drasticamente.

CLAUDE.md / AGENTS.md: instruções do projeto

Instruções persistentes por repo/projeto vivem em arquivos-guia: CLAUDE.md (Claude Code), AGENTS.md (Codex/OpenAI), .cursor/rules/ (Cursor). Esses arquivos entram automaticamente no contexto quando o agent abre o projeto.

Deve entrarNão deve entrar
Comandos de build/test/lint específicosDocumentação que o agent consegue derivar lendo código
Padrões de commit/PRHistórico de decisões (vai pra ADR, não aqui)
Gotchas conhecidos (bugs, conflitos)Todo o manual do projeto
Estrutura de pastas não-óbviaREADME completo duplicado
Scripts de deploy, env vars importantesSegredos, tokens
⚠️
CLAUDE.md "gigante" (>300 linhas) começa a competir por atenção com o próprio código. Mantenha enxuto (≤ 200 linhas em 90% dos casos). Se não couber, divida em skills carregadas sob demanda.

Ordem, posição e formato

PrincípioPor queConsequência prática
Estável antes do volátilPrompt caching exige prefixo idênticoSystem → tools → few-shots → dados fixos → query
Crítico no início ou fimLost in the middleResposta direta no topo; confirmação no fim
Tags estruturadas (XML)Claude/GPT-4+ respeitam delimitadores<contexto>...</contexto>, <pergunta>...</pergunta>
Evite repetiçãoCada token pago, cada token atençãoSe já está em system, não repita em user
Tool result compactoTool que retorna 50k tokens destrói contextoTruncar, agregar ou delegar para subagent

Perguntas típicas

Contexto de 1M tokens não elimina tudo isso?

Não. Custos sobem linearmente com input, latência cresce, e lost-in-the-middle continua existindo (menor que em 128k, mas existe). Janela grande é seguro-rede, não estratégia. Contexto bem curado de 30k costuma ganhar de 500k "enfiado" em qualidade e custo.

Prompt caching funciona entre usuários diferentes?

Depende do provider. Anthropic: cache é escopado por organização — chamadas com o mesmo prefixo de qualquer usuário da sua API key compartilham cache. OpenAI: cache automático, não precisa preocupar. Google Gemini: cache explícito por API. Em todos, o TTL curto (~5min) significa que baixo volume perde o benefício.

Como meço o impacto de context engineering?

Duas métricas principais: (1) cost per task (tokens × preço / query), (2) p95 latency. Instrumente ambos por versão do pipeline. Rode A/B test de 100 queries comparando versão antiga vs nova. Ganho abaixo de 10% não justifica refactor; acima de 30% é quase sempre vitória.

Skills vs tools — qual a diferença?

Tool é uma função executável (código). Skill é um conjunto de instruções + (opcional) scripts que guiam o agent em um tipo de tarefa. Tool responde "como chamar X"; skill responde "como lidar com situação Y". Em produção, você combina: skill "analisar PDF" usa tool "read_file" + tool "ocr". Skills mudam contexto, tools mudam estado.
Take-aways. Context engineering = gerenciar janela como recurso. Prompt caching corta 50-90% do custo em agents repetitivos — ordene estável antes do volátil. Compaction mantém conversas longas viáveis. Subagents isolam contexto pesado. Skills e CLAUDE.md/AGENTS.md carregam instruções sob demanda. Lost-in-the-middle ainda existe; posicione o crítico no início ou fim. Próximo: MCP deep dive — o protocolo que padronizou como agents acessam ferramentas e dados externos.
🧩

Quiz rápido

4 perguntas · Acerte tudo e ganhe o badge 🎯 Gabarito

Continue lendo