Por que o Claude Code envia 33k tokens antes do seu prompt (e o que fazer)

Entendendo a sobrecarga no uso de tokens do Claude Code

Toda ferramenta de programação com agentes carrega contexto antes mesmo de ver seu prompt. O modelo precisa saber quem é, quais ferramentas pode chamar e em que ambiente está operando. O Claude Code está entre as opções mais pesadas desse espectro. Uma inicialização a frio costuma ficar em torno de 33k tokens de preâmbulo; uma alternativa mínima como o OpenCode registra algo mais próximo de 7k.

Essa diferença é real, mas não é uma classificação de qualidade. É uma escolha de projeto. Os 33k proporcionam ferramentas integradas mais completas e um comportamento de agente mais confiável; os 7k proporcionam um volume menor e inicializações a frio mais baratas. Nenhuma opção é “correta” — são pontos diferentes em uma curva de capacidade versus custo.

Veja uma divisão aproximada de como o orçamento de tokens da inicialização do Claude Code é usado. Os números exatos mudam entre versões, então considere-os proporções, não constantes fixas:

A maior parcela quase sempre corresponde às definições de ferramentas. Isso surpreende quem espera que o prompt de sistema predomine.

Por que os esquemas de ferramentas são tão pesados

Cada ferramenta que o modelo pode chamar é fornecida como um esquema estruturado — nome, descrição e um esquema JSON completo para seus parâmetros. Uma única ferramenta bem documentada pode chegar a 500–1,500 tokens quando você contabiliza as descrições de parâmetros aninhados e as enumerações. O Claude Code habilita um conjunto padrão amplo (leitura e gravação de arquivos, edição, bash, glob, grep, busca na web, criação de tarefas/agentes, acompanhamento de pendências e muito mais), e todas essas ferramentas estão presentes em cada requisição.

Um esquema simplificado de uma ferramenta se parece aproximadamente com isto:

{
  "name": "edit_file",
  "description": "Make a targeted edit to an existing file. Use this instead of rewriting the whole file when possible...",
  "input_schema": {
    "type": "object",
    "properties": {
      "path": { "type": "string", "description": "Absolute path to the file" },
      "old_string": { "type": "string", "description": "Exact text to replace, including surrounding context for uniqueness" },
      "new_string": { "type": "string", "description": "Replacement text" }
    },
    "required": ["path", "old_string", "new_string"]
  }
}

Multiplique isso por mais de uma dúzia de ferramentas, depois acrescente todas as ferramentas expostas por qualquer servidor MCP que você tenha conectado, e a carga de esquemas cresce rapidamente. Uma armadilha comum: alguém instala três servidores MCP “para experimentar”, cada um expondo 8–15 ferramentas, e seu consumo de base aumenta em 10k tokens nos quais nunca mais pensa.

O contexto do ambiente que você não pediu

Quando o Claude Code inicia dentro de um repositório, ele injeta informações sobre o ambiente para que o agente não precise gastar uma interação fazendo perguntas básicas. Na prática, isso inclui coisas como:

Working directory: /home/ryan/projects/api-gateway
Platform: linux
Git branch: feature/rate-limiting
Git status: 4 modified, 1 untracked
Recent commits: ...

Isso é realmente útil — é por isso que o agente já sabe que você está em uma branch de funcionalidade —, mas continua consumindo tokens, e, em um monorepositório grande, o retrato dos diretórios pode ter um tamanho considerável.

O que essa sobrecarga realmente proporciona

Antes de eliminar isso com otimizações, avalie a contrapartida com honestidade. Esses 33k são o motivo pelo qual o Claude Code consegue, já na primeira resposta, editar o arquivo certo com o contexto adequado ao redor, executar seus testes, criar um subagente para uma tarefa paralela e respeitar as convenções do seu projeto — tudo sem uma rodada de perguntas de esclarecimento. Um agente de 7k tokens muitas vezes precisa obter esse contexto por meio de interações adicionais, o que significa mais requisições, mais latência e, às vezes, mais tokens no total ao longo de uma sessão completa.

Portanto, a comparação não é “33k desperdiçadores versus 7k eficientes”. É:

• Menos requisições, mais pesadas (Claude Code) versus mais requisições, mais enxutas (agentes mínimos)
• Capacidade disponível imediatamente versus capacidade construída sob demanda
• Maior custo fixo por sessão versus maior custo variável por tarefa

Em uma sessão de depuração com cinco mensagens, a sobrecarga fixa é bem amortizada. Em uma solicitação isolada de uma linha, parece desperdício. As duas reações são corretas em seus respectivos contextos.

Os ajustes que você de fato controla

Você não pode reescrever o conjunto central de ferramentas do Claude Code, mas três ajustes alteram significativamente seu consumo de base.

1. Enxugue o CLAUDE.md sem piedade

CLAUDE.md é injetado na íntegra em cada requisição. É a única parte do preâmbulo que está 100% sob seu controle, e é nela que vejo mais desperdício — arquivos de 4k tokens cheios de guias de estilo idealizados que o modelo já segue por padrão.

Mantenha-o enxuto e essencial. Prefira:

# Project: api-gateway

- Package manager: pnpm (never npm)
- Tests: `pnpm test` — must pass before any commit
- Do NOT edit files in /generated
- API errors use the AppError class in src/errors.ts

Exclua tudo o que o modelo faria de qualquer maneira (“escreva código limpo”, “adicione comentários”). Uma boa regra prática: se remover uma linha não mudaria o comportamento do agente, ela está custando tokens à toa. Para contexto aprofundado, coloque-o em um arquivo referenciado que o agente leia sob demanda em vez de colá-lo na memória.

2. Desative servidores MCP e ferramentas que você não usa

Esta é a medida de maior impacto para a maioria das pessoas. Revise o que está realmente conectado:

claude mcp list

Se você encontrar servidores que adicionou há meses e nunca usa, remova-os:

claude mcp remove some-unused-server

Você também pode limitar quais ferramentas são permitidas, mantendo seus esquemas fora do contexto. Nas configurações do projeto ou do usuário:

{
  "permissions": {
    "allow": ["Read", "Edit", "Bash", "Grep", "Glob"],
    "deny": ["WebFetch"]
  }
}

Cada ferramenta que você deixa de disponibilizar é um esquema pelo qual não precisa pagar para enviar a cada interação. Na prática, desativar um único servidor MCP com muitas definições já me poupou mais tokens do que qualquer ajuste de prompt.

3. Use intensamente o cache de prompts

Este é o ponto principal, e ele muda todo o cálculo. O prompt de sistema, as definições de ferramentas e o contexto estável do projeto são os mesmos em todas as requisições de uma sessão — o que os torna ideais para o cache de prompts. Tokens de entrada em cache são muito mais baratos do que tokens novos, então esse preâmbulo de 33k praticamente deixa de pesar após a primeira chamada.

O Claude Code usa cache automaticamente, mas você pode ajudar mantendo a parte estável do seu contexto realmente estável:

• Evite reescrever CLAUDE.md no meio da sessão — uma alteração invalida o cache do conteúdo que vem depois.
• Coloque o contexto estático no início; mantenha os detalhes que mudam nas suas mensagens, não no preâmbulo.
• A ordem importa: o cache funciona sobre um prefixo, então qualquer alteração no início invalida tudo o que vem depois.

A consequência prática: otimize a contagem de tokens da sua primeira requisição para reduzir o custo, mas otimize sua sessão para aproveitar o cache. Um prefixo estável de 33k que é armazenado em cache sem problemas costuma ser mais barato ao longo de uma sessão real de trabalho do que um prefixo de 7k que nunca entra em cache porque é reconstruído a cada interação.

Se você executa cargas de trabalho com agentes em grande volume e acompanha de perto o custo por token, é também aqui que um acesso à API mais barato — como o que a AI Prime Tech oferece para os modelos Claude — se combina bem com boas práticas de cache e amplia a economia.

Recomendações práticas

• O custo de inicialização de ~33k corresponde principalmente a esquemas de ferramentas, não ao prompt de sistema. As definições de ferramentas e os servidores MCP dominam o orçamento.
• É uma contrapartida, não desperdício. A sobrecarga proporciona capacidade imediata e menos trocas de mensagens; agentes mais enxutos transferem o custo de fixo para variável.
• Revise seus servidores MCP primeiro. Remover servidores não utilizados e bloquear ferramentas não utilizadas é a medida de redução com maior impacto.
• Mantenha o CLAUDE.md essencial. Exclua tudo o que o modelo faz por padrão; referencie documentação aprofundada sob demanda em vez de colá-la.
• Planeje para aproveitar o cache, não apenas para ter uma primeira requisição pequena. Um preâmbulo estável que é armazenado em cache sem problemas supera um pequeno que é reconstruído a cada interação.
• Meça por sessão, não por mensagem. Avalie a sobrecarga em relação à tarefa inteira, na qual os custos fixos são amortizados.