Por que janelas de 200 mil tokens não resolvem o desperdício

Quando os provedores de modelos de linguagem ampliaram as janelas de contexto para 200 mil e até 1 milhão de tokens, muita gente presumiu que o problema de tamanho de prompt tinha acabado. Na prática de engenharia de software com agentes de terminal e assistentes de IDE, aconteceu o oposto: janelas maiores incentivaram o hábito de jogar arquivos inteiros, logs gigantescos de build e históricos longos de tentativas dentro da conversa sem nenhum critério.

O primeiro problema dessa abordagem aparece na matemática das sessões de múltiplos turnos. Uma API de LLM não mantém estado interno gratuito entre chamadas; a cada rodada, o cliente reenvia todo o histórico acumulado. Se o primeiro turno consome 6.000 tokens e cada execução de ferramenta acrescenta outros 8.000 tokens de saída bruta, o vigésimo turno envia mais de 150.000 tokens de entrada. O crescimento acumulado de tokens ao longo da tarefa segue uma curva quadrática. Antes de trocar de modelo ou cortar recursos do time, vale simular esse acúmulo por turno na calculadora de custos e tokens de LLM, comparando entrada nova, leitura em cache e volume de saída.

O segundo problema é técnico e afeta diretamente a qualidade do código gerado. Quanto maior o volume de ruído na janela de entrada, maior o tempo até o primeiro token (TTFT) na etapa de prefill e maior a chance de o modelo perder atenção em instruções importantes registradas no começo da conversa. Stack traces curtos enterrados no meio de 1.500 linhas de avisos de compilação fazem o agente ignorar a causa real do erro e entrar em ciclos repetitivos de tentativas falhas.

Princípio da engenharia de contexto: um agente de código precisa dos sinais determinísticos de cada comando (código de saída, arquivos alterados, linha exata da falha e stack trace curto), nunca da saída visual completa pensada para um humano olhando um terminal colorido.

Anatomia do ruído em sessões de agentes de terminal

Ferramentas de linha de comando foram criadas ao longo de décadas para leitura humana interativa. Elas imprimem códigos de escape ANSI para colorir texto, barras de progresso que reescrevem a mesma linha com \r, cabeçalhos extensos de compilador repetidos para cada arquivo fonte e listas inteiras de testes que passaram. Para um tokenizador BPE, cada código de cor ou borda ASCII de tabela vira dezenas de tokens desperdiçados.

Outro vilão frequente aparece em repositórios reais: arquivos de trava de dependências como package-lock.json, Podfile.lock ou Package.resolved. Um único git diff sem filtro de caminho pode despejar 25.000 tokens de hashes SHA-256 na conversa e expulsar da memória ativa do modelo as regras do projeto. A tabela abaixo compara o volume médio de tokens em saídas brutas versus saídas filtradas semanticamente em comandos comuns do dia a dia.

Comando de terminalSaída bruta (tokens)Saída filtrada (tokens)ReduçãoSinal preservado
git status + git diff (com lockfile)14.2001.15091,9%Resumo por arquivo, hunks de código e aviso de lockfile omitido
pytest -v (240 testes, 2 falhas)6.80042093,8%Contagem total e traceback completo apenas dos 2 testes falhos
xcodebuild test (projeto modular iOS)31.5001.38095,6%Erros de compilação, arquivo/linha e falhas de XCTest
ls -laR em projeto web5.40069087,2%Árvore limpa sem metadados de permissão, usuário e node_modules
docker compose logs --tail 4009.10084090,8%Eventos ERROR/WARN deduplicados com contagem de ocorrências

Proxies CLI com hooks PreToolUse e filtragem semântica

A forma mais eficiente de cortar esse desperdício sem mudar o comportamento de cada ferramenta do sistema é colocar um proxy CLI entre o agente e o shell. Projetos escritos em Rust, como o RTK (Rust Token Killer), funcionam exatamente assim: um hook de PreToolUse intercepta o comando antes da execução, reescreve chamadas suportadas para o proxy e devolve ao modelo uma versão condensada de stdout e stderr.

Para que um filtro desse tipo seja seguro em produção, ele precisa obedecer a duas regras rígidas. Primeiro, nunca alterar o código de saída (exit code) do processo original, pois o agente depende dele para saber se um build ou teste falhou. Segundo, sempre gravar a saída bruta completa em um arquivo temporário quando houver truncamento, imprimindo o caminho do log no final do resumo. Se o filtro esconder alguma linha inesperada, o agente ou o desenvolvedor consegue ler exatamente o trecho bruto necessário sem repetir um build de cinco minutos.

O script em Python abaixo demonstra a lógica essencial de um condensador determinístico para logs de compilação e teste: remove sequências ANSI, deduplica avisos repetidos, preserva linhas de erro com contexto imediato e aplica um teto rígido de caracteres.

import re
import subprocess
import sys
import tempfile
from collections import Counter
from pathlib import Path

ANSI_RE = re.compile(r"\x1b\[[0-9;]*[a-zA-Z]|\r")
ERROR_RE = re.compile(r"(error:|failed|exception|traceback|assertionerror|fatal)", re.I)
WARN_RE = re.compile(r"(warning:|deprecated)", re.I)

def run_filtered(cmd: list[str], max_chars: int = 3500) -> int:
    proc = subprocess.run(cmd, capture_output=True, text=True)
    raw = (proc.stdout or "") + ("\n" + proc.stderr if proc.stderr else "")
    cleaned_lines = [ANSI_RE.sub("", line).rstrip() for line in raw.splitlines()]
    cleaned_lines = [line for line in cleaned_lines if line.strip()]

    errors: list[str] = []
    warnings: Counter[str] = Counter()

    for idx, line in enumerate(cleaned_lines):
        if ERROR_RE.search(line):
            start = max(0, idx - 1)
            end = min(len(cleaned_lines), idx + 4)
            errors.extend(cleaned_lines[start:end])
        elif WARN_RE.search(line):
            normalized = re.sub(r":\d+:\d+", ":L:C", line)
            warnings[normalized] += 1

    output_parts = [f"[exit_code={proc.returncode} total_lines={len(cleaned_lines)}]"]

    if errors:
        output_parts.append("--- FAILURES ---")
        output_parts.extend(dict.fromkeys(errors))
    else:
        output_parts.append("--- TAIL ---")
        output_parts.extend(cleaned_lines[-15:])

    if warnings:
        output_parts.append("--- REPEATED WARNINGS ---")
        for msg, count in warnings.most_common(5):
            output_parts.append(f"({count}x) {msg}")

    summary = "\n".join(output_parts)
    if len(summary) > max_chars:
        tmp = Path(tempfile.gettempdir()) / f"cli_raw_{proc.pid}.log"
        tmp.write_text(raw, encoding="utf-8")
        summary = summary[:max_chars] + f"\n[truncated: full log saved at {tmp}]"

    print(summary)
    return proc.returncode

if __name__ == "__main__":
    sys.exit(run_filtered(sys.argv[1:]))

Estabilidade de prefixo e engenharia de Prompt Caching

Reduzir o tamanho das saídas resolve metade da equação. A outra metade está em estruturar as mensagens para aproveitar o Prompt Caching oferecido pelos principais provedores de LLM. Nesse mecanismo, o servidor mantém em memória o estado computado (KV-cache) de um prefixo de prompt por alguns minutos ou até uma hora. Nas chamadas seguintes, tokens lidos diretamente do cache custam entre 75% e 90% menos e pulam boa parte do cálculo de prefill.

O erro mais comum que destrói a taxa de acerto de cache é inserir dados voláteis no topo do prompt de sistema. Um simples timestamp com segundos (Horário atual: 14:32:19), um UUID de requisição ou a lista de arquivos abertos ordenada de forma instável invalida o prefixo inteiro logo nos primeiros 50 tokens. Todo o bloco seguinte, incluindo milhares de tokens de regras de arquitetura e esquemas de ferramentas, precisa ser reprocessado do zero a cada turno.

Para manter o acerto de cache consistentemente acima de 75% em sessões iterativas, a ordenação dos blocos enviados à API deve ir estritamente do mais imutável para o mais dinâmico:

{
  "prompt_layout": [
    {
      "position": 1,
      "block": "system_instructions_and_repo_rules",
      "mutability": "static_per_session",
      "cache_breakpoint": true
    },
    {
      "position": 2,
      "block": "tool_schemas_sorted_alphabetically",
      "mutability": "static_per_session",
      "cache_breakpoint": true
    },
    {
      "position": 3,
      "block": "shared_reference_files_and_interfaces",
      "mutability": "changes_rarely",
      "cache_breakpoint": false
    },
    {
      "position": 4,
      "block": "conversation_turns_and_tool_outputs",
      "mutability": "append_only",
      "cache_breakpoint": true
    },
    {
      "position": 5,
      "block": "current_timestamp_git_branch_and_user_message",
      "mutability": "changes_every_turn",
      "cache_breakpoint": false
    }
  ]
}

Outro detalhe prático envolve o ciclo de vida das ferramentas registradas. Se um agente carrega 55 definições de ferramentas MCP no início da sessão, cada esquema JSON pode consumir entre 200 e 400 tokens, criando um imposto fixo de 12.000 a 20.000 tokens antes mesmo da primeira pergunta. Adotar carregamento sob demanda (lazy loading de esquemas de ferramentas) ou restringir o conjunto de ferramentas ao escopo real da tarefa corta esse custo fixo e ainda reduz erros de seleção de ferramenta, prática que complementa as barreiras descritas no artigo sobre guardrails e segurança em automações com IA.

Leitura seletiva de código e compactação entre subtarefas

Agentes mal configurados costumam abrir arquivos de 1.800 linhas inteiros apenas para checar a assinatura de um método ou alterar um campo de configuração. Ensinar o fluxo de trabalho a operar em duas fases economiza milhares de tokens por hora: primeiro uma busca estrutural por símbolo ou expressão regular (rg -n) para localizar exatamente a faixa de linhas relevante; depois a leitura restrita àquela janela com margem de 40 ou 60 linhas de contexto ao redor.

Quando uma subtarefa termina, por exemplo depois de diagnosticar um bug em um módulo de rede e validar os testes unitários, manter todas as tentativas intermediárias no histórico só atrapalha o próximo passo. A compactação de sessão substitui 30 turnos de exploração por um bloco curto contendo quatro itens concretos: arquivos modificados, decisões técnicas tomadas, comandos de teste já validados e hipóteses descartadas. Se o aprendizado valer para sessões futuras, ele sai do histórico temporário e passa para uma camada persistente, tema detalhado em arquitetura de memória de longo prazo para agentes de IA.

Métricas operacionais para acompanhar no time

Otimização de contexto só se sustenta quando vira métrica visível em vez de sensação subjetiva. Em equipes que rodam assistentes de programação ou agentes de revisão em CI/CD, quatro indicadores capturam rapidamente regressões de custo e latência:

  • Taxa de acerto de cache por sessão (cached_input_tokens / total_input_tokens), buscando manter acima de 70% em fluxos iterativos de codificação;
  • Mediana de tokens retornados por chamada de ferramenta, com alerta quando um comando de shell ou busca ultrapassa 2.000 tokens com frequência;
  • Custo médio em tokens por pull request entregue ou por tarefa encerrada, evitando otimizar apenas o tamanho de um único prompt às custas de dobrar o número de turnos;
  • Percentil 95 do tempo até o primeiro token (TTFT), que evidencia na prática quando a janela começou a ficar inchada demais para manter o ritmo de desenvolvimento fluido.

Combinando filtragem determinística de terminal, ordenação estável para Prompt Caching, leitura por faixa de linhas e compactação entre entregas, times de engenharia reduzem a fatura de API entre 60% e 80% ao mesmo tempo em que diminuem falhas de raciocínio causadas por excesso de ruído.