---
title: "Custo de um agente de código: passos, contexto e cache"
description: "Por que um agente de código custa mais por passo quanto mais tempo roda, como o cache muda o total e quando uma sessão fixa vence a cobrança por token, com contas."
url: https://broadrouter.com/pt/blog/ai-coding-agent-run-cost/
lang: pt-BR
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/ai-coding-agent-run-cost/) (atualizado em 2026-11-15).

# 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 2026-11-15

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.

## Pontos principais

-   A entrada total de uma execução é passos × contexto base + crescimento por passo × passos × (passos − 1) ÷ 2. O número de passos pesa mais do que qualquer outro fator.
-   Com histórico só de acréscimos, só os tokens adicionados desde a última chamada são novos. No exemplo calculado, isso deixa 94% da entrada de uma execução de 30 passos em cache.
-   Nos preços publicados pela BroadNet para o DeepSeek V4.1 Flash, a mesma execução de 30 passos custa cerca de 8 vezes mais sem cache do que com o cache no melhor caso.
-   Compactar ou editar o histórico inicial zera o cache. Faça isso raramente e em passos grandes.
-   Uma sessão fixa vence quando execuções por mês × custo por execução passa do preço do plano. Uma sessão roda uma requisição por vez, então o tempo por execução limita quantas execuções cabem num mês.

**Nesta página**

1.  Como o contexto cresce durante uma execução?
2.  Como fica uma execução de exemplo?
3.  Quanto o cache muda a conta?
4.  Como estimar a sua própria execução?
5.  O que faz uma execução custar mais do que a estimativa?
6.  Quando uma sessão fixa vence a cobrança por token?
7.  Onde a BroadNet Inference se encaixa

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](https://broadrouter.com/pt/blog/agent-token-budget/). 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](https://broadrouter.com/pt/glossary/context-window/). 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](https://broadrouter.com/pt/glossary/cached-input-tokens/). 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](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-ai-coding-agent-run-cost&utm_content=body) 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](https://broadrouter.com/pt/blog/prompt-structure-for-caching/).

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

Este script lê os preços atuais do [pricing.json](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-ai-coding-agent-run-cost&utm_content=body) 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:

```python
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](https://broadrouter.com/pt/blog/agent-token-budget/).
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](https://broadrouter.com/pt/glossary/reasoning-tokens/), 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](https://broadrouter.com/tools/agent-run-cost-estimator/) 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](https://broadrouter.com/pt/blog/long-running-agent-context-management/) 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](https://broadrouter.com/pt/blog/cut-coding-agent-llm-costs/) 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](https://broadrouter.com/pt/blog/flat-rate-vs-pay-per-token-llm-api/)).
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](https://broadrouter.com/tools/flat-rate-vs-per-token-calculator/).

| 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](https://broadrouter.com/pt/guides/unlimited-llm-api-sessions/).

Antes, confira um limite. A documentação da BroadNet lista tool calling só para o [GLM 5.3](https://broadrouter.com/pt/models/glm-5.3/) e o [Qwen3.8 27B](https://broadrouter.com/pt/models/qwen3.8-27b/), e nenhum dos dois está num plano fixo. Agentes que editam por texto, como o [Aider](https://broadrouter.com/pt/guides/aider-unlimited-deepseek/), 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.

Ferramentas gratuitas sobre o tema (em inglês)

-   [Agent run cost estimator](https://broadrouter.com/tools/agent-run-cost-estimator/) Context growth per step, total tokens and cost of one agent run, with a DeepSeek session comparison.
-   [LLM batch job planner](https://broadrouter.com/tools/llm-batch-job-planner/) Run time, binding limit, cost per model and the flat sessions needed to finish a big job by a deadline.
-   [Flat-rate vs per-token LLM cost calculator](https://broadrouter.com/tools/flat-rate-vs-per-token-calculator/) Break-even between an unlimited plan and paying per token, per agent.
-   [LLM rate limit and concurrency calculator](https://broadrouter.com/tools/llm-rate-limit-calculator/) Which limit binds first: RPM, TPM or concurrency, with Little's law.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

[Token](https://broadrouter.com/pt/glossary/token/)

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Tool calling (chamada de ferramentas)](https://broadrouter.com/pt/glossary/tool-calling/)

Tool calling, também chamado de function calling ou chamada de ferramentas, é um recurso de APIs de LLM em que o modelo devolve um pedido estruturado para executar uma função definida pelo desenvolvedor, com argumentos JSON. A aplicação executa a função e devolve o resultado; o modelo nunca executa código sozinho.

[Tokens de entrada em cache (cached input)](https://broadrouter.com/pt/glossary/cached-input-tokens/)

Tokens de entrada em cache são tokens do prompt que um provedor de LLM processou há pouco e pode reaproveitar de um cache em vez de calcular de novo, normalmente um prefixo repetido, como um system prompt ou um documento. Os provedores os cobram com uma tarifa menor que a dos tokens de entrada novos.

[Prompt de sistema (system prompt)](https://broadrouter.com/pt/glossary/system-prompt/)

O system prompt, ou prompt de sistema, é o texto de instruções que uma aplicação envia a um modelo de linguagem antes da conversa, em geral como mensagem com o papel system ou developer. Ele define o papel, as regras, o tom e o formato de saída do modelo, que deve segui-lo mesmo quando mensagens do usuário o contradizem.

[Tokens de entrada e de saída](https://broadrouter.com/pt/glossary/input-and-output-tokens/)

Tokens de entrada são os tokens que um modelo de linguagem lê em uma requisição, incluindo o system prompt, o histórico da conversa, as definições de ferramentas e as imagens. Tokens de saída são os que ele gera na resposta, incluindo o raciocínio. As APIs de LLM costumam cobrá-los separadamente, e a saída costuma custar mais.

[Agente de programação com IA (AI coding agent)](https://broadrouter.com/pt/glossary/coding-agent/)

Um agente de programação com IA é uma ferramenta de software em que um modelo de linguagem trabalha numa codebase em ciclo: lê arquivos, edita, roda comandos como os testes, lê a saída e decide o próximo passo até a tarefa terminar ou um limite ser atingido.

[Context compaction (compactação de contexto)](https://broadrouter.com/pt/glossary/context-compaction/)

Context compaction é a prática de resumir uma conversa que está chegando ao limite da janela de contexto e continuar a sessão a partir desse resumo, para que o agente mantenha decisões importantes e o estado, descartando histórico bruto como saídas antigas de ferramentas.

[Context engineering (engenharia de contexto)](https://broadrouter.com/pt/glossary/context-engineering/)

Engenharia de contexto é o trabalho de escolher e manter o conjunto de tokens que um modelo de linguagem vê a cada requisição, incluindo system prompt, definições de ferramentas, histórico, documentos recuperados e anotações, para que o modelo receba o menor conjunto de informações de alto sinal de que precisa para fazer bem a tarefa.

## 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.

## Continue lendo

-   [Orçamento de tokens de agentes: para onde vão os tokens de um loop](https://broadrouter.com/pt/blog/agent-token-budget/)
-   [10 formas de reduzir o custo de LLM de agentes de código, com economia](https://broadrouter.com/pt/blog/cut-coding-agent-llm-costs/)
-   [API de LLM com preço fixo ou por token: a conta do ponto de equilíbrio](https://broadrouter.com/pt/blog/flat-rate-vs-pay-per-token-llm-api/)
-   [Tokens de entrada em cache: como reduzir a conta de API de LLM](https://broadrouter.com/pt/blog/cached-input-tokens-explained/)
-   [Gestão de contexto para agentes de longa duração com janela de 1M](https://broadrouter.com/pt/blog/long-running-agent-context-management/)
-   [Claude Code com modelos abertos: proxies, endpoints nativos e limites](https://broadrouter.com/pt/blog/claude-code-with-openai-compatible-models/)
-   [OpenClaw e Hermes Agent com um modelo barato: setup e custos](https://broadrouter.com/pt/blog/openclaw-hermes-agent-cheap-model/)
-   [Guia: Como funcionam os planos de API de LLM ilimitada para agentes](https://broadrouter.com/pt/guides/unlimited-llm-api-sessions/)
-   [Guia: Rode o Aider no DeepSeek V4.1 Flash ilimitado](https://broadrouter.com/pt/guides/aider-unlimited-deepseek/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-ai-coding-agent-run-cost&utm_content=page-cta) ·

**Fontes**

-   [Referência da API da BroadNet Inference: campos de uso, cached\_tokens, o raciocínio conta para max\_tokens, limites (conferida em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-ai-coding-agent-run-cost&utm_content=sources)
-   [Página de preços e pricing.json da BroadNet Inference, preços atualizados em 2026-11-14 (conferidos em 2026-11-15) (em inglês)](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-ai-coding-agent-run-cost&utm_content=sources)
-   [Página de planos da BroadNet Inference: uma requisição por vez por sessão, sem medidor de tokens (conferida em 2026-11-15) (em inglês)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-ai-coding-agent-run-cost&utm_content=sources)
-   [Guia de prompt caching da OpenAI: correspondência de prefixo e tamanho mínimo para cache (conferido em 2026-11-15)](https://developers.openai.com/api/docs/guides/prompt-caching)
-   [Documentação da API da DeepSeek, context caching: unidades de cache nos limites das requisições (conferida em 2026-11-15)](https://api-docs.deepseek.com/guides/kv_cache)
