Custo de agentes de IA em produção: compute fixo, não preço por token
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".
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.
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.
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 passos, cada passo com probabilidade de falha que dispara um retry. Cada retry adiciona todo o histórico de tokens ao prompt. Após retries, o número de tokens processados é , onde é o crescimento médio de tokens por interação. Isso é uma progressão aritmética: o total de tokens cresce como , ou seja, quadraticamente em . Se não for limitado, o custo explode. No exemplo do suporte, se o histórico é 500 tokens e cada retry adiciona 200 tokens, após 5 retries o total é 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.
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.
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.
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.
Formalizado. O crescimento quadrático do custo em tokens com o número de retries (progressão aritmética ) é á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.