Agentes IA: observabilidad y tracing en producción

AI Integration

•1 de julio de 2026•6 min read•Por Daily Miranda Pardo

El agente funciona en local. Staging pasa. Lo despliegas. Una semana después, un usuario te manda una captura: la respuesta no tiene ningún sentido.

Abres los logs. Hay un 200 OK. El proceso terminó sin errores. El LLM respondió. Y no tienes idea de qué input recibió, qué contexto tenía, qué tool call ejecutó antes ni por qué devolvió eso.

Eso es un sistema de IA sin observabilidad. Y en producción es exactamente tan útil como volar sin instrumentos.

Por qué los agentes fallan diferente al software normal

El software clásico falla de formas predecibles: null pointer, timeout, respuesta 500. Cuando algo se rompe, hay un stack trace, hay un log, hay una causa.

Los agentes IA fallan de formas que no activan ninguna alarma:

El LLM recibió un contexto mal estructurado y generó una respuesta plausible pero incorrecta
Una tool call devolvió datos vacíos y el agente los asumió como válidos
El historial de conversación creció tanto que el modelo perdió el hilo de los primeros mensajes
Un cambio de versión del modelo alteró el comportamiento de un prompt que antes funcionaba bien

Ninguno de estos es un error técnico. Son fallos semánticos. Sin observabilidad, son invisibles.

Los tres vectores de fallo que no puedes detectar sin tracing

1. Pérdida de contexto

Los agentes con memoria acumulan contexto por sesión. Si no controlas el tamaño de la ventana de contexto, llega un punto en que el modelo trunca desde el principio. Los mensajes más antiguos desaparecen. Si el agente construía su razonamiento sobre esas primeras instrucciones, ya no puede.

El síntoma: el agente responde correctamente a preguntas cortas pero falla en tareas que requieren coherencia a lo largo de múltiples turnos.

2. Fallo silencioso en tool calls

Una herramienta devuelve un JSON vacío, un 404, o un campo null que nadie esperaba. El agente lo lee, decide que no hay datos disponibles, y responde al usuario de forma genérica.

Sin trazabilidad, ves la respuesta final. No ves el {} que recibió de la herramienta y que provocó esa respuesta.

3. Deriva de comportamiento por prompt decay

Los prompts que escribiste en marzo para un modelo concreto pueden comportarse diferente en julio si hubo un cambio de weights o un update de versión. El modelo sigue respondiendo. No falla. Solo responde distinto.

Sin un baseline registrado — las entradas y salidas de referencia que defines como "correcto" — no tienes forma de detectar cuándo un agente empieza a desviarse.

Qué instrumentar desde el día uno

Antes de desplegar cualquier agente a producción, tienes que capturar estas cuatro cosas por cada ejecución:

Prompt completo enviado al LLM. No solo el mensaje del usuario — el system prompt, el historial, las definiciones de herramientas, todo. Es lo único que te permite reproducir exactamente lo que vio el modelo.

Respuesta completa del LLM. El texto y, si hay tool calls, el JSON de cada llamada con sus argumentos.

Resultado de cada tool call. Lo que devolvió la herramienta, el tiempo que tardó, y si hubo error o éxito.

Métricas de la llamada. Tokens de entrada, tokens de salida, latencia, modelo usado, coste estimado.

Con eso puedes reconstruir cualquier conversación. Puedes encontrar exactamente qué vio el modelo justo antes de dar una respuesta incorrecta.

Implementación real: trazabilidad con Langfuse en TypeScript

Langfuse es la herramienta open-source más usada para tracing de LLMs. Se integra con el Anthropic SDK en menos de 20 líneas:

import Anthropic from "@anthropic-ai/sdk";
import { Langfuse } from "langfuse";

const anthropic = new Anthropic();
const langfuse = new Langfuse({
  secretKey: process.env.LANGFUSE_SECRET_KEY!,
  publicKey: process.env.LANGFUSE_PUBLIC_KEY!,
  baseUrl: process.env.LANGFUSE_BASEURL ?? "https://cloud.langfuse.com",
});

async function runAgent(userMessage: string, sessionId: string) {
  const trace = langfuse.trace({
    name: "agent-execution",
    sessionId,
    input: { userMessage },
  });

  const span = trace.span({ name: "llm-call", input: { userMessage } });

  const response = await anthropic.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 1024,
    system: "Eres un asistente de soporte empresarial.",
    messages: [{ role: "user", content: userMessage }],
  });

  const output =
    response.content[0].type === "text" ? response.content[0].text : "";

  span.end({
    output,
    usage: {
      input: response.usage.input_tokens,
      output: response.usage.output_tokens,
    },
  });

  trace.update({ output });
  await langfuse.flushAsync();
  return output;
}

Con esto, cada llamada queda registrada en el dashboard de Langfuse con el prompt completo, la respuesta, el coste y la latencia. Puedes filtrar por sesión, reproducir conversaciones exactas, y comparar el comportamiento entre versiones del agente.

Si trabajas con agentes que invocan herramientas externas, añade un span por cada tool call:

async function callTool(
  toolName: string,
  args: Record<string, unknown>,
  parentTrace: ReturnType<typeof langfuse.trace>
) {
  const toolSpan = parentTrace.span({ name: `tool-${toolName}`, input: args });
  try {
    const result = await executeTool(toolName, args);
    toolSpan.end({ output: result, level: "DEFAULT" });
    return result;
  } catch (error) {
    toolSpan.end({ output: { error: String(error) }, level: "ERROR" });
    throw error;
  }
}

Alertas que realmente importan en producción

Registrar datos sin alertas es tan inútil como no registrarlos. Estas cuatro métricas justifican una alerta inmediata en cualquier agente de producción:

Coste por sesión por encima del umbral. Si una conversación normal cuesta 0,02 € y hay una sesión que cuesta 0,80 €, algo está mal — probablemente un bucle de tool calls o un historial que creció sin control.

Latencia de tool call superior a 5 segundos. Un servicio externo lento no rompe el agente, pero degrada la experiencia y oculta timeouts futuros que sí lo romperán.

Tasa de error en tool calls superior al 5%. Un 5% de fallos en herramientas es señal de un problema de integración que no se arreglará solo.

Crecimiento del tamaño del contexto sesión a sesión. Si los tokens de entrada crecen linealmente con cada turno sin un mecanismo de truncado, tendrás un context overflow en producción antes de lo que esperas.

En DAILYMP incluimos esta instrumentación como estándar en cualquier proyecto de integración IA: el agente se entrega observable desde el primer día, con dashboards y alertas configuradas antes del primer despliegue.

Lo que cambia cuando puedes ver lo que hace el agente

La diferencia práctica no es técnica — es operativa. Cuando tienes trazabilidad:

El primer informe de bug incluye un trace ID, no "a veces falla con no sé qué"
Puedes comparar el comportamiento del agente antes y después de cambiar un prompt
Puedes auditar qué datos procesó el agente en cada conversación sin reconstruirlo desde cero
Puedes mostrarle al cliente exactamente qué vio el modelo y por qué respondió así

Los agentes IA que se despliegan en producción fallan. Todos fallan en algún momento. La diferencia entre un sistema mantenible y uno que se convierte en una caja negra es que el primero falla de forma visible.

Si estás construyendo un agente para producción y quieres asegurarte de que es depurable desde el primer día, hablamos en 30 minutos →