Agno Evals vs LangWatch Scenario: ¿métricas nativas de agentes o pruebas de agentes basadas en simulación?

Al April 28, 2026, la documentación oficial de Agno describe Evals como una forma nativa de medir la calidad de los Agents y Teams de Agno en cuatro dimensiones: precisión, agent-as-judge, rendimiento y confiabilidad. La documentación oficial de LangWatch Scenario describe Scenario como un framework de pruebas de agentes basado en simulación que prueba el comportamiento real de los agentes mediante usuarios simulados, jueces, scripts y conversaciones de múltiples turnos.

Esa diferencia importa. Estas herramientas no son duplicados. Responden a distintas preguntas sobre calidad.

Agno Evals pregunta: ¿este Agent o Team de Agno produjo el resultado esperado, cumplió una rúbrica, mantuvo un buen rendimiento o llamó a las herramientas esperadas?

LangWatch Scenario pregunta: ¿puede este agente desenvolverse en una situación realista durante múltiples turnos, con un usuario que podría aclarar algo, cambiar de dirección, proporcionar información faltante o sacar a la luz un caso límite?

La mejor respuesta para producción no suele ser «elige uno». Es:

Use Agno Evals to measure agent components and framework-local behavior.
Use LangWatch Scenario to rehearse end-to-end user journeys before release.
Promote failures from either layer into repeatable tests.

TL;DR

• Agno Evals es ahora una funcionalidad nativa de Agno para evaluar Agents y Teams en producción.
• Las dimensiones de eval documentadas por Agno son precisión, agent-as-judge, rendimiento y confiabilidad.
• LangWatch Scenario pone la simulación en primer plano. Prueba el comportamiento completo del agente con un agente bajo prueba, un simulador de usuario y un juez.
• Agno Evals destaca cuando se busca evaluar una entrada y salida conocidas, una rúbrica, una llamada esperada a una herramienta, un perfil de latencia, el uso de memoria o el comportamiento de un Team.
• LangWatch Scenario destaca cuando se busca evaluar un recorrido de usuario, el manejo de ambigüedades, un flujo de aclaración, la recuperación ante fallas de herramientas o regresiones en conversaciones de múltiples turnos.
• El modelo mental más claro: Agno Evals son sondas de medición; las pruebas de Scenario son ensayos de comportamiento.

La evidencia en la documentación

Estas son las fuentes que usé para esta comparación:

Mi interpretación: Agno ha acercado la evaluación al propio runtime del agente. LangWatch Scenario ha acercado las pruebas al comportamiento real de los usuarios. Es una distinción útil.

Para qué está optimizado Agno Evals

Agno Evals vive en el mismo entorno que el Agent o Team de Agno. Los ejemplos usan clases de Agno como AccuracyEval, AgentAsJudgeEval, PerformanceEval y ReliabilityEval, y el objeto evaluado puede ser un Agent, un Team o la salida capturada de una ejecución.

Esto lo hace una opción natural para las verificaciones de calidad dentro del framework:

Lo importante es que Agno Evals está cerca de la implementación del agente. Puedes evaluar el objeto exacto que estás construyendo.

Un patrón mínimo de eval de Agno

La documentación actual de Agno muestra evals de precisión con un modelo, un agente, una entrada, una salida esperada y pautas opcionales. En la práctica, el patrón se ve así:

from agno.agent import Agent
from agno.eval.accuracy import AccuracyEval
from agno.models.openai import OpenAIResponses
from agno.tools.calculator import CalculatorTools

agent = Agent(
    model=OpenAIResponses(id="gpt-5.2"),
    tools=[CalculatorTools()],
)

evaluation = AccuracyEval(
    name="Calculator Evaluation",
    model=OpenAIResponses(id="gpt-5.2"),
    agent=agent,
    input="What is 10*5 then to the power of 2?",
    expected_output="2500",
    additional_guidelines="The answer should include the final result.",
    num_iterations=3,
)

result = evaluation.run(print_results=True)
assert result is not None and result.avg_score >= 8

Es una buena opción cuando ya conoces la pregunta y la respuesta esperada.

Dónde destaca Agno Evals

Agno Evals es especialmente útil para:

• evaluar tareas de un solo turno o de alcance acotado
• comparar modelos dentro de un Agent de Agno
• comprobar la calidad de las salidas estructuradas
• validar que se llamaron las herramientas esperadas
• medir la latencia y la memoria después de cambios en el prompt o las herramientas
• almacenar ejecuciones de evals en el mismo sistema de producción respaldado por una base de datos
• exponer el historial de evaluaciones mediante AgentOS

Si estoy construyendo un enrutador de soporte en Agno, quiero evals nativas para aspectos como:

• precisión de la clasificación de intenciones
• corrección de las decisiones de escalamiento
• comprobaciones de las llamadas esperadas a herramientas
• evaluación de respuestas mediante una rúbrica
• comportamiento de enrutamiento del Team
• regresiones respecto al presupuesto de latencia

Son sondas específicas. Me indican si un componente conocido se comporta bien ante exigencias conocidas.

Para qué está optimizado LangWatch Scenario

LangWatch Scenario se sitúa un nivel más arriba. No pregunta solamente «¿fue correcta esta respuesta?». Pregunta si el agente completo puede manejar una situación.

La documentación describe una estructura de prueba con:

• un AgentAdapter que conecta tu agente real
• un UserSimulatorAgent que interpreta el papel del usuario
• un JudgeAgent que evalúa la conversación según ciertos criterios
• un script opcional que controla la secuencia de turnos
• set_id e identificadores de lote para agrupar resultados
• modos de caché y depuración para facilitar la repetición de pruebas no deterministas
• visualización de las ejecuciones de simulación en LangWatch

Esta estructura se parece mucho más a una prueba end-to-end que a una tarjeta de puntuación.

Un patrón mínimo de Scenario

La documentación de primeros pasos de Scenario muestra un patrón como este:

import pytest
import scenario

scenario.configure(default_model="openai/gpt-4.1-mini")

@pytest.mark.agent_test
@pytest.mark.asyncio
async def test_billing_dispute_flow():
    class SupportAgent(scenario.AgentAdapter):
        async def call(self, input: scenario.AgentInput) -> scenario.AgentReturnTypes:
            return support_agent.run(
                input.last_new_user_message_str(),
                session_id=input.thread_id,
            ).content

    result = await scenario.run(
        name="billing dispute needs account lookup",
        description="""
            User believes they were charged twice.
            They are frustrated but cooperative.
            They want a refund or a clear explanation.
        """,
        agents=[
            SupportAgent(),
            scenario.UserSimulatorAgent(),
            scenario.JudgeAgent(criteria=[
                "Agent asks for enough account information before taking action",
                "Agent explains billing policy clearly",
                "Agent does not promise a refund before verification",
                "Agent escalates if the case cannot be resolved safely",
            ]),
        ],
        max_turns=8,
    )

    assert result.success

Esta prueba puede fallar incluso cuando la respuesta final parece buena. Por ejemplo, puede detectar que el agente prometió un reembolso demasiado pronto, omitió la verificación o siguió haciendo preguntas redundantes.

Dónde destaca Scenario

Scenario es especialmente sólido para:

• el comportamiento de agentes durante múltiples turnos
• solicitudes ambiguas de usuarios
• flujos de aclaración y confirmación
• casos límite realistas
• recuperación después de una corrección del usuario
• funcionamiento degradado y configuración faltante
• comprobaciones end-to-end de capacidades de negocio
• pruebas de seguridad y de comportamiento adversarial
• pruebas de CI que expresan recorridos de usuario en lugar de cadenas esperadas

Si Agno Evals se acerca más a «mide esta respuesta», Scenario se acerca más a «representa este caso de uso y observa si el agente puede completar la tarea».

Comparación directa

En resumen:

Agno Evals are better for measuring known properties.
Scenario is better for discovering behavioral failures.

La perspectiva de la pirámide de pruebas

La documentación de Scenario de LangWatch describe una pirámide de pruebas de agentes con tres capas:

1. Pruebas unitarias para las partes deterministas del software.
2. Evals y optimización para los componentes probabilísticos.
3. Simulaciones para el comportamiento completo del agente.

Agno Evals encaja principalmente en la capa intermedia. Mide componentes probabilísticos y salidas de agentes. Las evals de confiabilidad de Agno también rozan el límite entre las comprobaciones unitarias o de integración y las de comportamiento, porque las llamadas esperadas a herramientas son concretas.

Scenario encaja en la capa superior. Valida si el sistema integrado funciona desde el punto de vista del usuario.

Esto nos da una arquitectura práctica:

                 AGENT QUALITY STACK

  Unit tests
  - tool functions
  - database queries
  - policy parsers
  - schema validation

  Agno Evals
  - answer accuracy
  - rubric scoring
  - expected tool calls
  - Agent and Team performance

  LangWatch Scenario
  - multi-turn user journeys
  - ambiguous requests
  - edge cases
  - release-blocking behavior tests

  Production monitoring
  - traces
  - online evals
  - alerts
  - failed traces promoted into new tests

Ninguna capa hace todo el trabajo por sí sola. Eso no es una debilidad. Así es una estrategia de pruebas madura.

Un ejemplo real: agente de soporte para reembolsos

Imagina un agente de Agno que gestiona solicitudes de reembolso. Tiene herramientas para:

• buscar un pedido
• comprobar si un pedido cumple los requisitos para un reembolso
• abrir un ticket
• escalar a una persona
• enviar una respuesta al cliente

El requisito de producto es:

The agent should help eligible customers get refunds,
but it must not promise money back before checking policy,
and it must escalate unclear or high-risk cases.

Qué probaría con Agno Evals

Usa Agno Accuracy Evals para casos conocidos:

Usa Agent-as-Judge Evals para evaluar la calidad de las respuestas:

• explicación clara
• ninguna promesa sin fundamento
• tono amable
• lenguaje basado en la política
• ninguna condición de reembolso inventada

Usa Reliability Evals para las herramientas esperadas:

Usa Performance Evals para reducir el riesgo en las versiones:

• tiempo de respuesta p95
• impacto en la memoria
• comparación de modelos o prompts
• sobrecarga de enrutamiento del Team

Son mediciones específicas. Son compactas, repetibles y están cerca de la implementación de Agno.

Qué probaría con Scenario

Usa Scenario para recorridos completos:

Son ensayos de comportamiento. Te indican si el agente realmente puede llevar adelante la conversación.

Cómo combinarlos en CI

Un flujo de trabajo práctico se ve así:

Pull request opens
    |
    v
Run unit tests
    |
    v
Run fast Agno Evals
  - accuracy smoke set
  - key reliability checks
  - one performance guardrail
    |
    v
Run Scenario smoke simulations
  - top happy path
  - top ambiguity path
  - top safety boundary path
    |
    v
Block merge only on high-signal failures

Para ejecuciones nocturnas o previas a una versión:

Nightly job
    |
    v
Run full Agno eval suite
    |
    v
Run broader Scenario pack
    |
    v
Export failed traces and failed conversations
    |
    v
Promote new cases into eval datasets or scenario tests

La clave es mantener rápidas las comprobaciones de pull requests. Ejecuta las pruebas suficientes para detectar regresiones evidentes y deja que los paquetes de simulación más exigentes se ejecuten según un calendario.

Guía de decisión

Usa Agno Evals cuando:

• ya estás desarrollando en Agno
• el comportamiento puede expresarse como una entrada y una salida esperada
• necesitas comparar modelos, prompts o herramientas dentro del runtime de Agno
• necesitas comprobar la confiabilidad de las llamadas a herramientas
• necesitas medir el rendimiento y la memoria
• quieres que las ejecuciones de evals se almacenen en la infraestructura de base de datos de Agno o se muestren mediante AgentOS

Usa LangWatch Scenario cuando:

• la falla ocurre a lo largo de múltiples turnos
• el recorrido del usuario importa más que una sola respuesta
• el agente debe hacer preguntas de aclaración
• el agente debe recuperarse de una confusión, una falla de herramienta o una corrección del usuario
• las partes interesadas del producto necesitan ver «¿puede hacer el trabajo?»
• quieres pruebas de CI que se lean como escenarios de negocio
• necesitas resultados de simulación en LangWatch para revisión y depuración

Usa ambos cuando:

• el agente interviene en dinero, soporte, operaciones, asuntos legales, atención médica, seguridad, despliegue o confianza del cliente
• los cambios de prompts son frecuentes
• las actualizaciones de modelos son frecuentes
• necesitas tanto puntuaciones como evidencia del comportamiento
• quieres convertir las fallas en pruebas de regresión permanentes

Errores comunes

Error 1: tratar las evals como pruebas end-to-end

Una eval puede indicar que una respuesta es precisa. No demuestra automáticamente que el agente pueda manejar una conversación complicada.

Por ejemplo, una eval de Agno podría confirmar que el agente responde correctamente «los reembolsos están disponibles dentro de 30 días». Scenario podría revelar que el agente falla cuando el usuario dice: «Lo compré hace un tiempo, creo que quizá el mes pasado, pero desde entonces cambié de tarjeta».

No son la misma prueba.

Error 2: tratar Scenario como un sistema de métricas

Scenario puede producir resultados de aprobación o falla y el razonamiento del juez, pero no es principalmente un benchmark de latencia ni un harness de optimización de componentes.

Si quieres comparar el modelo A con el modelo B en 200 casos de clasificación, las evals nativas suelen ser un punto de partida más claro.

Error 3: probar solo los caminos felices

El primer paquete de Scenario debería incluir al menos:

• un camino de finalización normal
• un camino con ambigüedad
• un camino que ponga a prueba un límite de seguridad
• un camino con una falla de herramienta o datos faltantes
• un camino con una corrección del usuario

La primera suite de evals de Agno debería incluir al menos:

• salidas esperadas que se sabe que son correctas
• casos límite que se sabe que son problemáticos
• comprobaciones de las llamadas esperadas a herramientas
• una rúbrica para respuestas de formato libre
• un presupuesto de rendimiento sencillo

Error 4: dejar que los casos fallidos desaparezcan

Cuando una eval de Agno falle, convierte la entrada en un caso de prueba permanente.

Cuando una prueba de Scenario falle, conserva el patrón de la conversación. ¿Fue ambiguo el usuario? ¿Omitió el agente la verificación? ¿Perdió el contexto después de una llamada a una herramienta? Ese patrón es lo verdaderamente valioso.

La recomendación práctica

Para un agente de Agno en producción, empezaría así:

1. Escribe pruebas unitarias para herramientas deterministas y transformaciones de datos.
2. Agrega Agno Accuracy Evals para entre 10 y 20 casos de referencia.
3. Agrega Agno Reliability Evals para las principales llamadas esperadas a herramientas.
4. Agrega una Agent-as-Judge Eval para evaluar la calidad de las respuestas.
5. Agrega una Performance Eval pequeña para que las regresiones de latencia sean visibles.
6. Agrega 3 a 5 pruebas de LangWatch Scenario para los recorridos de usuario de mayor valor.
7. Ejecuta el conjunto pequeño en CI y el conjunto más amplio cada noche.
8. Convierte las fallas de producción en casos de eval de Agno o simulaciones de Scenario, según sus características.

La regla para decidir dónde colocar cada prueba es sencilla:

If the failure is about a measurable response property, put it in Agno Evals.
If the failure is about a conversation path, put it in Scenario.

Conclusión

Agno Evals y LangWatch Scenario son herramientas complementarias dentro de un mismo sistema de calidad.

Agno Evals te da mediciones nativas del framework: precisión, calidad según una rúbrica, rendimiento, confiabilidad, comportamiento de Agents, comportamiento de Teams y visibilidad en AgentOS. Son las sondas que conectas a la máquina.

LangWatch Scenario te ofrece pruebas de comportamiento basadas en simulación: usuarios realistas, jueces, scripts, flujos de múltiples turnos y adaptadores para frameworks de agentes. Es el ensayo antes de que la máquina se encuentre con el público.

Si estás poniendo en producción agentes que importan, necesitas ambos:

Agno Evals for measurable quality.
LangWatch Scenario for lived behavior.
Production traces to keep both honest.

Esa es la diferencia entre preguntar «¿respondió el modelo a este ejemplo?» y preguntar «¿puede el agente realmente hacer el trabajo?».