Optimización de costes de IA: cinco técnicas que de verdad recortan la factura

Las líneas de coste de las funciones de IA en los paneles financieros tienen una propiedad divertida: crecen de forma no lineal con el tráfico y empeoran a medida que tu producto se hace popular. Estas son las cinco técnicas de mayor palanca que hemos visto mover de verdad la aguja, cada una con código ejecutable.

Ejemplo concreto: un producto de chat que hace 100K llamadas/día con una media de 3K tokens de input / 500 de output en Claude Sonnet 4.6 gasta unos $4.500/mes directos. La misma carga con las cinco técnicas de abajo suele quedarse en torno a $900–$1.200/mes — un recorte del 70–80% sin degradar de forma apreciable la calidad del output.

1. Caché de prompts — la palanca más grande de todas

Si tu system prompt o bloque de contexto supera los ~2K tokens y se reutiliza entre llamadas, estás pagando de más. Tanto Anthropic como Google facturan el input cacheado a aproximadamente 0,1×–0,2× del input normal — un ahorro de 5–10× en cada llamada una vez que la caché se calienta. Brievio te traslada el ahorro íntegro y ejecuta un enrutador por afinidad que mantiene los prompts repetidos golpeando el mismo nodo upstream, de modo que la caché sigue viva incluso con baja concurrencia.

Consulta /docs/caching para la guía completa.

import anthropic

client = anthropic.Anthropic(
    api_key="sk-brievio-...",
    base_url="https://api.brievio.com",
)

# Marca como cacheables las partes largas y estáticas del prompt. La siguiente
# llamada con el mismo prefijo acierta en la caché de Anthropic — el 10% del coste.
resp = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": "<<tu system prompt de 20K tokens — esquema, reglas, ejemplos>>",
            "cache_control": {"type": "ephemeral"},   # marcar como cacheable
        },
    ],
    messages=[{"role": "user", "content": "Última pregunta…"}],
)

Ahorro esperado: 40–70% en el coste de input para cargas con system prompts largos. A menudo, la mejora individual más grande.

2. Escalonado de modelos — no pagues por capacidad que no usas

Gana el modelo razonable más barato que siga produciendo un output aceptable. La mayoría de las cargas de LLM tienen una distribución de dificultad de cola larga — la tarea media de clasificación o resumen no necesita Opus.

Construye una estimación de dificultad sencilla (heurística, clasificador, o el propio Haiku haciendo triaje) y enruta en consecuencia. En más de 50 cuentas de Brievio hemos visto que esto solo recorta los costes de chat un 40–60%.

def pick_model(task_difficulty: int) -> str:
    """
    Gana el modelo más barato que siga siendo lo bastante bueno.
    Elige por dificultad percibida, luego valida por calidad del output.
    """
    if task_difficulty <= 2:
        return "claude-haiku-4-5"     # ~10x más barato que Opus
    if task_difficulty <= 4:
        return "gemini-2.5-flash"       # muy fuerte, aún más barato en output
    if task_difficulty <= 7:
        return "claude-sonnet-4-6"
    return "claude-opus-4-7"          # solo cuando de verdad hace falta

Ahorro esperado: 40–60% en cargas tipo chat una vez que una parte significativa se enruta a Haiku / Gemini Flash.

3. Topes de output y límites de gasto

Los tokens de output cuestan aproximadamente 5× más que los de input. Un bug que deja que un prompt pida una respuesta de 16K tokens dentro de un bucle apretado es la forma en que la gente gasta $400 sin querer en una tarde. Defiende ambas capas — el max_tokens por llamada y el límite de gasto a nivel de cartera en el panel.

# Tope en dos capas: max_tokens por llamada, más un tope de gasto fijo en la clave.
resp = client.chat.completions.create(
    model="claude-sonnet-4-6",
    messages=[...],
    max_tokens=800,       # limita el output por llamada
    stop=["</answer>"],   # corta en un terminador conocido
)

# En el panel de Brievio: /app/keys → fija un "Límite de gasto" en cada clave.
# Clave de producción: $50/día. Clave de experimentos: $5/día. Clave de CI: $1/día.

En Brievio: /app/keys te deja fijar un tope diario por clave. Las claves de CI/test a $1/día evitan que un script se descontrole; las de producción pueden seguir siendo generosas.

4. Paralelismo — concurrente no es lo mismo que más caro

Las llamadas secuenciales no ahorran dinero frente a las paralelas — pero sí malgastan tiempo de reloj, algo que a menudo se "resuelve" dándole al LLM más contexto o un modelo más grande. Lanza en paralelo las llamadas independientes; termina antes; baja de escalón.

# No pagues por razonamiento secuencial cuando N tareas son independientes.
import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key=os.environ["BRIEVIO_API_KEY"],
    base_url="https://api.brievio.com/v1",
)

async def classify_one(text: str) -> str:
    resp = await client.chat.completions.create(
        model="claude-haiku-4-5",     # paralelo + barato = victoria
        messages=[{"role": "user", "content": f"Classify: {text}"}],
        max_tokens=20,
    )
    return resp.choices[0].message.content

results = await asyncio.gather(*(classify_one(t) for t in batch))

Ahorro esperado: indirecto — normalmente un 10–20% al evitar la trampa de "subir de modelo para ir más rápido".

5. Reintentos que no facturan por duplicado

En Brievio, las peticiones fallidas (4xx, 5xx) nunca se facturan — pero solo es gratis la llamada que falla. Si tu lógica de reintentos se dispara ante cada microfallo transitorio sin backoff, puedes multiplicar el coste por 2–3× en un mal día del upstream. Respeta Retry-After, distingue los 4xx (tu bug) de los 5xx (transitorios) y limita los intentos.

from openai import APIError, RateLimitError
import time, random

def call_with_backoff(client, **kwargs):
    for attempt in range(5):
        try:
            return client.chat.completions.create(**kwargs)
        except RateLimitError as e:
            # Respeta Retry-After cuando esté presente.
            ra = getattr(e, "retry_after", None) or (2 ** attempt + random.random())
            time.sleep(min(ra, 30))
        except APIError as e:
            if 500 <= e.status_code < 600:
                time.sleep(2 ** attempt + random.random())
                continue
            raise           # 4xx — tu bug, no uno transitorio
    raise RuntimeError("exhausted retries")

Consulta /docs/errors para las reglas completas de reintentos.

El efecto compuesto

Cada técnica aplicada por separado da un recorte modesto. Apiladas, se componen: 50% menos por caché × 50% menos por escalonado × 10% menos por topes = 22% del coste original = 78% ahorrado. Esa es la diferencia entre que la IA sea una partida de gasto y que la IA aporte margen en producción.

Los propios precios de Brievio — cada modelo ~15% por debajo de la lista oficial, facturado sobre el conteo real de tokens — son un multiplicador plano encima de las cinco técnicas. La forma más inteligente de operar IA de frontera en 2026 es: elige modelos genuinos sobre una infraestructura que se mantiene en pie, y luego exprímeles las técnicas correctas. Ambas capas importan.

¿Quieres una lectura gratuita de tu uso actual para ver dónde está la palanca? Escribe a contact@brievio.com con una descripción aproximada y haremos el análisis.