Agente precisa de "indicador de combustível" e "freio": um artigo revela as "contas confusas" do Agente

null

Imagine este cenário:

Você pede ao AI Agent para ajudar a corrigir um bug no código. Ele abre o projeto, lê 20 ficheiros, faz algumas alterações, executa os testes, não passa, altera de novo, executa novamente, ainda não passa… rodando várias vezes, finalmente — ainda não resolveu.

Desliga o computador, respira fundo. E então recebe a fatura da API.

Os números acima podem fazer você ficar de cabelo em pé — o AI Agent autônomo para corrigir bugs, usando a API oficial internacional, costuma consumir mais de um milhão de tokens por tarefa não resolvida, com custos de dezenas a mais de cem dólares.

Em abril de 2026, um artigo de pesquisa publicado em colaboração por Stanford, MIT, Universidade de Michigan e outros, abriu pela primeira vez a “caixa preta” do consumo de recursos do AI Agent em tarefas de código — para onde vai o dinheiro, se vale a pena, se é possível prever antecipadamente, as respostas são chocantes.

Descoberta 1: O custo de escrever código com Agent é 1000 vezes maior que uma conversa comum com IA

Talvez você ache que pedir ao AI para escrever código ou apenas conversar sobre código deveria custar aproximadamente o mesmo, certo?

O artigo mostra uma comparação:

O consumo de tokens em tarefas de codificação com Agent é cerca de 1000 vezes maior do que em perguntas e raciocínios de código comuns.

Um aumento de três ordens de magnitude.

Por quê? O artigo aponta um fato — o dinheiro não é gasto na “escrita de código”, mas na “leitura de código”.

Aqui, “leitura” não é leitura humana, mas o fato de que o Agent, durante o trabalho, precisa constantemente “alimentar” o modelo com o contexto do projeto, histórico de operações, mensagens de erro, conteúdo dos ficheiros. Cada rodada de diálogo aumenta o comprimento do contexto; e o modelo é cobrado por tokens — quanto mais você alimenta, mais paga.

Por exemplo: é como contratar um mecânico que, antes de usar a chave de fenda, precisa que você leia toda a planta do prédio para ele — pagar para ler o projeto é muito mais caro do que pagar para apertar parafusos.

O artigo resume esse fenômeno em uma frase: o custo do Agent é impulsionado pelo crescimento exponencial de tokens de entrada, não de saída.

Descoberta 2: O mesmo bug, rodando duas vezes, pode custar o dobro — e bugs mais caros são mais instáveis

Outro problema é a aleatoriedade.

Os pesquisadores fizeram o mesmo Agent rodar 4 vezes na mesma tarefa, e os resultados mostraram:

Entre tarefas diferentes, a mais cara consumiu cerca de 7 milhões de tokens a mais que a mais barata (Figura 2a)

Na mesma tarefa, com o mesmo modelo, a execução mais cara foi aproximadamente o dobro da mais barata (Figura 2b)

E, ao comparar diferentes modelos na mesma tarefa, a variação de consumo pode chegar a 30 vezes

O último número é especialmente importante: isso significa que a diferença de custo entre usar o modelo certo ou errado não é “um pouco mais caro”, mas uma questão de uma ordem de grandeza.

Mais doloroso ainda — gastar mais não significa fazer melhor.

O artigo revela uma curva em “U” invertido:

O nível de custo e a precisão do resultado têm uma relação: custos baixos geralmente indicam baixa precisão (talvez por falta de investimento), custos médios tendem a ser os mais altos, e custos elevados podem até diminuir, entrando na “zona de saturação”.

Por quê? A análise do funcionamento do Agent explica:

Em operações de alto custo, o Agent gasta muito tempo em “trabalho repetitivo”.

Os pesquisadores descobriram que, em operações de alto custo, cerca de 50% das verificações e modificações de ficheiros são repetidas — ou seja, o Agent fica relendo o mesmo ficheiro, alterando a mesma linha várias vezes, como alguém que gira em círculos na sala, ficando cada vez mais tonto.

Dinheiro não é gasto na resolução do problema, mas em “perder o caminho”.

Descoberta 3: A “eficiência energética” entre modelos varia muito — GPT-5 é o mais econômico, outros modelos gastam até 1,5 milhão de tokens a mais

Na avaliação de 8 modelos avançados, usando o padrão SWE-bench Verified (500 issues reais do GitHub), a conversão em dólares mostra que modelos mais eficientes em tokens podem fazer a mesma tarefa por dezenas de dólares a menos. Para aplicações empresariais, rodando centenas de tarefas por dia, essa diferença é de dinheiro de verdade.

Outro achado interessante: a eficiência em tokens é uma “característica intrínseca” do modelo, não algo que depende da tarefa.

Ao comparar tarefas resolvidas por todos os modelos (230) e tarefas que nenhum conseguiu resolver (100), a classificação relativa dos modelos quase não muda.

Ou seja: alguns modelos são naturalmente “mais verbosos”, independentemente da dificuldade da tarefa.

Outro ponto importante: os modelos não têm “consciência de limite”.

Quando enfrentam tarefas difíceis que parecem impossíveis, o ideal seria que o Agent desistisse cedo, economizando tokens. Mas, na prática, eles gastam mais tokens em tarefas que falham — não “reconhecem” a derrota, continuam explorando, tentando, relendo o contexto, como um carro sem indicador de combustível que continua rodando até parar.

Descoberta 4: O que os humanos acham difícil, o Agent nem sempre acha caro — percepção de dificuldade totalmente desalinhada

Você pode pensar: “Se a tarefa é difícil, posso estimar o custo antes, né?”

Os pesquisadores pediram a especialistas humanos que avaliassem a dificuldade de 500 tarefas, e compararam com o consumo real de tokens pelo Agent —

E o resultado: há apenas uma fraca correlação.

Em linguagem simples: tarefas que os humanos acham extremamente difíceis podem ser resolvidas pelo Agent com pouco custo; tarefas que parecem fáceis para humanos podem consumir uma fortuna.

Por quê? Porque a percepção de dificuldade entre humanos e IA é completamente diferente:

Humans consideram: complexidade lógica, dificuldade de algoritmos, entendimento do negócio

O Agent avalia: tamanho do projeto, quantidade de ficheiros, profundidade de exploração, se vai reler o mesmo ficheiro várias vezes

Um especialista que acha “só uma linha” para corrigir um bug, pode precisar entender toda a estrutura do código antes — só a “leitura” já consome muitos tokens. Por outro lado, um problema que parece “complexo” para humanos, pode ter uma solução padrão que o Agent conhece e resolve rapidamente.

Isso leva a uma realidade desconcertante: é quase impossível para desenvolvedores preverem, por intuição, o custo de execução do Agent.

Descoberta 5: Até o próprio modelo não consegue estimar quanto vai gastar

Se os humanos não conseguem, por que não deixar a IA prever?

Os pesquisadores criaram um experimento: antes de começar a corrigir o bug, o Agent deve “inspecionar” o código e estimar quantos tokens vai gastar — sem realmente fazer a correção.

E o resultado?

Todos os modelos fracassaram.

A melhor correlação foi do Claude Sonnet-4.5 na previsão de tokens de saída — 0,39 (sendo 1,0 perfeito). A maioria ficou entre 0,05 e 0,34, e Gemini-3-Pro foi o pior, com apenas 0,04 — praticamente um chute.

Ainda mais: todos os modelos subestimaram sistematicamente seu consumo de tokens. No gráfico da Figura 11, quase todos os pontos estão abaixo da linha de previsão perfeita — eles acham que gastarão menos do que realmente gastaram. E essa subestimação é ainda mais grave sem exemplos de referência.

E o mais irônico: fazer a previsão também custa dinheiro.

Prever o consumo de tokens do próprio modelo pode custar até o dobro do que gastar na tarefa real. Ou seja: pedir ao modelo que estime o custo antes de executar é mais caro do que fazer a tarefa de fato.

A conclusão do artigo é direta:

Atualmente, os modelos de ponta não conseguem prever com precisão seu próprio consumo de tokens. Clicar em “executar Agent” é como abrir uma caixa de surpresas — só ao ver a fatura você sabe quanto gastou.

Por trás dessa confusão, há um problema maior na indústria:

E você pode estar se perguntando: o que tudo isso significa para as empresas?

1. O modelo de assinatura “por assinatura mensal” está sendo desfeito pelo consumo do Agent

O artigo aponta que, enquanto o ChatGPT Plus funciona porque o consumo de tokens em conversas comuns é relativamente controlado e previsível, as tarefas com Agent quebram essa premissa — uma única tarefa pode consumir uma quantidade enorme de tokens por causa de loops e repetições.

Isso sugere que, por enquanto, o pagamento por uso (pay-as-you-go) é a única opção viável, pois o uso não é previsível.

2. Eficiência em tokens deve ser um “terceiro critério” na escolha do modelo

Tradicionalmente, empresas escolhem modelos por capacidade (consegue fazer?) e velocidade (é rápido?). Este estudo acrescenta um terceiro fator: eficiência (quanto custa fazer).

Um modelo um pouco menos capaz, mas 3 vezes mais eficiente, pode ser mais econômico em escala do que o mais potente, mas mais caro.

3. O Agent precisa de “indicador de combustível” e “freio”

O artigo sugere uma direção futura: políticas de uso de ferramentas “conscientes do orçamento”. Ou seja, equipar o Agent com um “indicador de combustível”: quando o consumo de tokens estiver perto do limite, ele deve parar de explorar, ao invés de continuar gastando sem controle.

Hoje, quase todos os frameworks de Agent carecem dessa mecânica.

O problema de “gastar demais” não é um bug, mas uma dor inevitável na evolução do setor.

A pesquisa revela que esse não é um problema de um modelo específico, mas uma questão estrutural de todo o paradigma do Agent — à medida que a IA evolui de “perguntas e respostas” para “autonomia, planejamento, execução múltipla e depuração”, a imprevisibilidade do consumo de tokens é quase inevitável.

A boa notícia é que esta é a primeira vez que alguém sistematicamente mapeou essa confusão. Com esses dados, desenvolvedores podem fazer escolhas mais inteligentes de modelos, definir limites de orçamento e criar mecanismos de stop-loss; fabricantes de modelos podem focar não só em melhorar a potência, mas também na economia.

Antes que a IA Agent realmente entre na rotina de milhares de indústrias, gastar cada centavo com transparência é mais importante do que fazer cada linha de código ficar perfeita.