O Número que Ninguém Te Conta Sobre Agentes de IA

Você abre o Claude Code, pede pra ele refatorar aquele módulo de autenticação, e 15 minutos depois a conta bateu 2 milhões de tokens. O código ficou pronto — mas o custo te fez engolir seco.

A pergunta que ninguém faz: onde exatamente esses tokens foram parar?

Um grupo de pesquisadores decidiu rastrear cada token consumido por agentes de IA durante tarefas de engenharia de software. O resultado é tão contraintuitivo que merece um artigo inteiro: a maior parte dos tokens não vai pra escrever código. Vai pra revisar código.

59,4% dos Tokens Vão pro Code Review

O paper “Tokenomics: Quantifying Where Tokens Are Used in Agentic Software Engineering” analisou 30 tarefas de desenvolvimento no framework ChatDev usando modelos GPT-5. Os pesquisadores mapearam cada fase da execução para estágios do SDLC: Design, Codificação, Code Completion, Code Review, Testes e Documentação.

O resultado:

Leu certo: quase 60% de todo o consumo vai pra revisão de código automatizada, não pra geração inicial. O agente escreve, revisa, encontra problemas, reescreve, revisa de novo — e cada iteração desse loop reprocessa todo o contexto anterior.

Outro dado importante: input tokens representam 53,9% do consumo total. Ou seja, mais da metade do que você paga é a IA relendo o que já escreveu, não gerando conteúdo novo.

Por Que o Code Review É Tão Caro?

A resposta está na natureza iterativa do processo. Quando um agente multi-agente como o ChatDev gera código, ele não faz uma única passada. O fluxo real é:

1. Agente Coder escreve a primeira versão
2. Agente Reviewer analisa, encontra problemas, sugere mudanças
3. Agente Coder reescreve com base no feedback
4. Agente Reviewer analisa novamente
5. Repete até convergir (ou estourar o budget)

Cada iteração desse ciclo reprocessa todo o código já escrito, todo o feedback anterior, e todo o contexto da tarefa. Em uma tarefa de 30 arquivos, o agente pode reprocessar milhares de linhas de código 4-5 vezes antes de considerar o resultado aceitável.

Isso explica também por que input tokens dominam o custo (53,9%). O agente gasta mais relendo do que escrevendo. É como se você pagasse um programador sênior que precisa reler todo o codebase inteiro a cada vez que altera uma linha — e cobrasse por hora de leitura.

O paper sugere que protocolos de colaboração entre agentes mais eficientes — onde o reviewer só recebe o diff, não o projeto inteiro — poderiam reduzir drasticamente esse consumo. Mas a arquitetura atual da maioria dos frameworks simplesmente não foi projetada pensando em eficiência de tokens.

1.000x Mais Tokens que um Chat Normal

Se o paper do ChatDev já assusta, um segundo estudo publicado em abril de 2026 — “How Do AI Agents Spend Your Money?” — coloca o problema em escala.

Os pesquisadores analisaram 8 modelos de fronteira (incluindo GPT-5, Claude Sonnet 4.5 e Kimi-K2) em tarefas do SWE-bench Verified. Descobertas que doem no bolso:

• Tarefas agentic consomem ~1.000x mais tokens que code reasoning ou code chat
• Runs na mesma tarefa podem variar até 30x em total de tokens — dependendo de como o agente “decide” abordar o problema
• Gastar mais tokens não significa resultado melhor: a acurácia frequentemente atinge o pico em custos intermediários, e depois cai
• Kimi-K2 e Claude Sonnet 4.5 consomem 1,5 milhão de tokens a mais que GPT-5 nas mesmas tarefas
• Os próprios modelos não conseguem prever quanto vão gastar: a correlação entre previsão e gasto real ficou em míseros 0,39

Esse último ponto é particularmente perturbador. Quando você pede pro agente estimar o custo de uma tarefa, ele subestima sistematicamente. É como contratar um pedreiro que sempre promete “uma semana” e leva três meses — só que cada dia extra custa tokens.

O Vilão Oculto: Contexto Reenviado

Um relatório da LeanOps, baseado em auditorias de 30 equipes de engenharia usando IA agêntica em produção entre março e maio de 2026, identificou o verdadeiro vilão da conta:

62% do custo total vem de contexto reenviado.

Funciona assim: a cada chamada de API, o modelo recebe todo o contexto novamente — o system prompt, cada arquivo que o agente leu, cada edit que fez, cada mensagem de erro que encontrou, e o histórico completo da conversa. Tudo isso é reenviado como input tokens a cada turno.

Um agente simples com 5 passos custa 3,2x mais que um chatbot para o mesmo resultado. Com 50 passos, o multiplicador passa de 30x. Em sessões de debugging autônomo com 200+ passos — cenário comum com Claude Code ou Cursor — o multiplicador ultrapassa 100x.

Na prática: se um chat normal custaria $0.05, a mesma tarefa em modo agêntico pode custar $5.00. E a maior parte desse custo é a IA relendo o que já sabe.

Como o GitHub Cortou 62% da Conta

O GitHub enfrentou esse problema de frente e documentou a solução no blog oficial. O time de engenharia aplicou três otimizações nos seus workflows agênticos internos:

1. Eliminar ferramentas MCP não usadas

Muitos setups incluem dezenas de ferramentas MCP registradas que o agente nunca usa. Cada ferramenta registrada adiciona 8-12 KB ao contexto por chamada. Remover as não utilizadas economizou milhares de tokens por run.

2. Trocar MCP do GitHub por CLI

Em vez de deixar o agente fazer fetch de dados via MCP (que entra no loop de raciocínio do LLM), o GitHub passou a baixar dados com gh CLI antes do agente iniciar. Isso move a maior parte do data-fetching para fora do loop de raciocínio.

# Antes: agente usava MCP para buscar diff do PR (tokens no loop)
# Depois: dados pré-baixados com CLI
gh pr diff 123 > /tmp/pr-diff.txt
# Agente recebe o arquivo pronto, sem gastar tokens buscando

3. Remover steps determinísticos do raciocínio

Tarefas repetitivas como ler diffs de PRs foram convertidas em pre-workflow steps. O agente não precisa “pensar” para decidir que precisa ler o diff — isso é feito automaticamente antes dele começar.

Os resultados por workflow:

Só o Auto-Triage economizou 7,8 milhões de Effective Tokens durante o período de observação.

O GitHub também criou uma métrica chamada Effective Tokens (ET) que normaliza o custo entre modelos diferentes:

ET = m × (1.0 × I + 0.1 × C + 4.0 × O)

Onde I = input tokens, C = cached tokens, O = output tokens, e m = multiplicador do modelo. Isso permite comparar custos reais entre Haiku, Sonnet e Opus de forma justa.

Quanto Custa Realmente Usar IA pra Codar em 2026

Vamos colocar os números na mesa. Pesquisas de mercado de junho de 2026 mostram o custo real de cada ferramenta:

Mas esses são os preços de assinatura. O custo real? O dev médio usando Claude Code ou Cursor em modo agêntico gasta entre $400 e $1.500 por mês. Casos extremos chegam a $4.000+ em poucos dias.

Um desenvolvedor reportou que 8 meses de uso diário do Claude Code consumiram 10 bilhões de tokens — o que custaria mais de $15.000 a preço de API (baseado em $3/$15 por milhão de tokens no Sonnet 4.6).

E o volume global não para de crescer. O processamento semanal de tokens no OpenRouter saltou de 0,4 trilhão em dezembro de 2024 para 27 trilhões em março de 2026. Um aumento de 67,5x em 15 meses.

4 Formas de Cortar a Conta pela Metade

A LeanOps documentou quatro estratégias que consistentemente reduzem custos agênticos em 50-70% em duas semanas:

1. Budget caps por usuário

Parece óbvio, mas a maioria dos times não tem. Definir um limite por dev/dia evita que um loop infinito de debugging autônomo queime o orçamento do mês inteiro em uma tarde.

2. Prompt caching para system instructions

System prompts são reenviados a cada turno. Habilitar prompt caching (disponível no Claude e GPT-5) reduz drasticamente o custo dos tokens que não mudam entre chamadas.

# Anthropic API - prompt caching
response = client.messages.create(
    model="claude-sonnet-4-5-20250514",
    system=[{
        "type": "text",
        "text": system_prompt,
        "cache_control": {"type": "ephemeral"}
    }],
    messages=messages
)

3. Model tier routing

Nem toda subtarefa precisa do Opus. Use Haiku para tarefas mecânicas (linting, formatação, leitura de arquivos) e Opus apenas para raciocínio complexo. Essa estratégia sozinha pode cortar 40% da conta.

4. Poda agressiva da context window

Remova do contexto arquivos já processados, mensagens de erro resolvidas, e histórico de conversa que não é mais relevante. O agente não precisa relembrar cada passo que já deu — só os que importam pro passo atual.

O Volume Global de Tokens Explodiu — E Ninguém Sabe Como Frear

Esses problemas não seriam tão graves se o uso de agentes fosse nicho. Mas não é.

O processamento semanal de tokens no OpenRouter — uma das maiores plataformas de roteamento de LLMs — saltou de 0,4 trilhão em dezembro de 2024 para 27 trilhões em março de 2026. Isso é um aumento de 67,5x em 15 meses. E esses números só incluem uma plataforma.

Quando você soma Anthropic API diretamente, Azure OpenAI, AWS Bedrock, Google Vertex AI, e todas as outras formas de consumir tokens, o número real provavelmente está na casa dos centenas de trilhões por semana.

E aqui está o problema circular: quanto mais tokens são consumidos, mais demanda por GPUs. Quanto mais demanda por GPUs, mais data centers. Quanto mais data centers, mais energia. A Agência Internacional de Energia projeta que o consumo global de eletricidade por data centers vai dobrar até 2030 — e a ineficiência dos agentes de IA é um dos maiores contribuidores.

Não é exagero dizer que otimizar o consumo de tokens não é só uma questão de custo. É uma questão ambiental e de infraestrutura global.

O Paradoxo da Eficiência

Eu acho fascinante que estamos vivendo um momento onde a IA gasta mais tempo se corrigindo do que produzindo. O dado dos 59,4% em code review mostra que os agentes de IA reproduzem um padrão humano: revisar código é mais caro que escrevê-lo.

A diferença é que um humano revisando código não reprocessa cada linha do projeto a cada olhada. A IA, pela sua arquitetura baseada em transformers, é obrigada a fazer exatamente isso. É como se um code reviewer precisasse ler o repositório inteiro de novo a cada comentário no PR.

A Agência Internacional de Energia projeta que o consumo global de eletricidade por data centers vai dobrar até 2030, impulsionado em grande parte por esse tipo de ineficiência. Não é exagero dizer que otimizar o consumo de tokens dos agentes de IA é, literalmente, uma questão ambiental.

O Que Muda na Prática

Se você está usando agentes de IA para programar — e em 2026, quem não está? — aqui vai o que esses dados significam:

Pra devs individuais: Monitore seu consumo de tokens. A maioria das ferramentas tem dashboards de uso. Se o número está subindo sem sua produtividade acompanhar, o agente provavelmente está em loops de revisão ineficientes. Considere quebrar tarefas grandes em subtarefas menores — menos contexto acumulado, menos tokens reenviados.

Pra tech leads: Implementem budget caps ontem. Não como restrição punitiva, mas como circuit breaker. Um agente que gastou 5 milhões de tokens em uma tarefa simples provavelmente travou num loop — e continuar rodando não vai resolver.

Pra quem escolhe ferramentas: O modelo mais caro nem sempre é o melhor. O paper mostra que gastar mais tokens não correlaciona com resultados melhores. GPT-5 foi significativamente mais eficiente que Claude Sonnet 4.5 e Kimi-K2 nas mesmas tarefas — o que sugere que benchmarks de qualidade precisam incluir eficiência de tokens como métrica.

O futuro dos agentes de IA não é só torná-los mais inteligentes. É torná-los menos esbanjadores. E dado que o processamento semanal de tokens já bateu 27 trilhões, esse futuro precisa chegar rápido.

Se eu fosse apostar, diria que a próxima grande inovação em IA não vai ser um modelo maior ou mais capaz. Vai ser um modelo que faz o mesmo trabalho com 10x menos tokens. E quem resolver isso primeiro vai dominar o mercado de ferramentas de desenvolvimento por pelo menos uma década.

—

Fonte de inspiração: Tokenomics: Quantifying Where Tokens Are Used in Agentic Software Engineering — paper em destaque no Hacker News