LLMs tan calientes que te queman el bolsillo
¿Te acuerdas de los primeros días de la nube? El mayor dolor de cabeza en FinOps era la VM sin tag: un dev levantaba un servidor enorme, se olvidaba de etiquetarlo y ¡PUM!, a fin de mes aparecía un gasto sin asignar, misterioso y molesto. Sí, dolía, pero el costo solía acumularse a lo largo de semanas.
Pues bien, abróchate el cinturón. FinOps para IA ya llegó y te va a dejar con tortícolis. El nuevo agujero negro de costos no es un servidor encubierto: son los tokens descontrolados.
Cuando un prompt sin optimizar le pega a un LLM caro 100 veces por segundo, tu presupuesto no se filtra… explota. Hablamos de picos de costo que revientan el presupuesto en horas, no en meses.
¿La solución? Hay que mover el foco del tagging de infraestructura a la telemetría a nivel de aplicación. Necesitamos rastrear el costo de cada token, en tiempo real.
Esto cobra especial relevancia cuando hablamos de agentes de IA — no los chatbots donde cada sesión se vincula fácilmente a un usuario específico, sino un agente autónomo que puede estar trabajando para todo el equipo.
FinOps para IA: la telemetría de la nube no alcanza
La forma tradicional de rastrear costos —usando las facturas del proveedor de nube (Cost Explorer, Cost Management, etc.)— resulta demasiado lenta y demasiado gruesa para el uso de APIs de IA.
La siguiente tabla compara FinOps 1.0 con el FinOps para IA emergente:
| Característica | FinOps de nube temprano | FinOps actual para IA (API)
|------------------|--------------------------------|----------------------------------------
| Unidad de costo | Hora de VM, GB de almacenamiento| Token de entrada, token de salida
-------------------|--------------------------------|-----------------------------------------
| Driver de costo | Recursos ociosos, | Eficiencia del prompt,
| | egreso de red | selección de modelo
-------------------|--------------------------------|-----------------------------------------
| Visibilidad | Logs de facturación diaria/horaria| Telemetría por transacción en tiempo real
-------------------|--------------------------------|-----------------------------------------
| Optimización | Apagar servidores | - Reescribir el prompt/código
| | | - Selección de modelo en tiempo real
-------------------|--------------------------------|-----------------------------------------
Para gestionar de verdad el costo de las aplicaciones de IA, no podemos esperar a que llegue la factura. Se necesita inteligencia FinOps embebida directamente en la capa de aplicación, que reporte cada token enviado o recibido. Aquí es donde OpenTelemetry (OTel) viene al rescate.
Tutorial: cómo instrumentar tu agente de IA con OpenTelemetry
OpenTelemetry es un framework open-source que ofrece un estándar único para recolectar datos de observabilidad (trazas, métricas y logs). Podemos aprovechar sus capacidades de tracing para envolver las llamadas a LLMs e inyectar el contexto FinOps crítico que necesitamos.
El siguiente ejemplo muestra cómo implementar el seguimiento de asignación de costos FinOps para agentes de IA usando OpenTelemetry y el Agent Development Kit (ADK) de Google.
Este código es tu llave a la libertad FinOps: garantiza que cada token que use tu agente de IA quede etiquetado al instante con el dueño del presupuesto correcto. ¡Se acabaron las adivinanzas!
El código completamente ejecutable está aquí: https://github.com/antweiss/finops-ai-otel.
AVISO IMPORTANTE: ¡no apto para producción!
Para este tutorial usamos ConsoleSpanExporter para imprimir los datos crudos del trace en tu terminal. ¡En un entorno productivo NUNCA harías esto!
En su lugar, reemplazarías el exporter de consola por un OTLP Exporter dedicado que envíe los datos a un backend robusto, como:
- Google Cloud Trace: la opción nativa para usuarios de Google Cloud.
- Un backend de observabilidad gestionado: como Jaeger, Datadog o New Relic.
- Una plataforma dedicada de gestión FinOps como DoiT Cloud Intelligence
Estos backends te permiten consultar y agregar los datos para correr reportes FinOps como: "Muéstrame el total de tokens usados donde finops.project_code sea 'BLOG-FINOPS-001' en los últimos 30 días". ¡Así es como conviertes un trace en un reporte de costos!
Pasos 1 y 2: prepárate para ejecutar
¡Ya conoces la rutina! Clona el repo, instala las dependencias y configura tu API key.
git clone https://github.com/antweiss/finops-ai-otel.git
cd finops-ai-otel
pip install -r requirements.txt
export GEMINI_API_KEY="YOUR_API_KEY_HERE"
Paso 3: ejecuta el código y mira cómo fluyen los tokens
Cuando ejecutas el archivo agent.py, el superpoder FinOps se activa dentro de la función run_finops_session.
python agent.py
Cómo entran los tags FinOps (desglose del código)
El objetivo es envolver toda la actividad del agente en un Span personalizado de OpenTelemetry que lleve los detalles del presupuesto.
Iniciar el Span FinOps:
with tracer.start_as_current_span("adk-agent-session") as span:
¡En esta línea está todo el truco! Iniciamos un span y lo declaramos span activo actual. Cualquier código posterior que también esté instrumentado con OTel (como las llamadas internas al LLM del ADK de Google) creará automáticamente sus propios spans como hijos de este span padre activo.
Agregar la metadata FinOps (tags):
span.set_attribute("finops.team_id", team_id)
span.set_attribute("finops.project_code", project_code)
¡Justo aquí inyectamos los detalles del centro de costos! Como los spans internos del ADK (que contienen los conteos de tokens) son hijos de este span, tu backend de tracing verá todo el uso de tokens directamente bajo el finops.project_code. ¡Asignación resuelta!
Las métricas FinOps críticas
def setup_opentelemetry_tracer():
"""Configures the Tracer to output to the console for a runnable demo."""
# 1. Create a TracerProvider
provider = TracerProvider()
# 2. Add a simple processor that exports traces to the console
# This shows the raw trace data and attributes!
provider.add_span_processor(SimpleSpanProcessor(ConsoleSpanExporter()))
# 3. Set it as the global provider
trace.set_tracer_provider(provider)
return trace.get_tracer("finops.adk.agent")
La salida de ConsoleSpanExporter es tu reporte de costos inmediato. Busca el span anidado de la llamada al LLM para tener el panorama completo y facturable (los atributos finops.* los define el código de ejemplo, mientras que los atributos llm.* y las métricas provienen del LLMAgent del ADK):
FinOps avanzado: propagar spans en flujos multi-agente
¿Y qué pasa con flujos complejos donde un agente le delega trabajo a otro? Aquí es donde brilla el poder de OpenTelemetry.
- En el modelo de OTel, cuando un agente (el padre) llama a otro agente o herramienta (el hijo), el contexto del trace del span padre se propaga automáticamente por la cadena de llamadas.
- Toda la secuencia de agentes y herramientas se ejecuta dentro del contexto del Span FinOps inicial.
- Esto significa que un único tag FinOps de nivel superior cubre toda la coreografía multi-paso del agente: obtienes un reporte de costos unificado y auditable para todo el flujo. Esta funcionalidad se hereda de la instrumentación estándar de OTel que usa ADK.
Enlaces
Para profundizar en los fundamentos que hacen posible esta solución FinOps:
Confirma el soporte nativo e integrado de ADK para la instrumentación con OpenTelemetry.
Primeros pasos con OpenTelemetry
Explica los principios subyacentes de Spans, Contexto y Propagación de Contexto.
Detalla los tipos de agentes (LlmAgent, SequentialAgent) que se benefician de este tracing.
En el próximo post veremos cómo introducir guardrails de costo efectivos para tus aplicaciones de IA.