Por que agentes de IA usam tantos tokens (um exemplo de 20 passos)

Você faz uma pergunta a um agente, ele trabalha por alguns minutos, e a página de uso mostra centenas de milhares de tokens. Nada está quebrado. Um agente é um loop, e cada volta do loop reenvia tudo o que foi dito até agora (a lista de ferramentas, o histórico, o que as ferramentas retornaram) como tokens de entrada. A resposta que ele escreve é minúscula. O que ele lê repetidamente não é.

O que é um agente, em uma imagem#

Um modelo de chat responde uma vez. Um agente é o mesmo modelo dentro de um loop com ferramentas: ler um arquivo, pesquisar na web, executar um comando. E o modelo não lembra de nada entre chamadas. Imagine um assistente que esquece tudo cada vez que desliga: toda vez que liga de volta, você lê as anotações desde o início, depois adiciona uma linha. É assim que a API funciona.

A documentação de uso de ferramentas da Anthropic (verificada em 26 de outubro de 2026) descreve o loop assim:

1. Seu app envia a mensagem do usuário e a lista de ferramentas.
2. O modelo responde com stop_reason: "tool_use" e um bloco tool_use: qual ferramenta, com quais argumentos.
3. Seu app executa a ferramenta e envia uma segunda requisição. Ela contém as mensagens anteriores, a chamada de ferramenta do modelo, um bloco tool_result e a mesma lista de ferramentas.
4. O modelo responde, ou pede outra ferramenta, e o loop gira de novo.

A mesma página diz que requisições de uso de ferramentas são cobradas pelo total de entrada enviado, incluindo o parâmetro tools, mais a saída. Então o passo 3 nunca é "só a parte nova": é a conversa inteira de novo.

Request 1  tools + system + task
Request 2  tools + system + task + call 1 + result 1
Request 3  tools + system + task + call 1 + result 1 + call 2 + result 2
...

É o mesmo mecanismo de por que um chat longo custa mais, só que mais rápido. Um chat cresce uma mensagem quando você digita. Um agente cresce dois blocos a cada passo, e ninguém digita nada.

Três coisas viajam junto em cada passo#

A lista de ferramentas. Nomes, descrições e esquemas de parâmetros de cada ferramenta entram em toda requisição, mesmo quando o modelo não usa nenhuma delas nesta volta. A documentação acrescenta um pequeno extra: com ferramentas ativas, a API adiciona seu próprio prompt de uso de ferramentas, 286 tokens no Claude Sonnet 5.5, Opus 5.5 e Haiku 5.5, e outros modelos têm outras contagens.

O histórico. Sua tarefa, as chamadas de ferramenta anteriores do modelo, suas anotações.

Saída de ferramentas. Essa é a traiçoeira. Um arquivo que o agente leu, uma página de resultados de busca, um log de teste: uma vez que entra no histórico, é pago de novo em cada passo posterior.

Um token é um pequeno pedaço de texto, aproximadamente uma palavra curta ou parte de uma, e cada uma dessas três coisas é contada neles.

Uma execução de 20 passos, contada#

Digamos que você execute um pequeno agente de programação com três ferramentas (ler um arquivo, buscar, rodar testes) e dê a ele uma tarefa que leva 20 passos. Considere estas suposições:

• definições de ferramentas: 1.500 tokens, prompt de sistema: 500, sua tarefa: 200, então toda requisição começa com 2.200 tokens;
• em cada passo o modelo escreve uma chamada de ferramenta de 150 tokens, e a ferramenta retorna 800 tokens;
• ambos entram no histórico, então cada passo adiciona 950 tokens à próxima requisição.

Para obter o total da execução, some todas as 20 requisições. A base de 2.200 é enviada 20 vezes, e as rodadas são carregadas pelos passos posteriores: o passo 1 não carrega nenhuma, o passo 2 uma, e assim por diante até 19, o que dá 190 rodadas no total.

20 × 2.200 = 44.000

950 × 190 = 180.500

44.000 + 180.500 = 224.500 tokens de entrada, e 20 × 150 = 3.000 tokens de saída.

O agente escreveu 3.000 tokens e leu 224.500. Tokens de saída custam mais cada um do que tokens de entrada (veja tokens de entrada vs saída), mas há tão poucos deles que o lado da entrada ainda decide a conta. Aqui está essa execução com os preços atuais:

No DeepSeek-V4-Flash uma execução dessas sai por $0.0037, no GLM-5.3-Flash por $0.0046. Cem execuções são 22.450.000 tokens de entrada e 300.000 de saída: $0.367 no DeepSeek-V4-Flash. A tabela acima conta entrada e saída juntas, e no total os modelos de lá saem mais baratos que o OpenRouter.

A contagem de passos importa mais do que parece. Uma execução de 5 passos com as mesmas suposições:

5 × 2.200 = 11.000

950 × 10 = 9.500

11.000 + 9.500 = 20.500 tokens de entrada. Quatro vezes os passos deram cerca de onze vezes a entrada, porque cada novo passo também relê todos os antigos.

Onde cortar: quatro hábitos#

Um resultado de ferramenta é o lugar mais fácil de economizar. Digamos que uma execução de teste no passo 3 retorne um log de 4.000 tokens. Ele é então reenviado pelas 17 requisições que se seguem:

• antes: 4.000 × 17 = 68.000 tokens de entrada carregados por esse único log;
• depois, se a ferramenta retornar apenas as 40 linhas relevantes (cerca de 400 tokens): 400 × 17 = 6.800.

Mesma tarefa, mesma resposta, um décimo da entrada vinda desse único resultado. Isso dá quatro hábitos:

• Retorne menos das ferramentas. Linhas ao redor do erro, não o log inteiro; a função, não o arquivo inteiro. Há uma abordagem mais longa em mantendo a saída de ferramentas fora do contexto.
• Dê menos ferramentas ao agente. Toda definição viaja em toda requisição.
• Limite os passos e comece uma tarefa nova quando o histórico antigo não importa mais.
• Some o uso de cada passo, e pare a execução em um orçamento que você escolheu de antemão. Para o lado da estimativa, veja como estimar o custo de um agente de IA.

Conte sua própria execução#

Toda resposta informa quantos tokens consumiu de entrada e produziu de saída, em seu campo usage. Some-os em todos os passos e você tem os números reais do seu agente em vez das minhas suposições. Um esboço com o SDK Python da OpenAI apontado para a CheapTokens (messages e tools são do seu próprio agente):

from openai import OpenAI

client = OpenAI(base_url="https://api.cheaptokens.dev/v1", api_key="YOUR_API_KEY")

total_in = total_out = 0
for step in range(20):  # your agent loop
    resp = client.chat.completions.create(
        model="deepseek-ai/DeepSeek-V4-Flash-0731",
        messages=messages,
        tools=tools,
    )
    total_in += resp.usage.prompt_tokens
    total_out += resp.usage.completion_tokens
    # ...run the tool, append the result to messages

print(total_in, total_out)

Os dois totais entram direto na tabela de custos acima. Para históricos longos como este, o DeepSeek-V4-Flash oferece uma janela de contexto de 380K e até 32.768 tokens de saída por resposta, a um preço a qualquer hora; o GLM-5.3-Flash tem contexto de 390K e até 8.192 tokens de saída. A configuração está na documentação, o preço atual de cada modelo está na página de preços, e o modelo tem sua própria página, DeepSeek barato.