Nota do autor: Sem recorrer a canais de baixo custo e mantendo o preço original do modelo, detalho como o OpenClaw economiza dinheiro controlando o comprimento dos tokens de entrada: isolamento de novas tarefas de conversa, recuperação precisa de blocos de código em vez de despejo de texto completo, poda de contexto, busca local QMD e outras 6 estratégias.
O consumo de tokens do OpenClaw é famoso — há usuários que queimam 21,5 milhões de tokens em um único dia, com faturas mensais superiores a US$ 600. A primeira reação de muitos é mudar para canais de modelos mais baratos, mas isso sacrifica a qualidade. A verdadeira forma de economizar tokens é controlar a entrada — a quantidade de contexto que você fornece ao modelo é o fator determinante do custo. Este artigo foca em uma questão central: como reduzir os tokens de entrada de "despejo de texto completo" para "alimentação precisa", sem trocar de modelo e sem reduzir a qualidade.
Valor central: Ao terminar este artigo, você dominará 6 estratégias práticas para controlar os tokens de entrada, com uma economia esperada de 50-90% nos custos de tokens.
Pontos principais para economizar tokens no OpenClaw
Primeiro, vamos estabelecer uma premissa: este artigo trata de métodos para economizar tokens sem trocar de modelo e sem reduzir a qualidade. Você continua usando o Claude Opus 3.5 ou o GPT-4o (ou modelos equivalentes) com o mesmo desempenho, mas economizando na entrada (input).
| Estratégia | Taxa de economia | Dificuldade | Conceito central |
|---|---|---|---|
| Isolar tarefas em novos chats | 60-80% | Baixa | Inicie um novo chat para cada tarefa independente para evitar o acúmulo de histórico |
| Recuperação precisa de blocos de código | 40-95% | Média | Forneça apenas trechos de código relevantes, não o arquivo inteiro |
| Poda de contexto | 30-50% | Baixa | Limpe manualmente ou automaticamente o histórico de chat inútil |
| Busca local QMD | 80-90% | Média | Busca vetorial local, enviando apenas trechos relevantes |
| Prompt Caching | 80-90% (custo de input) | Baixa | Use cache para evitar o reenvio repetido de comandos do sistema |
| Desativar modo Thinking | 10-50x | Baixa | Desative o modo de raciocínio para tarefas que não exigem lógica complexa |
Mecanismos subjacentes do consumo de tokens no OpenClaw
Para economizar tokens, você precisa entender por que o OpenClaw consome tantos.
Toda vez que você envia uma mensagem no OpenClaw, ele não envia apenas a sua última frase — ele reenvia todo o histórico da conversa para o modelo. Quanto mais longa a conversa, maior o número de tokens de entrada em cada requisição.
Especificamente, a entrada de uma requisição contém:
- Comando do sistema (System Prompt): As instruções principais do OpenClaw, geralmente de 2000 a 5000 tokens.
- AGENTS.md / SOUL.md: Arquivos de configuração do espaço de trabalho.
- Skills carregadas: Cada Skill ativada consome tokens.
- Histórico completo da conversa: Todas as mensagens desde o início da sessão.
- Resultados de invocação do modelo: A saída de cada leitura de arquivo ou execução de comando.
- Resultados de busca na memória: Conteúdo relevante recuperado da base de memória.
Em uma sessão do OpenClaw que dura 30 minutos, a entrada da última mensagem pode facilmente atingir 100 mil ou até 1 milhão de tokens — sendo que a maior parte dos primeiros 29 minutos já não é útil para a tarefa atual.
Estratégia 1: Iniciar novos chats para tarefas diferentes no OpenClaw
Esta é a estratégia mais simples e eficaz.
Por que novos chats economizam tokens?
Imagine que você realizou 3 tarefas no mesmo chat: Corrigir Bug A → Escrever Funcionalidade B → Refatorar Módulo C. Na terceira tarefa, a entrada do modelo contém todo o histórico de conversas e resultados de leitura de arquivos das duas tarefas anteriores — mas isso é totalmente inútil para a refatoração do Módulo C.
Mesmo chat:
Histórico da tarefa A (20K tokens)
+ Conteúdo do arquivo da tarefa A (30K tokens)
+ Histórico da tarefa B (25K tokens)
+ Conteúdo do arquivo da tarefa B (40K tokens)
+ Mensagem atual da tarefa C (5K tokens)
= 120K tokens de entrada (dos quais 115K são "bagagem" histórica)
Novo chat:
Mensagem atual da tarefa C (5K tokens)
+ Comando do sistema (3K tokens)
= 8K tokens de entrada (economia de 93%)
Melhores práticas em cenários de chat
| Cenário | Iniciar novo chat? | Motivo |
|---|---|---|
| Mudar para uma tarefa totalmente diferente | Sim | O contexto da tarefa anterior é inútil |
| Ajustes iterativos na mesma funcionalidade | Não | Precisa do contexto da discussão anterior |
| Corrigir bugs diferentes em arquivos diferentes | Sim | Cada bug é independente, não precisa de contexto cruzado |
| Modificações contínuas no mesmo módulo | Não | O modelo precisa entender a intenção das alterações anteriores |
| Conversa com mais de 20 rodadas | Sim ou compactar | O acúmulo histórico já é muito grande |
🎯 Dica prática: Um critério simples — se você precisa dizer "esqueça o que dissemos antes, agora vamos fazer outra coisa", inicie um novo chat.
Este princípio não se aplica apenas ao OpenClaw, mas também ao Claude Code e outras ferramentas de codificação por IA. Cada requisição de API independente feita via APIYI (apiyi.com) é naturalmente um "novo chat", eliminando o problema de acúmulo de contexto.
Estratégia 2: Recuperação precisa de blocos de código com OpenClaw, sem sobrecarregar o contexto
Este é o ponto central deste artigo: como garantir que o modelo veja apenas os blocos de código que precisam ser alterados, em vez de enviar o arquivo inteiro ou até mesmo o projeto completo?
A essência do problema: Por que "enviar tudo" é um desperdício
Dados de pesquisa mostram que os agentes de codificação de IA desperdiçam 80% dos seus tokens apenas "procurando coisas". Cenário típico: você pede ao OpenClaw para modificar uma função, ele lê 25 arquivos apenas para encontrar as 3 funções realmente relevantes — e o custo em tokens da leitura desses 25 arquivos é debitado da sua conta.
Um arquivo de 1.000 linhas tem aproximadamente 15.000 a 25.000 tokens. Se você precisa modificar apenas 20 linhas (cerca de 300-500 tokens), mas o arquivo inteiro é fornecido ao modelo, 96-98% dos tokens de entrada são desperdiçados.
4 métodos para a recuperação precisa de blocos de código no OpenClaw
Método 1: Especifique claramente o arquivo e o número da linha
Não diga apenas "corrija a função de login". Diga: "modifique a função handleLogin nas linhas 45-78 do arquivo src/auth/login.ts". Quanto mais preciso for o comando, menos arquivos o OpenClaw precisará ler.
❌ "Corrigir bug de login"
→ OpenClaw lê 10+ arquivos, consome 200K+ tokens
✅ "Corrigir verificação de ponteiro nulo na linha 52 de src/auth/login.ts"
→ OpenClaw lê apenas a parte relevante de 1 arquivo, consome ~20K tokens
Método 2: Utilize a busca semântica local QMD
O QMD (Quick Memory Database) do OpenClaw pode criar índices vetoriais localmente, recuperando fragmentos de código relevantes e enviando apenas o conteúdo mais importante para o modelo.
Como ativar: ative o QMD nas configurações do OpenClaw; ele indexará automaticamente os arquivos do seu projeto e o histórico de conversas. Em consultas futuras, o QMD encontrará primeiro os blocos de código relevantes localmente e enviará apenas os fragmentos correspondentes ao modelo.
Método 3: Use a sintaxe @file para referência direta
No OpenClaw, você pode usar a sintaxe @file para referenciar arquivos com precisão, evitando que o modelo precise pesquisar por conta própria:
Modifique a função handleLogin em @src/auth/login.ts,
adicionando a lógica de tratamento para a expiração do refreshToken.
Consulte o método isTokenExpired em @src/token.ts.
Dessa forma, o OpenClaw carregará apenas os 2 arquivos que você especificou, em vez de escanear todo o diretório src/auth/.
Método 4: Guia de estrutura do projeto
Escreva uma visão geral da estrutura do projeto em AGENTS.md ou SOUL.md para que o OpenClaw saiba "qual funcionalidade está em qual arquivo", reduzindo a necessidade de varreduras exploratórias de arquivos.
## Estrutura do Projeto
- Autenticação: src/auth/ (login.ts, token.ts, session.ts)
- Gestão de usuários: src/user/ (profile.ts, settings.ts)
- Rotas da API: src/routes/ (auth.route.ts, user.route.ts)
Essa visão geral ocupa apenas algumas centenas de tokens, mas pode economizar dezenas de milhares de tokens em varreduras cegas de arquivos pelo OpenClaw.
Estratégias três a seis: Dicas avançadas do OpenClaw para economizar tokens
Estratégia três: Poda de contexto (Context Pruning)
O OpenClaw suporta a poda de contexto manual e automática. Quando a conversa se torna muito longa, você pode limpar as mensagens do histórico que não são mais necessárias.
O OpenClaw 2026.3.7 introduziu os Context Engine Plugins, permitindo que plugins de terceiros ofereçam estratégias alternativas de gerenciamento de contexto (anteriormente, essa parte era codificada diretamente no núcleo). O plugin lossless-claw pode comprimir o histórico da conversa sem perder informações cruciais.
Dicas práticas:
- Após concluir cada subtarefa, limpe manualmente as saídas de chamadas de ferramentas irrelevantes.
- Defina
contextTokens: 50000para limitar o tamanho da janela de contexto. - Use a função compact para comprimir o histórico da conversa.
Estratégia quatro: Busca semântica local QMD
O QMD (Quick Memory Database) é a funcionalidade de busca vetorial local do OpenClaw. Ele cria um banco de dados vetorial no dispositivo local, indexando o histórico de conversas e documentos. Ao realizar uma consulta, ele busca o conteúdo relevante localmente primeiro, enviando ao Modelo de Linguagem Grande apenas os fragmentos mais pertinentes.
Resultado: redução de 80-90% nos custos de tokens de entrada.
Estratégia cinco: Aproveitando o Prompt Caching
Tanto as famílias de modelos Claude quanto GPT suportam Prompt Caching — quando o comando do sistema ou o contexto usado com frequência não mudam, a API utiliza automaticamente uma versão em cache, reduzindo o custo de tokens de entrada em 80-90%.
Mas há uma limitação fundamental: a chamada do Claude via formato compatível com OpenAI (/v1/chat/completions) não suporta Prompt Caching; é obrigatório usar o formato nativo da Anthropic (/v1/messages). Se você fizer a invocação do modelo através da APIYI (apiyi.com), a plataforma oferece suporte ao Prompt Caching no formato nativo.
Estratégia seis: Desativar o Thinking em tarefas que não exigem raciocínio
O modo Thinking/Reasoning pode fazer o consumo de tokens disparar de 10 a 50 vezes. Se a tarefa atual não exigir um raciocínio profundo (como formatação simples, movimentação de arquivos ou substituição de texto), desativar o modo Thinking pode gerar uma economia significativa.
| Tipo de tarefa | Precisa de Thinking | Diferença de tokens |
|---|---|---|
| Análise complexa de bug | Sim | Consumo normal |
| Design de arquitetura | Sim | Consumo normal |
| Formatação simples | Não | Economia de 10-50x ao desativar |
| Mover/renomear arquivos | Não | Economia de 10-50x ao desativar |
| Gerar código boilerplate | Depende | Pode desativar para modelos simples |
Dica: O Context Compaction do Claude Code e a Poda de Contexto do OpenClaw resolvem o mesmo problema: controlar o acúmulo de tokens de entrada. Se você estiver usando ambas as ferramentas, pode gerenciar centralmente suas cotas de invocação do modelo através da APIYI (apiyi.com).
Comparação de economia de tokens: OpenClaw vs. Claude Code
Ambas as ferramentas enfrentam o mesmo problema, mas as soluções diferem.
Perguntas Frequentes
Q1: O que fazer se o modelo não entender o contexto do projeto ao iniciar uma nova conversa?
Utilize o sistema de memória do OpenClaw e o arquivo AGENTS.md. A memória recuperará automaticamente informações relevantes do contexto do projeto em novas sessões (enviando apenas os trechos mais pertinentes, em vez de todo o histórico). Defina a estrutura do projeto e as convenções principais no AGENTS.md, que será carregado automaticamente a cada nova sessão — isso é muito mais eficiente do que carregar 20 rodadas de histórico de conversas.
Q2: Como saber quantos tokens foram consumidos na sessão atual?
Os registros de conversa do OpenClaw são salvos em arquivos JSONL no diretório .openclaw/agents.main/sessions/, onde você pode verificar diretamente a quantidade de tokens de cada solicitação. Uma forma mais prática é usar o painel de uso do seu provedor de API — ao realizar a invocação do modelo via APIYI (apiyi.com), você pode visualizar o consumo preciso de tokens e os custos de cada solicitação no painel.
Q3: Qual a diferença entre QMD e uma busca direta com grep?
O grep faz uma correspondência exata — se você pesquisar por "handleLogin", só encontrará locais que contenham essa string. O QMD é uma busca semântica — se você pesquisar por "tratamento de erro de login do usuário", ele encontrará todos os blocos de código semanticamente relacionados, mesmo que o código não contenha as palavras "login" ou "tratamento de erro". A precisão da busca semântica é maior, enviando menos conteúdo irrelevante para o modelo e economizando mais tokens.
Q4: Por que o Heartbeat consome tantos tokens?
O mecanismo de Heartbeat (batimento cardíaco) do OpenClaw verifica periodicamente o status das tarefas. Se o intervalo for definido como muito curto (por exemplo, a cada 5 minutos), cada batimento enviará o contexto completo da sessão para o modelo — alguns usuários notaram que a função de verificação automática de e-mail consumiu US$ 50 em um único dia. Solução: aumente o intervalo do batimento ou pause o Heartbeat quando o monitoramento automático não for necessário.
Resumo
Pontos principais para economizar tokens no OpenClaw (sem trocar de modelo e sem perder qualidade):
- Tokens de entrada são o maior custo (70-85%): Reenviar todo o histórico da conversa a cada solicitação torna o diálogo mais caro conforme ele cresce. A forma mais simples de economizar é iniciar novas conversas para tarefas diferentes.
- A recuperação precisa de blocos de código é a maior alavanca: Passar de "enviar o arquivo inteiro" (120K tokens) para "enviar apenas o necessário" (4K tokens) economiza 96% na mesma modificação. Métodos: especifique números de linha, use referências @file, busca semântica QMD e declaração de estrutura no AGENTS.md.
- Caminho de otimização em três etapas: Resultados em 5 minutos (nova conversa + desativar Thinking, economiza 50%) → Resultados em 30 minutos (comandos precisos + limitar contexto, economiza 80%) → Longo prazo (QMD + Caching, economiza 97%).
Recomendamos gerenciar as invocações de API do OpenClaw através da APIYI (apiyi.com), que oferece estatísticas precisas de uso de tokens e monitoramento de custos, ajudando você a quantificar o efeito real de cada otimização.
📚 Referências
-
Guia de Uso de Tokens e Controle de Custos do OpenClaw: Documentação oficial de gerenciamento de tokens
- Link:
docs.openclaw.ai/reference/token-use - Descrição: Inclui configurações de
contextTokense otimização de Heartbeat.
- Link:
-
Prática de Economia de Tokens no OpenClaw: De $600 para $20: Estrutura completa de otimização em três estágios
- Link:
blog.laozhang.ai/en/posts/openclaw-save-money-practical-guide - Descrição: Contém parâmetros de configuração específicos e a proporção de economia esperada.
- Link:
-
80% do desperdício de tokens em agentes de codificação de IA ocorre na busca: Estudo sobre precisão de contexto
- Link:
medium.com/@jakenesler/context-compression-to-reduce-llm-costs - Descrição: Explica por que a recuperação precisa é mais eficaz do que aumentar a janela de contexto.
- Link:
-
Central de Documentação APIYI: Estatísticas de uso de tokens e monitoramento de custos
- Link:
docs.apiyi.com - Descrição: Suporta o gerenciamento de invocação do modelo para OpenClaw e Claude Code.
- Link:
Autor: Equipe Técnica APIYI
Troca de conhecimento: Sinta-se à vontade para discutir na seção de comentários. Para mais materiais, acesse a central de documentação da APIYI em docs.apiyi.com
