⚡ Eficiencia y Costos en Agentes Claude

Prompt Caching — La Mayor Palanca de Ahorro

A Almacena bloques de prompt que se repiten entre llamadas. La primera vez paga 1.25× el precio normal (overhead de escritura). Cada lectura subsecuente: solo 10% del precio normal = 90% de descuento.

Matemática del caching (Sonnet 4.6)

Break-even del caching

Con 50,000 tokens en caché (Sonnet):
  Sin caché:    50K × $3.00/1M = $0.150 por llamada
  Con caché:
    Escritura:  50K × $3.75/1M = $0.188 (primera vez)
    Lectura:    50K × $0.30/1M = $0.015 (2da llamada en adelante)

Break-even: ~1.4 lecturas (desde la 2ª lectura hay ahorro neto)
Ahorro después de 10 lecturas: 90% por llamada

Implementación en Python SDK

import anthropic
client = anthropic.Anthropic()

SYSTEM_PROMPT = """[...documentación del proyecto, 20K tokens...]"""

# Primera llamada — escribe el cache
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=2048,
    system=[{
        "type": "text",
        "text": SYSTEM_PROMPT,
        "cache_control": {"type": "ephemeral"}  # ← activa caching
    }],
    messages=[{"role": "user", "content": "Revisa el PR #127"}]
)

# Segunda+ llamadas — 90% de descuento en el system prompt
print(f"Cache write: {response.usage.cache_creation_input_tokens}")
# → siguientes llamadas leerán del cache automáticamente

Casos reales de ahorro

Batch API — 50% de Descuento para Trabajo Asíncrono

A El Message Batches API procesa solicitudes de forma asíncrona (resultados en hasta 24 horas), con descuento fijo del 50% en todos los tokens.

Precios con Batch API vs. Tiempo Real

¿Cuándo usar Batch API?

Implementación del Batch API

import anthropic
client = anthropic.Anthropic()

# Preparar un batch de documentos a procesar
requests = []
for i, documento in enumerate(lista_documentos):
    requests.append({
        "custom_id": f"doc-{i}",
        "params": {
            "model": "claude-sonnet-4-6",
            "max_tokens": 500,
            "messages": [{
                "role": "user",
                "content": f"Extrae campos clave: {documento['contenido']}"
            }]
        }
    })

# Crear el batch
batch = client.messages.batches.create(requests=requests)
print(f"Batch ID: {batch.id}")  # guardar para recuperar después

# Recuperar resultados (en otro script, horas después)
batch = client.messages.batches.retrieve(batch_id)
if batch.processing_status == "ended":
    for result in client.messages.batches.results(batch_id):
        print(result.result.message.content[0].text)

Ejemplo de ahorro: 500 documentos × 3K tokens de input × Sonnet:
Tiempo real: 500 × $0.009 = $4.50 → Batch: $2.25 · Ahorro: $2.25 solo en input

Model Routing — El Arte de Usar el Modelo Correcto

B Usar siempre el modelo más caro (Opus) o siempre el más barato (Haiku) es subóptimo. El routing inteligente puede reducir costos 50-80% sin pérdida de calidad.

Split típico de producción optimizado

vs. todo Sonnet → ahorro del 45-55% en costo total mensual

Router automático con Haiku como clasificador

import anthropic
client = anthropic.Anthropic()

def clasificar_complejidad(tarea: str) -> str:
    """Usa Haiku (más barato) para decidir qué modelo usar — meta-optimización"""
    response = client.messages.create(
        model="claude-haiku-4-5-20251001",
        max_tokens=10,  # solo necesita responder: baja, media, alta
        messages=[{"role": "user", "content": f"""
Clasifica la complejidad de esta tarea de software.
Tarea: {tarea}
Responde SOLO: baja, media, o alta

baja  → clasificación, formateo, summary simple, transformación mecánica
media → código producción, revisión PR, debug de función individual
alta  → arquitectura sistemas, análisis seguridad completo, diseño multi-componente
"""}]
    )
    return response.content[0].text.strip().lower()

def ejecutar_tarea(tarea: str, contenido: str) -> str:
    complejidad = clasificar_complejidad(tarea)
    modelos = {
        "baja":  "claude-haiku-4-5-20251001",
        "media": "claude-sonnet-4-6",
        "alta":  "claude-opus-4-6",
    }
    return client.messages.create(
        model=modelos[complejidad],
        max_tokens=4096,
        messages=[{"role": "user", "content": f"{tarea}\n\n{contenido}"}]
    )

Tabla de asignación por tipo de tarea

Gestión del Context Window — /compact y Disciplina de Sesión

A Los tokens de input se cobran en cada llamada. Una sesión con 80K tokens de historial paga esos 80K tokens en cada herramienta que se usa.

El impacto del crecimiento del contexto

Sin /compact — sesión de 8 horas:
  Herramienta 1:    5K tokens de historial  × $3/1M = $0.015
  Herramienta 10:  50K tokens de historial  × $3/1M = $0.150
  Herramienta 20: 100K tokens de historial  × $3/1M = $0.300
  Herramienta 50: 200K tokens de historial  × $3/1M = $0.600
  Total acumulado (estimado):                          ~$8.50

Con /compact (2 veces en la sesión):
  Comprime historial de 80K → resumen denso de 5K tokens
  Las 50 herramientas promedian 15K tokens de contexto
  Total acumulado (estimado):                          ~$1.80
  Ahorro: ~79% del gasto en tokens de input

El premium por contextos >200K tokens

Cuándo usar /compact vs. nueva sesión

Disciplina de session focus

# Regla: 1 sesión = 1 objetivo claro
# MAL: "Hoy voy a trabajar en el proyecto" → historial mezcla todo
claude  # sesión abierta, trabaja en A, B, C, D entremezclados

# BIEN: Una sesión por objetivo
claude --task "Implementar endpoint /users/profile"  # enfocado
# → contexto pequeño, barato, eficiente

B Branch8 atribuye el 35% de su reducción de costos a la disciplina de session focus: mantener conversaciones estrechas (1 tarea por sesión) redujo el costo promedio por sesión a ~33% del de sesiones abiertas.

Parallel Worktrees — Multiplicar el Throughput

A Git worktrees permiten múltiples ramas en directorios físicos separados, simultáneamente. Claude Code añadió soporte de primera clase con el flag -w en late 2025.

Comandos de setup

# Crear worktrees
git worktree add ../proyecto-feature-auth feature/auth
git worktree add ../proyecto-feature-pagos feature/pagos
git worktree add ../proyecto-hotfix-prod hotfix/prod-bug

# Lanzar Claude Code en paralelo (en terminales separadas)
cd ../proyecto-feature-auth && claude
cd ../proyecto-feature-pagos && claude
cd ../proyecto-hotfix-prod  && claude

# O directamente con el flag -w de Claude Code
claude -w feature/nueva-api    # crea worktree + abre sesión

Impacto en productividad (no en costo directo)

Sin worktrees (secuencial):
  Tarea A: 2 horas
  Tarea B: 2 horas  (espera a que A termine)
  Tarea C: 2 horas  (espera a que B termine)
  Total: 6 horas

Con worktrees (paralelo):
  Tarea A: 2 horas ─┐
  Tarea B: 2 horas  ├── ejecutadas simultáneamente
  Tarea C: 2 horas ─┘
  Total: ~2.5 horas (incluyendo merge)

Ganancia: 3× en throughput de tareas independientes

Cuándo usar worktrees

C Regla de thumb de la comunidad: "Scope worktrees por módulo, no por tarea. Cualquier tarea que toca más de 3 archivos merece su propio worktree." — Dogukan Uraz Tuna (Medium, 2025)

🧮 Calculadora de Ahorro — Antes vs. Después

Stack de Optimización Apilable

Combinadas: 80-90% de reducción total del gasto API 🎯

Árbol de Decisión — ¿Qué optimización aplicar primero?