Otimização de Custos de Agentes: Um Guia Prático para Reduzir Gastos com API

Seu agente funciona muito bem. Ele lida com 200 requisições por dia e os usuários estão satisfeitos. Então você confere a fatura da API: $3.400 este mês. Você analisa os números e percebe que o agente faz em média 12 chamadas de API por requisição, cada uma com um prompt de sistema de 4.000 tokens. Isso representa 9,6 milhões de tokens de entrada por dia só para prompts de sistema. A $3 por milhão de tokens, isso equivale a $864/mês em conteúdo repetido.

Custo é o principal motivo pelo qual implantações de agentes em produção são reduzidas ou encerradas completamente. Otimização não é prematura — é sobrevivência. A boa notícia: a maioria das implantações de agentes tem 50–80% de redução de custos disponível por meio de mudanças diretas que não exigem rearquitetura de todo o sistema.

Neste guia, você aprenderá sete estratégias de redução de custos, ordenadas por ROI (Retorno sobre Investimento). Comece pelo topo e vá descendo até atingir sua meta orçamentária. Cada seção inclui números concretos para que você possa estimar a economia antes de escrever uma única linha de código.

1. Contabilidade de Tokens: Saiba Onde Seu Dinheiro Vai

Você não pode otimizar o que não mede. Antes de mudar qualquer coisa, construa uma visão completa de para onde vai cada centavo no fluxo de trabalho do seu agente.

Detalhamento de Tokens de Entrada

Cada chamada de API ao Claude inclui várias categorias de tokens no lado da entrada:

• Prompt de sistema — Instruções, persona, restrições. Geralmente 1.000–5.000 tokens e repetido em cada chamada.
• Definições de ferramentas — Schemas JSON para cada ferramenta que o agente pode usar. 10 ferramentas podem facilmente consumir 2.000–3.000 tokens.
• Histórico de conversa — Todas as mensagens anteriores na conversa. Cresce a cada etapa.
• Resultados de ferramentas — Saídas de chamadas de ferramentas anteriores injetadas de volta no contexto. Podem ser massivas (páginas da web completas, resultados de banco de dados).

Detalhamento de Tokens de Saída

Tokens de saída são 3–5x mais caros do que tokens de entrada, tornando-os um alvo crítico de otimização:

• Raciocínio do agente — Cadeia de pensamento interna (especialmente com pensamento estendido).
• Geração de chamadas de ferramentas — O JSON para invocações de ferramentas.
• Resposta final — A resposta voltada ao usuário.

Cálculo de Custo por Tarefa

O custo total para uma única tarefa do agente é:

Custo Total = Σ (input_tokens × input_price + output_tokens × output_price)
              para cada chamada de API na tarefa

Exemplo de Detalhamento de Custos

Aqui está um detalhamento realista para uma tarefa de agente de pesquisa de 10 etapas usando o Claude Sonnet ($3/M de entrada, $15/M de saída):

Observe como os custos de entrada dominam e crescem a cada etapa conforme o histórico de conversa se acumula. As etapas 8–10 representam 47% do custo total, apesar de corresponderem a apenas 30% das etapas.

Código de Rastreamento de Custos

Implemente um wrapper de rastreamento desde o primeiro dia:

import anthropic
import time
from dataclasses import dataclass, field
from typing import Optional

@dataclass
class CostRecord:
    step: int
    model: str
    input_tokens: int
    output_tokens: int
    cache_read_tokens: int = 0
    cache_creation_tokens: int = 0
    input_cost: float = 0.0
    output_cost: float = 0.0
    total_cost: float = 0.0
    duration_ms: float = 0.0

# Pricing per million tokens (as of early 2026)
MODEL_PRICING = {
    "claude-haiku": {"input": 0.25, "output": 1.25, "cache_read": 0.025, "cache_write": 0.30},
    "claude-sonnet": {"input": 3.00, "output": 15.00, "cache_read": 0.30, "cache_write": 3.75},
    "claude-opus": {"input": 15.00, "output": 75.00, "cache_read": 1.50, "cache_write": 18.75},
}

@dataclass
class TaskCostTracker:
    task_id: str
    budget_limit: Optional[float] = None
    records: list = field(default_factory=list)
    total_cost: float = 0.0

    def record_call(self, step: int, model: str, usage) -> CostRecord:
        pricing = MODEL_PRICING.get(model, MODEL_PRICING["claude-sonnet"])

        input_cost = (usage.input_tokens / 1_000_000) * pricing["input"]
        output_cost = (usage.output_tokens / 1_000_000) * pricing["output"]
        cache_read_cost = (getattr(usage, 'cache_read_input_tokens', 0) / 1_000_000) * pricing["cache_read"]
        cache_write_cost = (getattr(usage, 'cache_creation_input_tokens', 0) / 1_000_000) * pricing["cache_write"]

        total = input_cost + output_cost + cache_read_cost + cache_write_cost

        record = CostRecord(
            step=step,
            model=model,
            input_tokens=usage.input_tokens,
            output_tokens=usage.output_tokens,
            cache_read_tokens=getattr(usage, 'cache_read_input_tokens', 0),
            cache_creation_tokens=getattr(usage, 'cache_creation_input_tokens', 0),
            input_cost=input_cost + cache_read_cost + cache_write_cost,
            output_cost=output_cost,
            total_cost=total,
        )

        self.records.append(record)
        self.total_cost += total

        print(f"  Step {step} [{model}]: {usage.input_tokens} in / {usage.output_tokens} out = ${total:.4f} (cumulative: ${self.total_cost:.4f})")

        if self.budget_limit and self.total_cost > self.budget_limit:
            raise BudgetExceededError(
                f"Task {self.task_id} exceeded budget: ${self.total_cost:.4f} > ${self.budget_limit:.4f}"
            )

        return record

    def summary(self) -> dict:
        return {
            "task_id": self.task_id,
            "total_steps": len(self.records),
            "total_input_tokens": sum(r.input_tokens for r in self.records),
            "total_output_tokens": sum(r.output_tokens for r in self.records),
            "total_cost": self.total_cost,
            "cost_by_model": self._cost_by_model(),
        }

    def _cost_by_model(self) -> dict:
        by_model = {}
        for r in self.records:
            if r.model not in by_model:
                by_model[r.model] = {"calls": 0, "cost": 0.0}
            by_model[r.model]["calls"] += 1
            by_model[r.model]["cost"] += r.total_cost
        return by_model


class BudgetExceededError(Exception):
    pass

Comece a rastrear hoje, mesmo antes de otimizar. Você precisa de números de linha de base para medir a melhoria.

2. Seleção de Modelo por Tarefa

Este é o maior alavancador de custos disponível para você. Nem toda etapa do agente exige seu modelo mais poderoso.

Níveis de Modelos e Preços

Usando a família Claude como referência:

O Haiku é 12x mais barato que o Sonnet na entrada e 12x mais barato na saída. O Sonnet é 5x mais barato que o Opus em todos os aspectos.

Recomendações por Função

Associe cada função do agente ao modelo mais barato que atende aos requisitos de qualidade:

• Agentes roteadores/classificadores → Haiku. “Esta é uma pergunta de cobrança ou técnica?” não precisa do Sonnet. O Haiku lida com classificação com >95% de precisão para categorias bem definidas.
• Agentes de extração de dados → Haiku. Extrair campos

Artigos Relacionados

• Estratégias de Cache para Agentes de IA: Reduzindo Custos Sem Abrir Mão da Qualidade
• Modelos de Raciocínio em Fluxos de Agentes: Quando o Pensamento Estendido Vale a Pena
• Padrões Multi-Agente: Orquestradores, Workers e Pipelines
• Depuração e Observabilidade em Sistemas de Agentes Autônomos