BroadRouter
Começar

Custo de uma execução de agente de código: passos, contexto e cache

Pela equipe da BroadNet Inference · 7 min de leitura · Publicado em

Um agente reenvia todo o contexto a cada passo, então a entrada cresce com o quadrado do número de passos: 60 passos custam cerca de 3,5 vezes a entrada de 30. O cache decide a maior parte da conta; com histórico só de acréscimos, mais de 90% da entrada pode ser cobrada pela tarifa de cache. Multiplique o custo por execução pelas execuções do mês e compare com uma sessão fixa.

Um agente de código não paga por tarefa. Paga por passo, e cada passo reenvia toda a conversa até ali. Por isso o custo de uma execução depende muito mais de quantos passos ela leva, e de quanto do contexto está em cache, do que do preço por token. Este post monta o custo de uma execução a partir dessas partes, com números, e mostra quando uma sessão de preço fixo vence o pagamento por token.

Para entender de onde vêm os tokens dentro de cada chamada (schemas de ferramentas, leituras de arquivos, histórico), veja para onde vão os tokens de um loop de agente. Este post trata da aritmética de uma execução inteira.

Como o contexto cresce durante uma execução?

Cada chamada contém:

  • um contexto base enviado em toda chamada: system prompt, definições de ferramentas, arquivos de regras, um mapa do repositório;
  • tudo o que os passos anteriores adicionaram: as respostas e chamadas de ferramenta do modelo, conteúdo de arquivos e saída de comandos;
  • a nova instrução ou o novo resultado de ferramenta.

Chame esse contexto base de B e os tokens que cada passo adiciona de g. O passo 1 envia B. O passo 2 envia B + g. O passo n envia B + (n − 1) × g. Somando tudo, uma execução de n passos envia:

Entrada total = n × B + g × n × (n − 1) ÷ 2

O segundo termo cresce com o quadrado do número de passos. É por isso que execuções longas surpreendem: o último passo de uma execução de 60 é muito maior que o primeiro, e cada passo no meio paga de novo por todos os anteriores.

Como fica uma execução de exemplo?

Pegue um agente com contexto base de 15.000 tokens (system prompt, uma dúzia de ferramentas e um mapa do repositório). Cada passo adiciona 3.000 tokens: um arquivo ou log de teste mais a própria resposta do modelo. Cada passo escreve 800 tokens de saída, raciocínio incluído.

Passos Entrada total Saída Maior chamada individual
10 285.000 8.000 42.000
30 1.755.000 24.000 102.000
60 6.210.000 48.000 192.000

Passar de 30 para 60 passos dobra o trabalho, mas multiplica a entrada por cerca de 3,5. A saída só dobra. Nessas execuções, a entrada é de 36 a 130 vezes a saída, e é por isso que o preço de entrada, e o de entrada em cache, são os que mais pesam para agentes.

A maior chamada também precisa caber na janela de contexto. 192.000 tokens cabem no DeepSeek V4.1 Flash e no GLM 5.3 (1.048.576 tokens cada) e no Qwen3.8 27B (262.144). Não cabem no Gemma 4 VL 26B (32.768): neste exemplo, a sétima chamada já é grande demais.

Quanto o cache muda a conta?

Os provedores cobram um prefixo de prompt repetido por uma tarifa menor de entrada em cache. Um agente que só acrescenta ao histórico envia sempre o mesmo prefixo e mais um pouco, então, no melhor caso, só os tokens adicionados desde a última chamada são novos:

Entrada nova (melhor caso) = B + (n − 1) × g

Todo o resto é acerto de cache. A fatia de entrada em cache sobe conforme a execução fica mais longa:

Passos Entrada nova, melhor caso Fatia em cache
10 42.000 85%
30 102.000 94%
60 192.000 97%

Agentes reais raramente chegam ao melhor caso, então vale dar preço a três cenários. Nos preços da BroadNet para o DeepSeek V4.1 Flash ($0.175 de entrada, $0.0055 em cache, $0.52 de saída por 1M de tokens, publicados em 2026-11-14), este é o custo de cada execução em relação ao melhor caso de 30 passos:

Passos Cache no melhor caso 80% em cache Sem cache
10 0,33× 0,39× 1,37×
30 1× 2,07× 8,11×
60 2,33× 6,84× 28,2×

Duas coisas chamam a atenção. Sem cache, uma execução de 60 passos custa 28 vezes uma execução de 30 passos bem cacheada. E o cache importa mais quanto mais longa fica a execução. No melhor caso de 30 passos, a saída é cerca de um terço do custo, a entrada nova menos da metade e a entrada em cache menos de um quarto; então, depois do cache, a próxima economia está na saída.

Cache não é algo que você liga. Depende de o provedor guardar o prefixo e de o seu agente não mudá-lo. O guia da OpenAI descreve correspondência exata de prefixo com um tamanho mínimo para cache. A API da própria DeepSeek guarda unidades de cache no fim da entrada e da saída de cada requisição, então uma requisição seguinte que estende a anterior pode acertar o cache. A página de preços da BroadNet diz que a entrada em cache não exige configuração, e a documentação informa os acertos em usage.prompt_tokens_details.cached_tokens quando o modelo os fornece. O catálogo de modelos da BroadNet lista o DeepSeek V4.1 Flash entre os “models we never ran on our hardware” (tradução: modelos que nunca rodamos no nosso hardware), e os Termos (§7.3) cobrem o modelo “when partner-hosted” (tradução: quando hospedado por parceiro), então na BroadNet ele é servido por meio de um parceiro. Meça a sua taxa de acerto em vez de supor os números da própria DeepSeek. Escreva o prefixo de forma que ele possa ir para o cache: estrutura de prompt para cache.

Como estimar a sua própria execução?

Este script lê os preços atuais do pricing.json público da BroadNet, então nunca fica desatualizado, e imprime os totais de tokens e o custo por execução para cada cenário de cache:

import json, urllib.request

PRICES = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
m = next(x for x in PRICES["models"] if x["id"] == "broadnet/deepseek-v4.1-flash")
p_in, p_cached, p_out = m["input_per_m"], m["cached_input_per_m"], m["output_per_m"]

def run_tokens(steps, base=15_000, growth=3_000, out_per_step=800, cache_rate=None):
    total_in = steps * base + growth * steps * (steps - 1) // 2
    if cache_rate is None:                      # best case: only new tokens miss
        new_in = base + (steps - 1) * growth
    else:
        new_in = round(total_in * (1 - cache_rate))
    return total_in, new_in, steps * out_per_step

def run_cost(total_in, new_in, out):
    return ((new_in * p_in) + (total_in - new_in) * p_cached + out * p_out) / 1e6

for steps in (10, 30, 60):
    for label, rate in (("best", None), ("80%", 0.8), ("none", 0.0)):
        t, n, o = run_tokens(steps, cache_rate=rate)
        print(f"{steps:>3} steps  cache {label:>4}  input {t:>9,}  new {n:>9,}  "
              f"output {o:>6,}  cost/run {run_cost(t, n, o):.4f} USD")

Troque os valores padrão pelos seus números. Não chute; leia-os de uma execução real:

  1. Registre prompt_tokens, prompt_tokens_details.cached_tokens e completion_tokens de cada chamada, como no post sobre o orçamento de tokens de um agente.
  2. B é o prompt_tokens da primeira chamada. g é o aumento médio de prompt_tokens de uma chamada para a seguinte.
  3. A saída por passo é a média de completion_tokens. Ela inclui os tokens de raciocínio, que são cobrados como saída.
  4. A sua taxa real de cache é a soma de cached_tokens dividida pela soma de prompt_tokens.

O estimador gratuito de custo por execução de agente faz a mesma conta no navegador, para você testar outros números de passos, taxas de crescimento e taxas de cache sem código.

O que faz uma execução custar mais do que a estimativa?

  • Retries. Uma chamada de ferramenta que falha ou um retry depois de um 429 é mais uma chamada com o contexto inteiro. Conte como passos.
  • Mudar o prefixo. Um timestamp no system prompt, ferramentas listadas em outra ordem ou um arquivo de regras editado no meio da execução transformam a entrada em cache de volta em entrada nova, do ponto da mudança em diante.
  • Compactação. Resumir o histórico encolhe o contexto, o que corta a entrada seguinte, mas o histórico novo nunca esteve em cache, então a chamada seguinte paga o preço cheio de entrada. Compacte raramente e em passos grandes; gerenciamento de contexto para agentes de longa duração explica quando.
  • Saída de ferramenta grande. Um log de teste de 20.000 linhas adicionado no passo 5 vai junto em todos os passos seguintes. Na fórmula, ele soma 20.000 × (passos restantes) tokens de entrada.
  • Esforço de raciocínio. Esforço alto pode multiplicar a saída por passo. Defina reasoning_effort como low para edições de rotina.
  • Andar em círculos. Um agente que leva 60 passos numa tarefa de 30 paga o quadrado, não o dobro. Um limite de passos é um limite de custo. Dez formas de reduzir o custo de agentes de código cobre as alavancas.

Quando uma sessão fixa vence a cobrança por token?

Transforme o custo por execução num valor mensal: custo mensal = custo por execução × execuções por mês. Depois compare com um plano de preço fixo. Na BroadNet, os planos cobrem o DeepSeek V4.1 Flash sem medidor de tokens: o Full Moon custa $60 por mês, o Orbit $15 por semana e o Meteor $1 por hora, cada um por sessão.

Execuções por mês para empatar = preço do plano ÷ custo por execução.

Duas coisas deixam essa comparação menos simples do que parece:

  1. A sua taxa de cache define o lado por token. Com uma taxa de cache alta, a cobrança por token no Flash é barata e você precisa de muitas execuções para passar de $60. Com uma taxa baixa, passa rápido. O post sobre preço fixo mostra o ponto de equilíbrio como volume mensal: cerca de 917 milhões de de entrada e 46 milhões de de saída com 80% em cache (a conta do ponto de equilíbrio).
  2. O tempo define o teto do lado fixo. Uma sessão roda uma requisição por vez. Se uma chamada leva em média 20 segundos (prefill, cerca de 800 tokens de saída a cerca de 100 tokens por segundo, mais o tempo das ferramentas), uma execução de 30 passos leva cerca de 10 minutos. Uma sessão comporta então no máximo umas seis execuções por hora. Mais agentes em paralelo precisam de mais sessões.

Para rajadas curtas, o Meteor funciona do mesmo jeito em escala menor: se cabem seis execuções numa hora, cada uma custa $1 ÷ 6. Compare isso com o custo por token de uma execução calculado pelo script. Para testar os seus volumes, use a calculadora de preço fixo vs por token.

O seu padrão Costuma sair mais barato
Poucas execuções curtas por dia Por token
Execuções longas com cache ruim Sessão fixa
Agentes rodando a maior parte do dia de trabalho Sessão fixa
Vários agentes em paralelo, o dia todo Uma sessão fixa por agente
Precisa de tool calling nativo na BroadNet Por token no GLM 5.3 ou no Qwen3.8 27B

Onde a BroadNet Inference se encaixa

A BroadNet informa os tokens em cache e de raciocínio no bloco usage, então você pode medir cada número acima nas suas próprias execuções. O DeepSeek V4.1 Flash tem preço baixo de entrada em cache e contexto de 1.048.576 tokens, e os planos ilimitados removem o medidor de tokens dele; como as sessões funcionam.

Antes, confira um limite. A documentação da BroadNet lista tool calling só para o GLM 5.3 e o Qwen3.8 27B, e nenhum dos dois está num plano fixo. Agentes que editam por texto, como o Aider, não precisam de chamadas de ferramenta nativas. Se o seu precisa, teste o DeepSeek V4.1 Flash com o seu agente antes de comprar um plano, ou reserve orçamento para GLM ou Qwen por token. E se o seu agente só roda de vez em quando, pagar por token normalmente vai custar menos do que qualquer plano fixo.

Perguntas frequentes

Quanto custa uma execução de um agente de código com IA?

Conte os tokens e depois dê preço a eles. No exemplo deste post, uma execução de 30 passos com contexto base de 15.000 tokens e 3.000 tokens adicionados por passo envia 1.755.000 tokens de entrada e 24.000 de saída. Quanto isso custa depende principalmente de quanto da entrada é cobrado pela tarifa de cache.

Por que uma execução mais longa custa desproporcionalmente mais?

Cada passo reenvia tudo o que veio antes. A entrada por passo cresce em linha reta, então o total de uma execução cresce com o quadrado do número de passos. Dobrar uma execução de 30 para 60 passos multiplica a entrada por cerca de 3,5 no exemplo calculado.

Que taxa de acerto de cache devo esperar de um agente de código?

Depende do agente e do provedor. Com histórico estritamente só de acréscimos, só os tokens mais novos ficam de fora, o que deu de 85% a 97% nos nossos exemplos. Histórico editado, timestamps no system prompt e pausas longas baixam a taxa. Meça pelo prompt_tokens_details.cached_tokens.

Quando uma sessão fixa sai mais barata do que a cobrança por token para um agente?

Quando custo por execução × execuções por mês passa do preço do plano. Na BroadNet, o Full Moon custa $60 por mês por sessão para o DeepSeek V4.1 Flash. Uso leve ou ocasional costuma sair mais barato por token.

Os tokens de raciocínio mudam a estimativa?

Sim. Eles são cobrados como saída, e a saída custa mais por token do que a entrada. Coloque na saída por passo o raciocínio que você medir. Na BroadNet, o completion_tokens_details.reasoning_tokens informa esse valor quando o modelo o fornece.

Ler em MarkdownPerguntar ao ChatGPTPerguntar ao ClaudePerguntar ao Perplexity