Todo desarrollador que empieza a usar activamente la API de los modelos de la familia Claude (especialmente los buques insignia Claude 3.5 Sonnet y Opus) en proyectos reales sufre tarde o temprano un pequeño shock al mirar la factura de cómputo en la nube. Lanzaste un par de docenas de pruebas de un agente autónomo, le pediste refactorizar un par de módulos en el proyecto... y de pronto descubriste que en un solo día se esfumaron varias decenas de dólares del saldo.
La primera reacción instintiva es culpar al proveedor por tarifas altas y pasarse a modelos compactos más baratos, pero más torpes. Sin embargo, si haces una auditoría detallada de las peticiones de red, casi siempre sale a la luz lo mismo: el grueso del dinero no se quema en cómputo útil, sino en reenviar un gigantesco lastre muerto.
Julian Goldie, junto con la comunidad de desarrolladores, mostró un conjunto de ajustes de ingeniería sencillos que permiten recortar el consumo de tokens en un 80% sin el menor perjuicio para la calidad del trabajo de los modelos. Repasemos estas técnicas paso a paso.
A dónde se fugan realmente millones de tokens
En un ciclo típico de interacción con la API, los desarrolladores cometen dos errores clave que multiplican la factura:
- Reenvío repetido de un prefijo estático pesado: en cada petición al modelo se envían instrucciones detalladas de sistema, especificaciones de API, esquemas de bases de datos y ejemplos de respuestas correctas (Few-Shot Examples). Ese bloque pesa fácilmente entre 5,000 y 10,000 tokens. Si el agente da veinte pasos en un diálogo, pagas veinte veces la lectura de exactamente los mismos bytes invariables a tarifa completa.
- Salida sin filtrar de comandos de terminal: el agente ejecuta
git log,npm testo la compilación de un contenedor Docker, y todo el log en bruto —cientos de líneas con barras de progreso, mensajes internos del compilador y advertencias del linter— vuela directo a la ventana de contexto. En pruebas reales, una sola ejecución fallida de tests infló el contexto de 1,400 a unos monstruosos 71,000 tokens en un único paso.
Arquitectura de Prompt Caching: cómo funciona la fijación de prefijos
El arma principal contra el derroche de tokens es la tecnología oficial de caché de prompts (Prompt Caching) de Anthropic.
La mecánica de la caché es sencilla y brillante. Cuando el servidor de Anthropic recibe una petición, comprueba si se encontró exactamente con el mismo prefijo de texto en los 5 minutos anteriores. Si hay coincidencia, el modelo lee el estado intermedio de atención ya compilado (caché KV) directamente desde la memoria ultrarrápida del servidor:
- El costo de lectura de tokens cacheados es de apenas el 10% de la tarifa base de entrada (un descuento del 90%);
- La velocidad de respuesta del modelo (Time to First Token) aumenta entre 2 y 3 veces, ya que el servidor no necesita volver a digerir todo el texto de sistema.
Para que el cacheo se active, el prompt de sistema debe superar el umbral mínimo (1024 tokens para Sonnet y Opus) y contener un punto de control explícito.
Así luce la configuración de caché en código Python usando el cliente oficial de Anthropic:
import os
from anthropic import Anthropic
client = Anthropic(api_key=os.environ.get("ANTHROPIC_API_KEY"))
# Separación de instrucciones en un bloque estático cacheable y una tarea dinámica
system_instructions = "Eres un ingeniero líder. Aquí tienes el esquema completo de la base de datos del proyecto: " + ("TABLE_SCHEMA " * 300)
response = client.messages.create(
model="claude-3-5-sonnet-latest",
max_tokens=2048,
system=[
{
"type": "text",
"text": system_instructions,
"cache_control": {"type": "ephemeral"} # Punto de control de caché
}
],
messages=[
{"role": "user", "content": "Escribe una consulta SQL para contar los usuarios activos de la semana."}
]
)
# Comprobación de la eficiencia de la caché en la respuesta
usage = response.usage
print(f"Escrito en caché: {getattr(usage, 'cache_creation_input_tokens', 0)}")
print(f"Leído desde caché (descuento 90%): {getattr(usage, 'cache_read_input_tokens', 0)}")
Como se subrayó al analizar las capacidades de Claude con ajuste flexible de razonamiento, una gestión inteligente de la caché permite usar modelos insignia al precio de redes ligeras.
Filtrado de la salida de terminal: recortando la basura
La segunda medida crítica es el saneamiento de la salida de las utilidades del sistema. El agente no necesita miles de líneas de compilación; solo necesita el estado de ejecución y el texto exacto del error si algo falla.
Usa pipelines concisos y recorte de logs antes de pasar el texto al modelo:
# Ejemplo de compresión agresiva de la salida de build y tests antes de enviarla al agente
npm test 2>&1 | tail -n 40 | grep -E "(FAIL|Error|passing|failing)" || true
Esta simple línea corta las listas interminables de archivos aprobados y deja únicamente el estado final y el stack trace del test fallido. En el escenario de prueba de Goldie, un filtro así redujo el tamaño del log de 71,000 a 1,400 tokens, conservando el 100% de la información útil para depurar.
Para controlar la eficiencia de la caché en producción, recomiendo configurar el registro de los encabezados especiales de respuesta de Anthropic. En el objeto usage se devuelven los campos cache_creation_input_tokens y cache_read_input_tokens. Si la proporción de tokens leídos desde caché supera de forma estable el 75%, tu arquitectura está operando con el máximo retorno económico.
Checklist de ahorro para producción
Fija estas tres reglas antes de lanzar cualquier script:
- Lleva todos los datos invariables (documentación, reglas de código, estructura del proyecto) al inicio del prompt de sistema y márcalos con el atributo
cache_control; - Nunca envíes volcados en bruto de logs: limita la salida a las primeras y últimas líneas (
head -n 20ytail -n 30); - Controla los intervalos entre sesiones: el tiempo de vida de la caché (TTL) es de 5 minutos. Agrupa las peticiones en lotes para que cada llamada siguiente caiga en la caché caliente de la anterior.

