Inferencia-por-dólar: dominando los costos de los agentes de IA con caching y disyuntores

El almacenamiento en caché de contexto, al que me refiero como la "regla del 90%" por su potencial de importantes ahorros de costos, es una técnica en la que los proveedores almacenan en caché una parte sustancial de una solicitud grande y frecuentemente repetida. Esto se refiere típicamente al "contexto" o a las "instrucciones del sistema" que permanecen estáticas a lo largo de múltiples turnos de interacción de un agente. Cuando se realizan llamadas posteriores con el mismo contexto almacenado en caché y solo una nueva entrada de usuario, el proveedor puede recuperar el contexto preprocesado. Esto reduce drásticamente el consumo de tokens y la latencia para la entrada grande. He encontrado esto particularmente efectivo para agentes que mantienen una personalidad de sistema consistente o una extensa base de conocimientos recuperada a lo largo de múltiples turnos.

Para calificar eficazmente para el almacenamiento en caché y los descuentos asociados (que pueden ser sustanciales, a menudo alrededor de una reducción del 90% para la parte de entrada almacenada en caché), los proveedores suelen tener varios requisitos. Presto mucha atención a estos al diseñar mis prompts:

• TTL mínimo (tiempo de vida): las políticas de retención de caché varían significativamente según el proveedor. El almacenamiento en caché explícito (como el de Vertex AI de Google) generalmente cobra por hora de almacenamiento, lo que le permite establecer TTL largos para bases de conocimiento estables. Por el contrario, el almacenamiento en caché automático (como el de OpenAI o Anthropic) se basa en TTL efímeros de 5 a 10 minutos que se actualizan al usarse. Debe diseñar la cadencia de interacción de su agente para que coincida con estos mecanismos TTL para maximizar los aciertos de caché.
• Recuento mínimo de tokens: el bloque almacenado en caché debe alcanzar un umbral específico del proveedor para activar el motor de almacenamiento en caché. Esto varía desde tan solo 1.024 a 2.048 tokens para el almacenamiento en caché automático hasta 32.768 tokens para la creación explícita de caché. Este umbral garantiza que la sobrecarga computacional del almacenamiento en caché se justifique por los ahorros derivados de la reutilización de un contexto grande.
• Coincidencia exacta: este es el requisito más crucial y a menudo pasado por alto. La parte almacenada en caché del prompt debe ser exactamente la misma, bit a bit, que la anterior. Incluso un solo espacio extra, un carácter de nueva línea o una pequeña reordenación puede romper el caché y forzar un reprocesamiento completo de todo el prompt, lo que le costará el precio completo. Esto me ha pasado antes, así que soy meticuloso con la consistencia del prompt.

Al implementar en regiones europeas, normalmente opto por europe-west1 o europe-west4 en GCP, eu-west-1 en AWS, o westeurope o northeurope en Azure. estas regiones suelen ofrecer una excelente latencia de red dentro de europa y con frecuencia son de las primeras en admitir nuevas funciones de ia e implementaciones de modelos. para conocer las capacidades específicas de cada región, consulte ubicaciones de google cloud, regiones de aws para amazon bedrock y geografías y regiones de azure.

Elegir el modelo y el proveedor de la nube correctos es un componente crítico de la optimización de costos. El precio de los modelos de lenguaje grande (LLM) puede variar significativamente, impactando directamente su métrica de "Inferencia-por-Dólar". A continuación se presentan mis consideraciones de referencia para los modelos líderes, utilizando una tasa de conversión aproximada de 1 $ = 0,92 € para estas cifras:

• Gemini 2.5 Pro en GCP: 1,27 €/M (1,38 $/M) tokens de entrada.
• GPT-5.2 en Azure: 1,78 €/M (1,93 $/M) tokens de entrada.
• Opus 4.5 en AWS Bedrock: 2,30 €/M (2,50 $/M) tokens de entrada (ilustrativo). Confirme siempre los precios de lista actuales en su región en precios de amazon bedrock e id. de modelos en la documentación de bedrock.

Estas cifras destacan que incluso pequeñas diferencias en el precio por millón de tokens pueden dar lugar a variaciones de costos sustanciales a escala. Mi elección depende de las compensaciones específicas entre rendimiento, conjunto de características y costo para la carga de trabajo de mi agente.

Un disyuntor agentico es un mecanismo que implemento para evitar que un agente de IA autónomo entre en bucles de razonamiento incontrolados que consumen una cantidad excesiva de tokens y, en consecuencia, el presupuesto. Es una defensa pragmática contra el escenario de la "tarjeta de crédito sin límite". La idea central es imponer límites de tokens estrictos y monitorear el uso acumulativo de tokens dentro de una sesión o tarea de un agente. Si el agente se acerca a un umbral predefinido, el disyuntor se activa, terminando la línea de razonamiento actual, cambiando a un modelo más barato y pequeño, o escalando a una revisión humana. Esto no se trata de sofocar la inteligencia, sino de garantizar un funcionamiento responsable y consciente de los costos.

Así es como visualizo la arquitectura de un agente de IA que aprovecha el almacenamiento en caché y un disyuntor:

Gobernanza y seguridad del modelo

Al implementar agentes de IA, la seguridad es primordial. Los ataques a la cadena de suministro en las herramientas y dependencias de IA son un riesgo creciente para los pipelines de CI/CD y los entornos de desarrollo. Implemente siempre las siguientes prácticas:

• Principio de privilegio mínimo: asegúrese de que las cuentas de servicio de su agente tengan solo los permisos mínimos necesarios para acceder a las API de LLM y otros recursos.
• Rotación de credenciales: rote regularmente las claves API y las credenciales de la nube. Implemente la rotación automatizada siempre que sea posible.
• Aislamiento del entorno: implemente agentes en entornos aislados (por ejemplo, espacios de nombres de Kubernetes, máquinas virtuales dedicadas) para limitar el radio de explosión.
• Registro de auditoría: habilite el registro de auditoría completo para todas las llamadas a la API de LLM y las acciones del agente. Integre estos registros con su SIEM para la detección de anomalías.
• Seguridad de la cadena de suministro: verifique todas las bibliotecas y dependencias de terceros. Utilice escáneres como Trivy o Snyk en CI, y siga marcos como NIST SSDF o SLSA cuando sea apropiado.

El recuento de tokens local proporciona estimaciones para las comprobaciones previas al vuelo y los disyuntores. Sin embargo, para la facturación, siempre confíe en los recuentos oficiales de tokens devueltos por el proveedor de la nube en la respuesta de la API. Estas son las cifras que aparecen en su factura.

Azure y GCP proporcionan funciones de plataforma integradas para la limitación de velocidad y las cuotas, que son la forma más robusta de aplicar límites estrictos.

• Azure: use la política azure-openai-token-limit en API Management para aplicar tasas de tokens por minuto o cuotas fijas.
• GCP: use la política LLMTokenQuota de Apigee para administrar los costos y aplicar límites de consumo de tokens por período de tiempo.

El siguiente código Python ilustra un disyuntor del lado del cliente, que es un patrón flexible que puede implementar directamente en la lógica de aplicación de su agente.

Este ejemplo demuestra un agente conceptual que interactúa con un modelo de GCP Vertex AI. Incluye un contador de tokens del lado del cliente para el disyuntor y muestra cómo estructurar las llamadas para aprovechar la función de almacenamiento en caché de contexto de Vertex AI.

# File: agent_sdk_runner.py
import os
from typing import Dict, Any, List

# --- SDK Imports --- #
# Use the official SDKs for production
import vertexai
from vertexai.generative_models import GenerativeModel, Part
from vertexai.preview.generative_models import caching

# A simple, local token counter for estimates.
# For production, consider a library like tiktoken, but for billing,
# ALWAYS use the usage_metadata from the API response.
def estimate_tokens(text: str) -> int:
    """Provides a rough estimate of token count. Not for billing."""
    return len(text) // 4

class AgentCircuitBreaker(Exception):
    """Custom exception for when the circuit breaker trips."""
    pass

class VertexAIAgent:
    def __init__(self, project_id: str, location: str, model_name: str, max_session_tokens: int):
        self.project_id = project_id
        self.location = location
        self.model_name = model_name
        self.max_session_tokens = max_session_tokens
        self.cumulative_tokens = 0

        vertexai.init(project=project_id, location=location)
        self.model = GenerativeModel(model_name)
        print(f"Agent initialized for model '{model_name}' with max session tokens: {max_session_tokens}")

    def _check_circuit_breaker(self, estimated_next_call_tokens: int):
        projected_total = self.cumulative_tokens + estimated_next_call_tokens
        if projected_total > self.max_session_tokens:
            raise AgentCircuitBreaker(
                f"Circuit breaker tripped! Projected tokens ({projected_total}) exceed session limit ({self.max_session_tokens})."
            )
        print(f"Circuit breaker check OK. Cumulative tokens: {self.cumulative_tokens}, Estimated next call: {estimated_next_call_tokens}")

    def run_interaction(self, system_prompt: str, user_queries: List[str]):
        responses = []
        # --- Caching logic --- #
        # Create a cache. In a real app, you would reuse this cache across sessions.
        # The content of the cache is automatically managed by the SDK.
        # IMPORTANT: Caching in the SDK requires an exact match of the cached prefix.
        # Here, 'system_prompt' is our prefix.
        cached_content = caching.CachedContent.create(
            model=self.model.model_name,
            contents=[Part.from_text(system_prompt)]
        )
        print(f"Vertex AI Context Cache created. TTL: {cached_content.expire_time}")

        # The system prompt is now cached. We only pay the full price once.
        # We can get the token count from the created cache for our circuit breaker.
        # Note: This is a conceptual example. The actual token count for cache creation isn't directly exposed this way.
        # We'll use the response metadata for accurate accounting.

        try:
            for i, query in enumerate(user_queries):
                full_prompt_for_estimation = query if i > 0 else system_prompt + query
                self._check_circuit_breaker(estimate_tokens(full_prompt_for_estimation))

                # For subsequent calls, we use the cache and only send the new user query.
                # The SDK handles combining the cached content with the new content.
                contents_for_call = [Part.from_text(query)]

                # Use the cache in the generation request
                response = self.model.generate_content(contents_for_call, cached_content=cached_content)

                # --- Use official token count from response for circuit breaker --- #
                input_tokens = response.usage_metadata.prompt_token_count
                output_tokens = response.usage_metadata.candidates_token_count
                is_cached = response.usage_metadata.total_token_count < (input_tokens + output_tokens)

                self.cumulative_tokens += input_tokens
                responses.append(response.text)

                print(f"  Query {i+1} processed. Input tokens (billed): {input_tokens}, Output tokens: {output_tokens}")
                print(f"  Cumulative billed input tokens: {self.cumulative_tokens}. Cache hit: {is_cached}")
                print(f"  Response: {response.text.splitlines()[0]}...")

        except AgentCircuitBreaker as e:
            print(f"\nSESSION TERMINATED: {e}")
            responses.append(f"Agent terminated early: {e}")
        finally:
            # Clean up the cache
            cached_content.delete()
            print("Vertex AI Context Cache deleted.")

        return responses

# --- Main Execution --- #
if __name__ == "__main__":
    # This is a conceptual example. You would need to set up authentication.
    # export GOOGLE_APPLICATION_CREDENTIALS="/path/to/your/key.json"
    GCP_PROJECT_ID = os.environ.get("GCP_PROJECT_ID", "your-gcp-project-id")
    GCP_LOCATION = "europe-west4"

    # Illustrative model name for 2026
    MODEL_NAME = "gemini-1.5-pro-preview-0409"

    # Long system prompt to demonstrate caching benefits
    system_prompt = "You are a helpful financial assistant providing concise market analysis... " * 500
    # In a real scenario, this would need to be large enough to meet the provider's min token count for caching.

    user_queries = [
        "What is the current outlook for wind energy investments in EU-West1?",
        "How have carbon credit prices reacted to recent energy crises?",
        "Provide an overview of regulatory changes affecting green bonds in 2025."
    ]

    print("\n=== Testing Agent with Circuit Breaker (GCP) ===")
    # Set a tight token budget to demonstrate the circuit breaker
    agent = VertexAIAgent(GCP_PROJECT_ID, GCP_LOCATION, MODEL_NAME, max_session_tokens=1000)
    responses = agent.run_interaction(system_prompt, user_queries)

Salida esperada (conceptual): la salida mostrará al agente realizando llamadas. Los usage_metadata del SDK de Vertex AI proporcionan el prompt_token_count exacto. Para un acierto de caché, este recuento será mucho menor que la llamada inicial, reflejando solo los tokens en la nueva consulta del usuario. Si los tokens acumulativos superan max_session_tokens, se generará la excepción AgentCircuitBreaker, terminando la sesión.

Para verificar su implementación, ejecute el script del agente con sus credenciales de la nube configuradas. Monitoree la salida del registro para:

• Aciertos de caché: después de la primera llamada, las llamadas posteriores deben mostrar un prompt_token_count significativamente menor en los usage_metadata devueltos por el SDK. Esto confirma que se está utilizando la caché.
• Activación del disyuntor: establezca un límite bajo de max_session_tokens. El agente debe dejar de procesar consultas y generar la excepción AgentCircuitBreaker una vez que el recuento acumulativo de tokens exceda este umbral. Esto confirma que su mecanismo de control de costos funciona.

1. Error: AgentCircuitBreaker: Agent circuit breaker tripped! Solución: este es el comportamiento previsto del disyuntor. Para permitir interacciones más largas, aumente el max_session_tokens al inicializar el agente.

2. Error: Fallo de caché en llamadas posteriores, incluso con un prompt de sistema idéntico. Solución: el almacenamiento en caché requiere que la parte almacenada en caché del prompt sea exactamente idéntica. Asegúrese de que no se agreguen espacios adicionales o caracteres. Además, verifique que cumpla con los requisitos mínimos del proveedor para el almacenamiento en caché, como el recuento mínimo de tokens en el contexto almacenado en caché. Para las API de LLM reales, verifique los parámetros de almacenamiento en caché específicos del proveedor a través de su documentación de la API, por ejemplo, los documentos de almacenamiento en caché de google o los documentos de almacenamiento en caché de openai.

• El almacenamiento en caché de contexto es crucial para las interacciones de agentes de múltiples turnos; preste siempre mucha atención al requisito de coincidencia exacta y a los recuentos mínimos de tokens para obtener el máximo ahorro.
• La evaluación comparativa de modelos como gemini, gpt y opus por cada 1m de tokens de entrada es esencial para una selección informada del proveedor y del modelo basada en la eficiencia de costos.
• Los disyuntores agenticos son una salvaguardia innegociable que evita bucles de razonamiento costosos y proporciona un control granular sobre el gasto de los agentes de IA.
• Las mejores prácticas de seguridad en torno a las credenciales, el aislamiento del entorno y la cadena de suministro son fundamentales al desplegar agentes autónomos.

El siguiente paso más importante y accionable para cualquier gerente de proyecto o arquitecto de IA es integrar estos controles de costos desde el primer día. Un poco de disciplina arquitectónica inicial realmente ahorra muchos costos operativos.

Recursos externos:

• Almacenamiento en caché y costos (proveedores): almacenamiento en caché de prompts de openai, almacenamiento en caché de api de gemini, descripción general del caché de contexto de vertex ai, precios de amazon bedrock
• SDK oficiales de Python:
  • cliente python de google cloud vertex ai
  • azure openai python (azure-ai-openai)
  • boto3 bedrock-runtime

Ejemplos de código adicionales:

Para patrones de agentes más avanzados y técnicas de optimización de costos, consulte el repositorio de github de langchain o los ejemplos de transformadores de hugging face, adaptando sus ejemplos para incorporar un conteo explícito de tokens y verificaciones de presupuesto.