Inteligência Artificial

Custo de agentes de IA em produção: compute fixo, não preço por token

Por Vivian Kang
Pumpkin LabsPumpkin ExplainsEnsaio nº 17Produção
Onde o dinheiro some entre uma resposta e outra
Custo de
agentes de IA
em produção
Pumpkin Labs
Custo de agentes de IA em produção
Por Vivian Kang · Co-fundadora
pumpkinlabs.io
~13 min · jul 2026
Três eixos de custo · esquemático
Fig. 17
sys
hist
tools
out
tokens por chamada
01.
Contexto
o que entra
req
n1
n2
n3
n4
1 pergunta → n chamadas
02.
Loop
passos ocultos
$↑
·
·
·
×
·
·
latência →
fronteira de custo
03.
Trade-off
rápido = caro
O fio condutor → custo por tarefa, não por token
S01 · E17
Pumpkin Explica, #17
(Por que o custo só fica previsível quando você para de pagar por token)
TL;DR

A conta de um agente raramente é o que parece. A ilusão do custo médio faz equipes planejarem orçamentos e SLAs como se todo chamado consumisse R$ 0,10 e 2 segundos, mas a realidade é uma cauda de eventos raros que multiplica o custo por 40 vezes e a latência por 20 vezes. Essa variância não é ruído: ela vem de mecanismos estruturais, loops de retry, expansão de contexto, encadeamento de ferramentas e árvores de fallback. E tudo isso se retroalimenta: um retry aumenta o prompt, o contexto maior piora a acurácia, e a falha vira um novo retry, num ciclo que o custo médio nunca captura. A saída tem duas camadas: execução limitada (bounded execution), que cerca cada passo de limites determinísticos e corta a cauda antes dela explodir, e uma decisão de infraestrutura mais profunda, rodar modelos pequenos em compute fixo em vez de pagar APIs de terceiros por token. Quando você não paga por token, a variância de tokens deixa de virar variância de conta: o pior caso custa latência, não dinheiro. Este post mostra de onde vem a variância, por que ela escala em vez de se diluir, e por que compute fixo é o que torna o custo previsível de verdade.

Um agente de suporte ao cliente que custa R$ 0,08 e leva 2 segundos na maioria dos casos. No pior caso, estoque inconsistente, uma ferramenta que falha, um retry mal desenhado, e a mesma tarefa explode para R$ 3,20 e 45 segundos. O SLA quebra, a margem some, e ninguém viu isso no planejamento.

A economia dos agentes de IA está sendo discutida pelo lugar errado. A maioria dos projetos fala de custo médio por tarefa e ignora o que realmente quebra orçamentos, SLAs e confiança: a variância. A diferença entre o custo típico e o custo no pior caso não é um fator de dois ou três, é uma ordem de grandeza ou mais, e essa cauda longa não é acidental, ela é uma consequência direta de como os agentes são desenhados. A pergunta que o mercado deveria estar fazendo não é "como baratear o custo médio", é "como impedir que o pior caso aconteça".

01 — O diagnóstico

O custo de agentes de IA em produção é realmente previsível?

Planejar um sistema de agente usando o custo médio por tarefa é como planejar um orçamento familiar usando a média de gastos mensais sem considerar o mês em que o carro quebra. O custo médio esconde a assimetria: a maioria das tarefas custa pouco, mas uma fração pequena, imprevisível, custa dezenas de vezes mais. No exemplo do suporte, a tarefa típica, consultar estoque e gerar resposta, roda num modelo pequeno em poucos segundos. O problema é quando algo sai do roteiro: o banco de estoque retorna inconsistente, a ferramenta de histórico de cliente está em timeout, ou a pergunta do usuário exige uma verificação que o modelo pequeno não consegue fazer sozinho. De repente a tarefa aciona um retry, depois um fallback para um modelo maior, depois um loop de reconsulta, e o custo dispara.

A literatura documenta esse fenômeno de forma ampla. Estudos de confiabilidade de agentes mostram que, sob perturbações realistas, a taxa de sucesso pode cair cerca de 9 pontos percentuais, e cada falha dispara um gasto extra que o custo médio jamais projeta. O problema não é que o agente falhe, é que a falha custa muito mais que o acerto, e a diferença cresce com cada camada de fallback.

02 — As fontes

De onde vem a variância no custo de agentes de IA em produção?

A variância não tem uma causa única, mas algumas fontes se repetem em todo agente em produção. A primeira é a expansão de tokens no contexto. Quando um retry acontece, o histórico completo da conversa é reenviado, então cada tentativa adicional não soma só os tokens da nova chamada, ela ressubmete todo o prompt acumulado. Um agente de 5 passos com 20% de taxa de retry por passo vê o custo em tokens subir para mais de 2 vezes o baseline, e esse crescimento é quadrático no tamanho do contexto, não linear no número de passos.

A segunda fonte são os retry loops mal limitados. Pesquisas empíricas mostram que, em certos benchmarks, mais de 90% das tentativas de retry foram desperdiçadas em nomes de ferramentas alucinados ou inexistentes. O agente inventa uma ferramenta que não existe, a chamada falha, ele tenta de novo com uma alucinação ligeiramente diferente, e assim sucessivamente. Sem um limite de tentativas, o loop pode consumir milhares de tokens e dezenas de segundos sem nunca resolver a tarefa.

A terceira fonte são as árvores de fallback. Quando um modelo pequeno não consegue responder, o desenho típico é subir para um modelo maior, que custa de 40 a 100 vezes mais por token. Se esse segundo modelo também falha, a cadeia pode continuar para um terceiro nível, e cada degrau multiplica o custo. O problema é quando um bug de configuração ou um padrão de erro inesperado faz com que toda requisição passe pela árvore inteira, mesmo quando o caso era simples. O custo médio então não é mais o custo do modelo pequeno, é uma média ponderada que esconde picos de 100 vezes o baseline.

03 — O mecanismo

Por que agentes falham explosivamente e não gradualmente

O comportamento de um agente não é linear, e é isso que torna a variância perigosa. Um pequeno erro numa chamada de ferramenta pode deflagrar uma cascata: o retry aumenta o contexto, o contexto maior reduz a acurácia do modelo, a resposta errada leva a uma nova chamada de ferramenta errada, e o ciclo se realimenta. Esse fenômeno, documentado em estudos de resiliência de agentes, mostra que a degradação não é gradual, ela acelera com o número de passos.

Para ver isso numericamente, considere um agente com nn passos, cada passo com probabilidade pp de falha que dispara um retry. Cada retry adiciona todo o histórico de tokens HH ao prompt. Após kk retries, o número de tokens processados é H+(H+Δ)+(H+2Δ)+⋯+(H+kΔ)H + (H + \Delta) + (H + 2\Delta) + \dots + (H + k\Delta), onde Δ\Delta é o crescimento médio de tokens por interação. Isso é uma progressão aritmética: o total de tokens cresce como k⋅H+k(k+1)2Δk \cdot H + \frac{k(k+1)}{2}\Delta, ou seja, quadraticamente em kk. Se kk não for limitado, o custo explode. No exemplo do suporte, se o histórico HH é 500 tokens e cada retry adiciona 200 tokens, após 5 retries o total é 5⋅500+15⋅200=2500+3000=55005 \cdot 500 + 15 \cdot 200 = 2500 + 3000 = 5500 tokens, contra 500 tokens do caso sem retry. Isso é um aumento de 11 vezes, e o custo em dólares escala na mesma proporção.

A realimentação agrava ainda mais: contextos maiores reduzem a acurácia do modelo, aumentando a probabilidade de novas falhas. Um estudo mostrou que, para cada duplicação do tamanho do prompt, a taxa de erro em tarefas de raciocínio pode subir de 5% para 12%. Isso fecha o ciclo: mais tokens, mais erros, mais retries, mais tokens. O ponto de inflexão acontece quando a probabilidade de falha ultrapassa um limiar, e o sistema passa de operação estável para colapso de custo.

04 — O efeito composto

Custo sobe, latência sobe, confiabilidade cai: tudo da mesma raiz

O que muita equipe descobre tarde demais é que custo, latência e confiabilidade não são três problemas separados. Eles compartilham a mesma raiz: a falta de limites no comportamento do agente. Cada retry aumenta o custo e a latência ao mesmo tempo, e cada aumento de latência torna o sistema menos previsível, o que reduz a confiabilidade de SLAs. Além disso, contextos maiores, devido a retries, pioram a precisão do modelo, geram mais erros, e o ciclo se retroalimenta.

O efeito composto é um gradiente de degradação que a literatura mede de forma consistente: à medida que a taxa de falhas injetadas sobe, a queda de desempenho não é linear, é acelerada. Um agente de 5 passos sofre muito mais que um de 3 passos, porque cada passo adicional multiplica o risco de um retry e a expansão de contexto. No limite, o sistema pode passar de confiável a quebrado com apenas alguns pontos percentuais a mais de falhas externas. A variância não é um ruído de fundo, é o mecanismo central de colapso.

Bounded execution não é um detalhe de implementação, é a diferença entre um sistema que você monitora e um sistema que você apaga no meio da madrugada.

05 — O princípio

Execução limitada (bounded execution) como resposta à variância

A resposta à variância não é tentar eliminar toda falha, é garantir que nenhuma falha possa escalar fora de controle. Esse princípio se chama execução limitada (bounded execution): cercar cada passo do agente com barreiras determinísticas que impedem loops infinitos, explosão de tokens e cascatas de fallback.

As práticas estão se consolidando em torno de algumas camadas. Um limite de tentativas por requisição é o mínimo, mas não basta: é preciso também um tracker de taxa de retry em janela deslizante que recuse novas tentativas quando a proporção ultrapassa certo limiar, porque cada retry tem um custo acumulado de prompt que não aparece no contador de tentativas. Timeouts por sessão, na ordem de centenas de segundos, impedem que um agente consuma recursos infinitos. Circuit breakers de custo agregado param o agente quando o gasto acumulado ultrapassa um limite, por exemplo, US$ 50 de alerta, US$ 100 de parada. E uma pinagem de modelo obriga cada tarefa a declarar exatamente qual modelo usa, evitando que um bug de configuração roteie requisições baratas para modelos de fronteira.

06 — A Pumpkin

Onde a Pumpkin entra: compute fixo em vez de preço por token

A Pumpkin não vende modelos melhores, vende harness engineering: a camada de estrutura determinística que embrulha o núcleo probabilístico do LLM. Mas, quando o assunto é custo, o harness sozinho não é a parte mais importante. A decisão que muda o jogo é anterior a ele: a gente roda modelos pequenos em compute próprio, um custo fixo de infraestrutura, em vez de chamar APIs de terceiros que cobram por token.

Essa escolha ataca a variância na raiz do preço. Todo o mecanismo que este post descreveu, retry que ressubmete o contexto, expansão de tokens, fallback para um modelo maior, só vira dinheiro porque cada token tem um preço marcado. Num modelo de preço por token, a variância de tokens é a variância da conta: dobrar os tokens dobra o custo. Com compute fixo, essa ligação se rompe. A GPU já está paga, esteja ela processando 500 tokens ou 5.500. Um pico de tokens ainda custa alguma coisa, mas essa coisa é latência e capacidade, não uma linha a mais na fatura. O pior caso deixa de ser um evento financeiro e vira um evento de engenharia, do tipo que o bounded execution já sabe conter.

Com preço por token, a variância de tokens é a variância da conta. Com compute fixo, o pior caso custa latência, não dinheiro.

O harness entra como a disciplina que mantém esse compute sob controle. Cada passo do agente tem limites explícitos: número de tentativas por ferramenta, tamanho máximo de prompt, orçamento por sessão, e um circuit breaker que corta a execução antes da cauda. O fallback de modelo não é uma árvore solta que escala preço, é uma decisão orquestrada entre modelos que já são nossos: o pequeno roda a maior parte dos passos e o maior só entra quando o caso exige, sem que isso signifique multiplicar uma fatura por token. O resultado é um custo que se aproxima do típico não porque a cauda foi só aparada, mas porque ela nunca chega ao boleto. E o SLA vira algo confiável, porque a latência máxima é limitada por timeout, não por loop infinito.

A lição é econômica e arquitetural ao mesmo tempo. A economia dos agentes de IA parece quebrada porque se planeja pelo custo médio de um preço por token que amplifica cada falha. Consertar isso não exige um modelo melhor, exige tirar o token da conta: compute fixo para desacoplar custo de volume, e bounded execution para manter o volume dentro do que a estrutura aguenta. É exatamente esse contrato que a gente constrói.

O que está provado e o que é interpretação

Formalizado. O crescimento quadrático do custo em tokens com o número de retries (progressão aritmética k⋅H+k(k+1)2Δk \cdot H + \frac{k(k+1)}{2}\Delta) é álgebra simples; a relação entre tamanho de contexto e acurácia decrescente tem suporte empírico em múltiplos estudos (Liu et al., 2024; Li et al., 2024). O princípio de bounded execution é uma técnica de engenharia de sistemas, não um teorema.

Robusto (suporte empírico). Que loops de retry não limitados causam explosão de custo é documentado em incidentes reais (ex: 1,6 bilhão de tokens em horas). Que a taxa de erro aumenta com o tamanho do prompt é medido em benchmarks de raciocínio. Que fallbacks em cascata multiplicam custo é consequência direta dos preços de API.

Interpretação (consistente, não um teorema fechado). Que a variância é o mecanismo central de colapso, e não um ruído, é a tese do post. Ela é consistente com a literatura e com a experiência de produção, mas não há um teorema que prove que todo agente sem limites colapsa. A interpretação serve como modelo mental para desenho de sistemas.

FAQ · Perguntas frequentes

Por que o custo de agentes de IA em produção varia tanto?

O custo varia porque a maioria dos agentes não tem limites nos loops de retry, na expansão de contexto e nas árvores de fallback, e porque paga por token: cada token a mais é dinheiro a mais. Uma tarefa simples pode se transformar em dezenas de chamadas quando uma ferramenta falha, e o custo médio esconde esses picos. A variância não é ruído, é a soma de um desenho sem barreiras determinísticas com um modelo de preço que cobra por volume.

Por que o custo de agentes de IA na Pumpkin é previsível?

Porque a Pumpkin roda modelos pequenos em compute fixo, e não em APIs de terceiros que cobram por token. Quando o custo é de infraestrutura e não de volume, um pico de tokens vira latência, não uma conta maior. Isso desacopla o custo da variância de tokens, a principal fonte de estouro de orçamento em agentes, e o bounded execution mantém a latência sob controle.

Como evitar que o custo de agentes de IA em produção exploda?

A resposta é a execução limitada (bounded execution): limites explícitos de tentativas por ferramenta, timeouts por sessão, circuit breakers de custo agregado e pinagem de modelo. Essas barreiras impedem que um erro isolado se transforme numa cascata. O harness engineering da Pumpkin implementa todas essas camadas de forma integrada.

O que é bounded execution em agentes de IA?

Bounded execution é o princípio de cercar cada passo do agente com limites determinísticos: número máximo de tentativas, tamanho máximo de prompt, orçamento de tokens por sessão e fallbacks controlados. O objetivo não é eliminar falhas, é garantir que nenhuma falha possa escalar fora de controle.

Qual a diferença entre custo médio e variância de custo em agentes?

O custo médio diz quanto uma tarefa típica custa. A variância captura quanto o custo pode desviar desse valor nos piores casos. Num agente sem limites, a variância pode ser de 40 vezes ou mais, enquanto o custo médio parece baixo. Planejar pelo custo médio é ignorar o risco que realmente quebra orçamentos e SLAs.

Como loops de retry afetam o custo de agentes de IA?

Cada retry ressubmete o histórico completo da conversa, então o custo em tokens cresce de forma quadrática com o tamanho do contexto. Sem um limite de tentativas, um loop de retry pode consumir milhares de tokens sem resolver a tarefa. Mais de 90% dos retries em alguns benchmarks são desperdiçados em alucinações de nomes de ferramentas.

O que fazer quando um agente de IA entra em loop infinito?

Implementar um circuit breaker monitorando o gasto acumulado (em tokens ou em dólares) e um timeout por sessão. Quando o gasto ultrapassa um limite, o agente é interrompido. Além disso, um tracker de taxa de retry em janela deslizante recusa novas tentativas se a proporção for muito alta. Essas barreiras cortam o loop antes dele explodir o orçamento.
A economia dos agentes não precisa ser uma aposta. O que torna o custo previsível não é adivinhar melhor a média, é remover a fonte da variância na conta: rodar modelos pequenos em compute fixo, onde o volume de tokens não move o preço, e cercar esse compute com bounded execution para que nem a latência escape. Um pico deixa de ser um susto na fatura e vira só mais um caso que a estrutura já aguenta. É esse contrato, custo previsível por desenho, que a gente entrega.

Gostou do conteúdo?

Entre em contato conosco para descobrir como implementar essas soluções na sua empresa.