Evals: la capa después del tracing que decide si tu LLM rinde o sólo parece rendir

Wed, 20 May 2026 00:12:00 +0200

TL;DR

Tracing te dice qué ha pasado dentro de tu aplicación LLM: qué prompts entraron, qué tokens salieron, qué tools se llamaron. Evals te dice si eso está bien. Son dos capas distintas: no hay overlap, no hay sustitución, hay continuidad. En 2026 el campo se ha estabilizado alrededor de una arquitectura de dos pisos: un framework ligero estilo pytest (DeepEval, Promptfoo, Ragas) que corre en CI y bloquea el merge si la regresión es seria, y una plataforma de observabilidad (Langfuse, LangSmith, Arize Phoenix, Braintrust) que persiste evaluaciones a largo plazo, permite anotación humana, detecta drift, da dashboard a stakeholders. La técnica dominante es LLM-as-a-judge: un modelo evaluador con una rúbrica determina si la respuesta es buena, 80-90% de acuerdo con humanos a 500-5000x menos coste y, calibrado correctamente, en producción. Para RAG hay las cuatro métricas canónicas de Ragas (faithfulness, answer relevancy, context precision, context recall). Para agentes, trajectory matching, accuracy de selección de tools y pass^k —la métrica recién popularizada por Tau-bench que reveló que muchos agentes con pass^1 alto tienen pass^4 hasta 25 puntos por debajo, es decir, son inconsistentes—. Este artículo recorre los seis ángulos: por qué evaluar LLMs es distinto, las cuatro patas de un sistema de evals, LLM-as-a-judge en serio (G-Eval, position bias, calibración), métricas para RAG y agentes, el panorama de herramientas 2026 con sus diferencias reales, y la receta operativa para tener evals que no sean teatro.

Este artículo abre la serie de capas post-tracing. Viene encadenado del cierre de la serie eBPF de ayer (AgentSight y el nuevo tracing de LLMs), donde quedó apuntado que evals es “el mundo aparte que sigue al tracing”. Es ese mundo.

La analogía: el test suite que tu pipeline de ML siempre quiso

Quien lleve años desarrollando software no encontrará nada raro en la idea de tests automatizados: cada commit dispara una suite que se valida contra outputs esperados, y si algo se rompe, el merge falla. Es lo que separó programar en los 90 de programar en los 2010. Imposible imaginar producción sin esto.

Cuando llegaron los modelos de Machine Learning clásicos, el patrón se preservó parcialmente: tests de entrada/salida determinista, plus métricas de modelo (accuracy, F1, AUC) sobre un dataset de validación. Imperfecto pero funcionaba; los modelos eran determinísticos y las predicciones tenían etiquetas claras.

Con los LLMs, el patrón se rompió. ¿Cómo testeas que la respuesta a “explícame qué es un transformer” es correcta? No hay una sola respuesta correcta, hay una distribución de respuestas razonables. ¿Cómo testeas que un agente eligió la herramienta adecuada para resolver un problema multistep? La función de coste es subjetiva, dependiente del contexto, y a menudo emerge solo cuando el dominio experto lo mira.

Lo que ha pasado en los últimos tres años es la construcción colectiva del equivalente al test suite para LLMs. Aún imperfecto, aún en evolución, pero ya operacionalmente viable. Las piezas existen: datasets curados, evaluadores que escalan (LLM-as-a-judge), frameworks que corren en CI, plataformas que persisten regresión. Lo que cambia respecto a tests tradicionales es que el resultado del eval también es probabilístico: el judge se puede equivocar; medimos su acuerdo con humanos y aceptamos un umbral. Vivimos con la incertidumbre como parte del sistema.

Por qué evaluar LLMs es estructuralmente distinto

Cinco diferencias que cambian todo:

No-determinismo. Mismo input → distinto output según temperature, top_p, seed. Un test que pasaba ayer puede fallar hoy sin haber tocado nada. La solución no es eliminar el no-determinismo (a veces lo quieres); es medir en distribución, no en una muestra única.

No hay golden answer única. Para “resume este artículo en 3 frases”, hay miles de resúmenes válidos. Comparar bit-a-bit con una “respuesta correcta” es absurdo. Evaluamos propiedades de la respuesta (fidelidad, concisión, no contradicción), no igualdad textual.

Métricas clásicas son insuficientes. BLEU, ROUGE, BERTScore funcionaban en traducción automática y resumen extractivo. Para generación abierta correlan muy mal con juicio humano. Es famoso el contraejemplo: una respuesta semánticamente correcta puede tener BLEU bajo porque usa otras palabras; una respuesta incorrecta puede tener BLEU alto porque copia tokens del input. Hace falta otra cosa.

Coste cuadrático del juicio humano. La alternativa obvia —“que personas evalúen cada respuesta”— escala terriblemente. Una app con 100 conversaciones/día genera 3.000/mes; evaluar cada una requiere horas de un humano caro. Para apps con miles o millones de queries, inviable.

Drift en producción. El modelo no cambia; el mundo cambia. Cambia el vocabulario de los usuarios, cambia el contenido de los documentos del RAG, cambia el comportamiento de los modelos cuando vendor los actualiza silenciosamente. Sin eval continuo, la app degrada y nadie se entera hasta que un cliente se queja.

Estos cinco puntos explican toda la arquitectura moderna de evals: necesitamos automatizar el juicio (LLM-as-a-judge), medir propiedades en distribución (no igualdad exacta), persistir resultados a lo largo del tiempo (detección de drift) y mantener un anclaje humano (golden datasets calibrados).

Las cuatro patas de un sistema de evals

Cualquier framework moderno gira sobre cuatro componentes:

1. Datasets

Un dataset de evaluación tiene una forma mínima: lista de entradas + cómo se juzga cada salida. Dos modelos:

Dataset con golden output: para cada entrada, tienes la respuesta correcta (o una lista de aceptables). El evaluador compara generación con golden. Caso típico: NER, clasificación, traducción.
Dataset con criteria: para cada entrada, tienes una rúbrica abstracta (“la respuesta debe ser factual respecto al contexto”, “el tono debe ser profesional”). No hay golden; el evaluador aplica la rúbrica.

Los datasets buenos en producción son mantenidos activamente: empiezas con 20-50 ejemplos curados a mano, los etiquetas con resultados deseados, y vas creciendo el dataset con los casos reales que han causado problemas (regression dataset). Después de un año en producción, debería haber cientos o miles de casos, cada uno respaldado por una incidencia o un patrón observado.

2. Evaluators

Lo que toma generación + criterios y devuelve un score. Cuatro familias:

Determinísticos / heurísticos: regex, longitud, presencia de tokens, validación de JSON schema. Rápidos, baratos, pero solo aplicables a propiedades sintácticas.
Semánticos clásicos: BERTScore, embeddings cosine similarity. Mejor que BLEU para igualdad semántica, pero limitados a “comparar contra golden”.
LLM-as-a-judge: un modelo —típicamente GPT-4, Claude, o un open-source especializado como Prometheus— recibe generación + criterios y devuelve score. El caballo de batalla del campo en 2026.
Humanos: la verdad de referencia. Caro, lento, pero indispensable como anclaje (golden set).

En una pipeline madura, los cuatro coexisten: heurísticos como gate inicial (¿es JSON válido?), semánticos para checks rápidos, LLM-as-judge para la mayoría de evaluación, y humanos en muestreo periódico para calibrar.

3. Runners

Ejecutan dataset × evaluators y producen el cuadro de resultados. Lo que en pytest serían pytest --collect-only + pytest -v. Las cosas que un runner serio tiene que hacer:

Paralelización: cientos de prompts no pueden ejecutarse en serie.
Caché: si re-ejecutas un eval con el mismo prompt y modelo, no pagar dos veces.
Retry y backoff: rate limits de las APIs son la norma.
Trazabilidad: cada run identificado con commit, version del prompt, version del dataset, version del evaluator.
Aggregation: medias, percentiles, breakdown por segmento.

4. Storage y analytics

Un eval que se ejecuta y se imprime en pantalla no sirve. Hay que persistir resultados a lo largo del tiempo para detectar regresión y drift. Aquí entran las plataformas (Langfuse, LangSmith, Phoenix): cada eval-run se guarda con metadata, se puede comparar contra runs anteriores, se generan dashboards.

LLM-as-a-judge: el caballo de batalla

Esta es la técnica que ha hecho factible eval automático a escala. Vale la pena entender bien cómo funciona y qué problemas tiene.

El modelo básico

Le das al judge un prompt estructurado:

You are evaluating the quality of a customer support agent's response.
User question: "How do I cancel my subscription?"
Agent response: "To cancel, log into your account, go to Settings >
Billing, click Cancel. Note that you'll retain access until the end
of your current billing period."
Rubric:
- Accuracy (1-5): Does the response factually answer the question?
- Completeness (1-5): Does it cover all relevant steps?
- Tone (1-5): Is it professional and helpful?
Provide a JSON response with the three scores and a brief justification.

El judge devuelve un JSON. Las tres notas, una justificación corta. Caso resuelto.

Scoring rubric vs pairwise comparison

Dos modelos principales:

Scoring rubric (absoluto): el judge devuelve un número en una escala (típicamente 0-1, 1-5 o 1-10). Sencillo, ortogonal entre evaluaciones. Pero los modelos LLM son malos en escalas absolutas: tienden a apilarse en valores medios (3-4 en escala 1-5) y a no usar los extremos. Las correlaciones con humanos en scoring absoluto suelen rondar el 0.6-0.7.

Pairwise comparison: el judge ve dos respuestas (A y B) y elige cuál es mejor. Los modelos son mucho mejores en pairwise que en absoluto; las correlaciones suben a 0.75-0.85. Razón: es la tarea natural de un modelo de lenguaje (modelar relación entre dos cosas), no asignar números abstractos.

La práctica recomendada: usar pairwise cuando puedas. Para regresión ("¿v4 del prompt mejora sobre v3?"), pairwise es ideal. Para producción ("¿esta respuesta es buena?"), donde no tienes otra contra qué comparar, scoring absoluto con cuidado.

G-Eval: el patrón que más se usa

G-Eval (Liu et al., NAACL 2023) es el patrón de prompting que más correlación con humanos consigue de los métodos públicos. Tiene tres ingredientes:

Auto-CoT: el prompt induce al judge a generar su propia cadena de razonamiento sobre los pasos a evaluar antes de dar nota. No le dices la rúbrica; le pides que la deduzca y aplique.
Form-filling: en lugar de pedir números libres, el judge rellena un formulario estructurado con campos específicos (presencia de elementos, errores detectados).
Probability-weighted scores: en lugar de “qué nota das”, se pide la probabilidad de cada nota y se hace una expectativa ponderada. Mitiga la tendencia a apilarse en valores medios.

G-Eval implementado bien alcanza 0.89 de correlación de Spearman con humanos en datasets de summarization. Es lo que las plataformas serias usan por defecto bajo el capó. Para tu trabajo: no implementes G-Eval a mano; usa la versión de DeepEval o de Phoenix que ya lo trae.

Calibración contra humanos: el paso no negociable

Un judge sin calibrar es teatro. La práctica:

Construye un golden set anotado por humanos (50-200 ejemplos como mínimo).
Corre el judge sobre ese golden set.
Mide el agreement con humanos (Cohen’s kappa, Spearman, o accuracy si la tarea es binaria).
Si el agreement es <85%, el judge no es fiable para esa tarea; itera sobre el prompt o cambia de modelo judge.
Repite cada 60-90 días. Los judges drift en silencio: cambios de versión del modelo, cambios de comportamiento que el vendor hace sin avisar.

El número de referencia que cita la literatura 2026: 85-90% de agreement con humanos es el umbral para considerar el judge productivo. Por encima, automatizas con cobertura humana en muestreo. Por debajo, sigues siendo manual.

Los sesgos del judge: lo que pega tiros en producción

Cinco sesgos identificados que cualquier judge tiene en algún grado:

Position bias: en pairwise, el judge favorece la respuesta que aparece primero (o última, según modelo). Mitigación obligatoria: swap and average — corre cada par dos veces, una en orden A-B y otra en B-A, y promedia. Si los dos órdenes contradicen, ese par es ambiguo, lo marcas como tal.

Length bias: respuestas más largas tienden a recibir mejor nota porque “parecen más completas”. Mitigación: normaliza por longitud o penaliza explícitamente en la rúbrica. Las plataformas modernas detectan esto y lo reportan.

Verbosity bias: similar al length bias pero con jerga técnica: respuestas que suenan más sofisticadas se puntúan mejor, aunque sean menos correctas. Mitigación: usar judges que citen evidencia concreta del input.

Self-preference: si el judge es del mismo proveedor que el modelo evaluado (GPT-4 evaluando GPT-4), tiende a favorecer respuestas del propio proveedor por estilo. Mitigación: cross-judge — usa un judge de un proveedor distinto al modelo bajo prueba.

Shortcut bias (el “Silent Judge” del paper de 2025): los judges aprenden atajos no intencionados; por ejemplo, asociar respuestas que empiezan por “Certainly!” con mayor calidad porque sí. Mitigación: tener una rúbrica explícita y ejemplos calibrados; medir agreement contra golden set humano periódicamente.

Coste y judges open-source

GPT-4 como judge es excelente pero caro. A 5 USD/millón input tokens y 15 USD/millón output, una pipeline que evalúa 50 000 respuestas/día puede costar decenas de miles de USD/mes solo en evals.

La respuesta del campo: judges open-source especializados. Prometheus (KAIST + LG AI) entrena un modelo open-source pequeño específicamente para juzgar con rúbrica, y alcanza 0.897 de correlación de Pearson con humanos en 45 rúbricas — comparable a GPT-4 (0.882) a una fracción del coste.

Otros modelos en la misma línea: JudgeLM, PandaLM, modelos Auto-J. La práctica madura es usar judges open-source para la mayoría del tráfico, GPT-4/Claude para casos críticos (regresión profunda, golden set re-evaluación).

Métricas específicas para RAG

Si tu sistema es Retrieval-Augmented Generation, hay cuatro métricas canónicas que Ragas popularizó y que el resto del ecosistema ha adoptado:

Faithfulness (fidelidad)

¿La respuesta se atiene a los documentos recuperados? Mide alucinación. Se calcula descomponiendo la respuesta en afirmaciones individuales y verificando cuántas están respaldadas por el contexto. Rango 0-1.

Crítico para sistemas donde la respuesta debe ser sourced (legal, médico, financiero). Una respuesta puede sonar bien y aún así inventar; faithfulness lo cazas.

Answer Relevancy (relevancia de la respuesta)

¿La respuesta responde a la pregunta? Independiente de si es factualmente correcta — solo mide on-topic. Se calcula generando varias preguntas inversas a partir de la respuesta y midiendo cuánto se parecen a la pregunta original.

Importante para detectar off-topic drift: respuestas que evaden la pregunta o se desvían.

Context Precision (precisión del contexto)

De los documentos recuperados, ¿cuántos son realmente relevantes? Si tu retrieval devuelve 10 chunks y solo 3 son útiles, la precisión es 0.3. Métrica del retrieval, no del LLM.

Diagnóstico clave: precisión baja indica retrieval ruidoso, probablemente porque el embedding model no captura semántica fina o el chunking es demasiado grande.

Context Recall (recall del contexto)

De los documentos relevantes que existen, ¿cuántos se han recuperado? Requiere golden (saber qué documentos eran los correctos).

Recall bajo indica retrieval limitado: el sistema no encuentra documentos que existían y eran relevantes. Causas: k demasiado bajo, query embedding mal, chunking que rompe contexto necesario.

El cuadrante diagnóstico de RAG

Las cuatro métricas combinadas dan un diagnóstico estructurado:

Faithfulness	Relevancy	Precision	Recall	Diagnóstico
Alto	Alto	Alto	Alto	Sistema sano
Bajo	Alto	Alto	Alto	LLM alucina sobre buen contexto
Alto	Bajo	Alto	Alto	LLM divaga sobre pregunta
Alto	Alto	Bajo	Alto	Retrieval ruidoso (k alto, embeddings malos)
Alto	Alto	Alto	Bajo	Retrieval incompleto (k bajo, chunking malo)
Bajo	Bajo	Bajo	Bajo	Empieza por arreglar retrieval

Ragas mantiene además otras métricas más sofisticadas: noise sensitivity (cómo afecta inyección de ruido), context entities recall (recuperación de entidades específicas), multimodal faithfulness/relevance para RAG sobre imágenes y vídeo.

Métricas específicas para agentes

Los agentes con tool use multi-step rompen el modelo single-turn de RAG. Necesitan métricas que entiendan trayectoria de acciones, no solo respuesta final.

Tool selection accuracy

¿El agente eligió la herramienta correcta? Métrica clásica de classification. Para cada turno donde el agente tenía que decidir entre herramientas, comparas selección con la correcta.

Variantes:

Exact match: la herramienta elegida es la golden.
Top-k: la golden está entre las top-k consideradas (medido por logprobs si están disponibles).

Trajectory matching

Compara la secuencia completa de acciones del agente con una trayectoria golden. Para tareas multistep, una respuesta final correcta puede haberse llegado por un camino tortuoso e ineficiente, o por un camino directo. Trajectory matching captura la diferencia.

Variantes:

Exact trajectory: secuencia idéntica de tool calls (rara vez factible).
Soft trajectory: porcentaje de pasos correctos, permitiendo ramas alternativas válidas.
Trajectory similarity: embedding de la secuencia comparado con embedding de la golden.

Task completion rate

¿El agente terminó la tarea exitosamente? Métrica binaria al final. Crítica para benchmarks como Tau-bench (Sierra), GAIA (Meta + HF), SWE-bench (Princeton).

pass^k: la métrica que cambió las leaderboards

Tradicionalmente los benchmarks reportaban pass^1: ejecutas el agente una vez por tarea, mides cuántas resolvió. El problema de no-determinismo: una ejecución sola es ruido.

pass^k ejecuta cada tarea k veces y mide si el agente la resuelve en las k ejecuciones. Es decir: pass^4 = “el agente resuelve esto consistentemente las 4 veces”. Métrica de fiabilidad, no de capacidad puntual.

El descubrimiento que ha agitado el campo 2026: pass^4 suele estar 15-25 puntos por debajo de pass^1. Es decir, muchos agentes que parecen estado del arte en leaderboards single-run resuelven la tarea solo a veces. Productivamente significa que esos agentes no se pueden poner en producción tal cual — necesitan reintentos, autoconsistencia o human-in-the-loop. Tau-bench fue el primero en formalizar este reporting y otros benchmarks lo están adoptando (Tau²-Bench, ATBench, TRAJECT-Bench).

Benchmarks 2026 importantes

Tau-bench / Tau²-Bench (Sierra): tool-agent-user interaction en dominios empresariales (retail, airline). Reporta pass^k.
GAIA: tareas que requieren razonamiento + tool use + web browsing.
SWE-bench: arreglo de bugs en repos reales de GitHub. El benchmark más exigente para agentes de coding.
ATBench (2026): foco en safety durante la trayectoria, no solo en respuesta final.
TRAJECT-Bench: agentic tool use evaluado a nivel trayectoria con métricas estandarizadas.
Inspect AI evals (UK AI Safety Institute): foco en capability y safety, abierto.

El panorama de herramientas 2026

El campo se ha estabilizado en dos categorías que rara vez compiten directamente:

Categoría A: testing frameworks (gating en CI)

Pensados para correr como tests, bloquear merges, dar feedback rápido al desarrollador.

DeepEval (Apache 2.0). El más popular hoy. Estilo pytest:

from deepeval import assert_test
from deepeval.test_case import LLMTestCase
from deepeval.metrics import GEval, FaithfulnessMetric

def test_rag_response():
 test_case = LLMTestCase(
 input="What's the capital of France?",
 actual_output=my_rag_app("What's the capital of France?"),
 retrieval_context=docs,
 )
 geval_metric = GEval(
 name="Correctness",
 criteria="Determine if the answer is factually correct.",
 evaluation_params=["input", "actual_output"],
 )
 faithfulness = FaithfulnessMetric(threshold=0.7)
 assert_test(test_case, [geval_metric, faithfulness])

Trae 30+ métricas pre-hechas, incluye G-Eval, integra con CI/CD trivial. La librería más completa en cobertura.

Promptfoo (MIT). CLI-first, configuración en YAML. Especializado en red teaming y comparación de modelos:

providers:
 - openai:gpt-4o
 - anthropic:claude-3.5-sonnet
 - openrouter:meta-llama/llama-3.3-70b

prompts:
 - "Summarize: {{text}}"

tests:
 - vars:
 text: "..."
 assert:
 - type: llm-rubric
 value: "Summary is accurate and concise"
 - type: contains
 value: "..."

Corre la misma evaluación contra muchos providers simultáneamente. Fantástico para “qué modelo conviene a esta tarea”. Pioneer en red teaming automatizado: genera ataques de prompt injection y mide robustez.

Ragas (Apache 2.0). Especializado en RAG. Implementa las 4 métricas canónicas más una docena más, lightweight, sin opinionado sobre tu stack:

from ragas import evaluate
from ragas.metrics import faithfulness, answer_relevancy, context_precision, context_recall

result = evaluate(dataset, metrics=[
 faithfulness, answer_relevancy, context_precision, context_recall
])

Si tu sistema es RAG y solo RAG, Ragas es la apuesta más directa.

Otros relevantes: OpenAI Evals (el clásico, OSS), LangSmith Evals SDK (para usuarios LangChain), Inspect AI (UK AISI, fuerte en safety/capability evals).

Categoría B: plataformas (storage + dashboard + regresión)

Pensadas para persistencia a largo plazo, anotación humana, regresión, dashboards a stakeholders.

Langfuse (MIT, self-host disponible). Cubierta en profundidad ayer. Para evals: ejecuta evaluators en background sobre traces de producción, permite human labeling en UI, integra con datasets y prompt management. Es la opción más completa OSS.

LangSmith (comercial). Si usas LangChain, integración cero-config. Datasets, evaluator SDK, runs comparables side-by-side. UI limpia para stakeholders.

Arize Phoenix (ELv2, OSS). OTel-native, fuerte en RAG por su énfasis en retrieval. Evals built-in con LLM-as-judge configurable.

Braintrust (comercial, OSS lite). El competidor más joven en plataformas; fuerte en datasets y comparativa side-by-side. Adoptado por equipos que vienen de hacer evals “en una hoja de cálculo” porque la UX está pulida.

Tabla comparativa: testing frameworks vs platforms

Herramienta	Tipo	Licencia	Self-host	Especialidad	Idóneo cuando
DeepEval	Framework CI	Apache 2.0	N/A	Maximalismo de métricas	Quieres pytest para LLMs, 30+ métricas listas
Promptfoo	Framework CI	MIT	N/A	Modelo comparison + red teaming	Eliges modelo, atacas prompt
Ragas	Framework CI	Apache 2.0	N/A	RAG end-to-end	Tu sistema es exclusivamente RAG
OpenAI Evals	Framework CI	MIT	N/A	Clásico, simple	Empezando, OpenAI nativo
Inspect AI	Framework CI	MIT	Sí	Safety / capability evals	Evaluación de modelos base, alignment
Langfuse	Platform	MIT	Sí	Suite completa (trace+eval+prompts)	OSS, self-host, equipo iterativo
LangSmith	Platform	Comercial	No	LangChain ecosystem	Tu stack es LangChain
Arize Phoenix	Platform	ELv2 (OSS)	Sí	OTel-native, RAG	Estandarización OTel, RAG profundo
Braintrust	Platform	Comercial + OSS	Limitado	UX pulida, datasets	Stakeholders no-técnicos, side-by-side

La receta operativa: stack de dos pisos

La estructura que más se ve en equipos productivos en 2026:

Piso 1 — Framework de CI

DeepEval o Promptfoo (o Ragas si es RAG estricto) corriendo en cada PR.
Dataset golden versionado en el repo (~100-500 ejemplos curados).
Métricas con threshold: si baja G-Eval medio por debajo de 0.85, el merge falla.
Tiempo objetivo: <2 minutos para no bloquear el flow del desarrollador.

Piso 2 — Plataforma de regresión + drift

Langfuse / LangSmith / Phoenix / Braintrust persistiendo todos los traces de producción.
Evaluators corriendo sobre muestreo de tráfico real (eg 5-10% de las respuestas evaluadas con LLM-as-judge cada hora).
Dashboard semanal con tendencias por segmento, version de prompt, modelo.
Human labeling de los casos que el judge marca como dudosos.

Ciclo del cambio

Pipeline típico de cambiar un prompt:

Developer modifica el prompt en local.
CI corre eval framework contra dataset golden. Si pasa, merge.
El cambio sube a staging; la plataforma persiste evaluaciones de tráfico real durante 24-48h.
Si la regresión sale: rollback automático o flag.
Si pasa la ventana de staging: promoción a producción.
Eval continuo en producción detecta drift en días/semanas si ocurre.

Lo que cierra el bucle: el dataset golden se enriquece con los casos donde el sistema falló en producción. Cada incidente genera 3-5 ejemplos nuevos en el dataset; el dataset crece como entidad viva durante el ciclo de vida de la app.

Ejemplo concreto: pipeline RAG con DeepEval + Langfuse

Receta minimalista:

# CI: deepeval test (corre en cada PR)
# tests/test_rag.py
import pytest
from deepeval import assert_test
from deepeval.test_case import LLMTestCase
from deepeval.metrics import FaithfulnessMetric, AnswerRelevancyMetric
from deepeval.dataset import EvaluationDataset
from app.rag import answer

dataset = EvaluationDataset()
dataset.add_test_cases_from_json_file(
 file_path="tests/golden_dataset.json",
 input_key_name="question",
 actual_output_key_name="ignore", # se rellena en runtime
 expected_output_key_name="expected_answer",
 context_key_name="ignore",
)

@pytest.mark.parametrize("tc", dataset.test_cases)
def test_rag_quality(tc):
 response, docs = answer(tc.input)
 tc.actual_output = response
 tc.retrieval_context = [d.content for d in docs]
 assert_test(tc, [
 FaithfulnessMetric(threshold=0.8),
 AnswerRelevancyMetric(threshold=0.75),
 ])

# Producción: tracing + eval async con Langfuse
# app/rag.py
from langfuse import observe, get_client
from langfuse.evaluators import faithfulness, answer_relevancy

langfuse = get_client()

@observe(as_type="generation")
def answer(question: str):
 docs = retrieve(question)
 resp = llm.generate(build_prompt(question, docs))
 # eval async en background sobre una muestra
 langfuse.evaluate_async(
 name="faithfulness",
 evaluator=faithfulness,
 input=question,
 output=resp,
 context=docs,
 sample_rate=0.1, # 10% del tráfico
 )
 return resp, docs

Y un dashboard Grafana o Langfuse UI muestra:

Faithfulness p50/p95 por día.
Distribución por namespace o tenant.
Drift respecto al baseline.
Casos peor evaluados para human review.

Cuatro horas de trabajo para tener esto montado en una app que ya tiene Langfuse desplegado. Cero excusas para no hacerlo.

La frontera 2026: lo que el campo aún no ha resuelto

Tres frentes abiertos donde la investigación va activa:

Outcome scoring sigue siendo el problema duro

Ya tenemos el step-level tracing: tool-call accuracy, trajectory analysis, latency per step, input/output por nodo. Te dice cómo se ejecutó el agente.

Lo que no está resuelto es outcome scoring: ¿completó el agente el objetivo en una forma que un experto del dominio aprobaría? Replay del trace no responde esta pregunta. Necesitas a alguien que sepa qué significa “éxito” en el contexto específico — y eso es caro y no escala.

Las propuestas actuales: usar judges fuertes (GPT-4 con CoT) sobre la respuesta final más contexto del trace, dataset de outcomes etiquetados por expertos como golden, ensembles de judges para alta varianza. Ninguna es magia.

Trajectory benchmarks emergentes

ATBench y TRAJECT-Bench representan la nueva ola de benchmarks que evalúan toda la trayectoria del agente, no solo input/output. Detectan safety issues durante la ejecución (usar tools peligrosos, exfiltrar datos en pasos intermedios) que un benchmark de final-answer pierde.

Si tu carga de producción tiene agentes haciendo varios tool calls, moviéndose a benchmarks trajectory-level durante 2026 es la dirección que el campo señala.

Pairwise vs absolute revisited

Hay debate activo. El argumento contra pairwise: no escala bien. Para evaluar N respuestas, pairwise requiere O(N²) comparaciones (todos contra todos) o N log N con torneo, ambos caros. Scoring absoluto es O(N).

La síntesis emergente: pairwise para gold-set y regresión (necesitas la mayor calidad), absolute con G-Eval para producción (escala mejor, asumiendo calibración adecuada). La elección no es ideológica; depende de la fase del pipeline.

Self-consistency y ensemble de judges

Para casos críticos: ejecutar el judge varias veces con temperature > 0 y agregar. Si los N judges coinciden, alta confianza; si discrepan, marca el caso para human review. Mejora robustez a costa de coste.

Variante más avanzada: jury of judges — tres judges distintos (GPT-4, Claude, un open-source) sobre la misma respuesta, agregación por mayoría. Estado del arte en agreement con humanos pero 3x más caro.

Trampas operativas

Golden dataset que envejece

Un golden set sin mantener empieza a divergir de la realidad: nuevos casos de uso aparecen, nuevos failure modes no están representados. Revisa y enriquece el golden cada quincena o mes, idealmente añadiendo los casos donde producción falló.

Judge contaminado

El judge sabe demasiado sobre el dataset (apareció en su entrenamiento). Las notas son artificialmente buenas. Especialmente serio si usas datasets públicos como golden. Mitigación: datasets privados curados internamente, rotación de modelos judge.

Sample size insuficiente

Con 10 ejemplos en el dataset, una métrica que baja de 0.85 a 0.75 puede ser ruido puro. Mínimo 50, ideal 200-500 para que las diferencias sean significativas. Reporta intervalos de confianza, no solo medias.

Costes que se descontrolan

Ejecutar G-Eval con GPT-4 sobre 5 000 respuestas/día son decenas de miles de tokens/día solo de evaluación que se pagan extra. Para escalas medianas, considera judge open-source (Prometheus) o sampling (5-10% del tráfico evaluado, no todo).

Olvidar el segmento

Una métrica media de 0.85 puede esconder que para el segmento “preguntas en alemán” es 0.55 y para “preguntas técnicas largas” es 0.65. Reporta siempre por segmento (idioma, dominio, tenant, tipo de pregunta). El “todo está bien” es sospechoso.

No actualizar la calibración

Los judges drift. Lo que medía 88% de agreement humano hace 3 meses puede haber bajado a 76% sin que nadie se entere. Recalibra cada 60-90 días contra el golden set humano.

Confiar en un eval para reemplazar humanos

Los evals automatizados son complemento del juicio humano, no sustituto total. Para casos de alto stake (legal, médico, financiero) o nuevos releases mayores, muestreo humano sigue siendo necesario. La proporción razonable: 95% automatizado, 5% humano en muestreo estratificado.

Lo que no hemos cubierto (próximos posts)

Guardrails y safety: el siguiente post de la serie. Cómo prevenir que prompts malos lleguen al modelo, en lugar de evaluar respuestas a posteriori.
MCP observability profunda: cómo OpenTelemetry GenAI se extiende a MCP servers para que las tools también sean trace-aware.
eBPF + on-device inference + drift detection: el cierre.

Referencias

Frameworks y plataformas:

DeepEval — Apache 2.0, pytest-style.
Promptfoo — MIT, CLI + YAML, red teaming.
Ragas — Apache 2.0, RAG-specific.
OpenAI Evals — MIT, clásico.
Inspect AI — UK AI Safety Institute.
Langfuse — MIT, self-host, suite completa.
LangSmith — LangChain team.
Arize Phoenix — ELv2, OTel-native.
Braintrust — comercial + OSS lite.

Métodos y papers:

G-Eval (Liu et al., 2023) — el patrón de prompting dominante.
Prometheus (KAIST + LG AI) — judge open-source con 0.897 correlación.
Tau-bench (Sierra, 2024) — tool-agent-user benchmark con pass^k.
ATBench (2026) — trajectory safety benchmark.
TRAJECT-Bench (2026) — trajectory-aware agentic tool use.
Survey on Evaluation of LLM-based Agents — el survey de referencia.

Comparativas 2026:

Cross-references:

Serie eBPF: eBPF de cero a Cilium, Tetragon, Hubble, AgentSight y tracing LLM.
Serie de inferencia: KV cache, vLLM en K8s, PagedAttention, Operators LLM K8s.

Deepeval on lo0 — Blog Técnico