Optimización de Costos en Agentes: Guía Práctica para Reducir el Gasto en APIs

Tu agente funciona de maravilla. Gestiona 200 solicitudes al día y los usuarios están satisfechos. Entonces revisas la factura de la API: $3.400 este mes. Analizas los números y te das cuenta de que el agente realiza un promedio de 12 llamadas a la API por solicitud, cada una con un prompt del sistema de 4.000 tokens. Eso equivale a 9,6 millones de tokens de entrada al día solo por los prompts del sistema. A $3 por millón de tokens, son $864/mes en contenido repetido.

El costo es la principal razón por la que los despliegues de agentes en producción se reducen o se cancelan por completo. La optimización no es prematura — es una cuestión de supervivencia. La buena noticia: la mayoría de los despliegues tienen una reducción de costos disponible del 50–80% mediante cambios sencillos que no requieren rediseñar todo el sistema.

En esta guía aprenderás siete estrategias de reducción de costos, ordenadas por ROI (Retorno sobre la Inversión). Empieza por arriba y avanza hacia abajo hasta alcanzar tu presupuesto objetivo. Cada sección incluye cifras concretas para que puedas estimar el ahorro antes de escribir una sola línea de código.

1. Contabilidad de Tokens: Saber en Qué se Va el Dinero

No puedes optimizar lo que no mides. Antes de cambiar cualquier cosa, construye un panorama completo de a dónde va cada dólar en el flujo de trabajo de tu agente.

Desglose de Tokens de Entrada

Cada llamada a la API de Claude incluye varias categorías de tokens en la parte de entrada:

• Prompt del sistema — Instrucciones, personalidad, restricciones. A menudo entre 1.000 y 5.000 tokens, y se repite en cada llamada.
• Definiciones de herramientas — Esquemas JSON para cada herramienta que el agente puede usar. 10 herramientas pueden consumir fácilmente entre 2.000 y 3.000 tokens.
• Historial de conversación — Todos los mensajes anteriores de la conversación. Crece con cada paso.
• Resultados de herramientas — Salidas de llamadas a herramientas previas inyectadas de vuelta al contexto. Pueden ser masivas (páginas web completas, resultados de bases de datos).

Desglose de Tokens de Salida

Los tokens de salida son entre 3 y 5 veces más caros que los de entrada, lo que los convierte en un objetivo de optimización crítico:

• Razonamiento del agente — Cadena de pensamiento interna (especialmente con pensamiento extendido).
• Generación de llamadas a herramientas — El JSON para las invocaciones de herramientas.
• Respuesta final — La respuesta que ve el usuario.

Cálculo del Costo por Tarea

El costo total de una sola tarea del agente es:

Costo Total = Σ (tokens_entrada × precio_entrada + tokens_salida × precio_salida)
              para cada llamada a la API en la tarea

Ejemplo de Desglose de Costos

Aquí tienes un desglose realista de una tarea de investigación de 10 pasos con Claude Sonnet ($3/M entrada, $15/M salida):

Observa cómo los costos de entrada dominan y crecen con cada paso a medida que se acumula el historial de conversación. Los pasos 8–10 representan el 47% del costo total a pesar de ser solo el 30% de los pasos.

Código de Seguimiento de Costos

Implementa un wrapper de seguimiento desde el primer día:

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

Empieza a hacer seguimiento hoy, incluso antes de optimizar. Necesitas cifras de referencia para medir las mejoras.

2. Selección del Modelo Según la Tarea

Este es el mayor palanca de reducción de costos disponible. No cada paso del agente requiere tu modelo más potente.

Niveles de Modelos y Precios

Usando la familia Claude como referencia:

Haiku es 12 veces más barato que Sonnet en entrada y 12 veces más barato en salida. Sonnet es 5 veces más barato que Opus en todos los aspectos.

Recomendaciones por Rol

Asigna cada rol del agente al modelo más económico que cumpla los requisitos de calidad:

• Agentes de enrutamiento/clasificación → Haiku. “¿Es esto una pregunta de facturación o una pregunta técnica?” no necesita Sonnet. Haiku maneja la clasificación con >95% de precisión para categorías bien definidas.
• Agentes de extracción de datos

Artículos Relacionados

• Estrategias de Caché para Agentes de IA: Reducir Costos sin Sacrificar Calidad
• Modelos de Razonamiento en Flujos de Trabajo de Agentes: Cuándo Vale la Pena el Pensamiento Extendido
• Patrones Multi-Agente: Orquestadores, Workers y Pipelines
• Depuración y Observabilidad en Sistemas de Agentes Autónomos