Potato frente a LangSmith y Langfuse para la evaluación de agentes: una comparación práctica

LangSmith y Langfuse están hechos para trazar y monitorizar aplicaciones con LLM en producción. Potato está hecho para recoger juicios humanos estructurados sobre lo que muestran esas trazas y para medir cuánto coinciden quienes juzgan. Los equipos que necesitan ambas cosas suelen capturar en una herramienta de observabilidad y llevar el estudio humano a Potato.

Las tres herramientas se solapan lo bastante como para que la comparación salga a menudo, y se solapan en un único punto. Las tres pueden adjuntar un juicio humano a una ejecución registrada de un agente. Aquello en torno a lo que se organizan es distinto, y esa diferencia decide cuál encaja con la pregunta que te estás haciendo.

Para qué está hecha cada herramienta

LangSmith instrumenta, traza y depura aplicaciones con LLM, con la integración más profunda en LangChain y LangGraph. Las trazas de una aplicación construida sobre esos frameworks llegan sin instrumentación adicional, y la plataforma se organiza en torno a inspeccionar ejecuciones, seguir la latencia y el coste y lanzar experimentos de evaluación sobre conjuntos de datos. Sus colas de anotación admiten claves de feedback con rúbrica, un número configurable de revisores por ejecución, colas por pares y revisores que no pueden ver el feedback de los demás.

Langfuse cubre el mismo terreno como código abierto, para cualquier aplicación con LLM en lugar de un solo framework, e incluye la gestión de prompts junto con el trazado. La puntuación está disponible a nivel de traza y a nivel de observación (span), y sus score configs categóricos permiten definir un conjunto fijo de etiquetas y adjuntar varias puntuaciones con nombre a un mismo span.

Potato es una plataforma de anotación que se amplió a las trazas de agentes. Se organiza en torno al estudio y no a la aplicación, así que sus primitivas son quién anota qué, cuántas personas ven cada ítem, qué pasa cuando no coinciden y qué dicen las estadísticas de acuerdo sobre si las etiquetas significan algo. Las trazas de agentes son un tipo de ítem más entre los 61 tipos de anotación que registra la versión actual, y por eso heredan el acuerdo entre anotadores, las fases de entrenamiento, la adjudicación y el crowdsourcing sin que nada de eso se haya reconstruido para los agentes.

Ninguna de las tres es mejor en abstracto. La pregunta útil es si tu cuello de botella está en ver lo que hizo el agente o en poder fiarte de las etiquetas humanas que estás recogiendo sobre ello.

Mover trazas entre ellas

Potato lee las trazas a posteriori en lugar de instrumentar tu código, así que registra conversores para 15 formatos de traza:

python -m potato.trace_converter --list-formats

La lista incluye react, openai, anthropic, langchain, langfuse, multi_agent, mcp, otel, atif, webarena, web_agent, swebench, swe_agent_trajectory, claude_code y aider. Las exportaciones de ejecuciones de LangSmith pasan por el conversor langchain, porque no existe uno langsmith aparte. Los registros de CrewAI, AutoGen y LangGraph pasan por multi_agent.

Convertir una exportación es un solo comando en cada dirección del flujo de trabajo:

# LangSmith runs, exported from LangSmith, converted for annotation
python -m potato.trace_converter \
  --input langsmith_export.jsonl \
  --output data/traces.jsonl \
  --input-format langchain
 
# Langfuse traces, exported from Langfuse
python -m potato.trace_converter \
  --input langfuse_traces.json \
  --output data/traces.jsonl \
  --input-format langfuse

Si tu framework no está en la lista, --auto-detect elige un conversor a partir de las firmas de los campos, y uno nuevo es una subclase de BaseTraceConverter. La detección toma el primer conversor que coincide, así que indica el formato de forma explícita cuando sepas cuál encaja con tus archivos.

Las trazas también pueden llegar sin paso de exportación. La ingesta de trazas de Potato acepta ejecuciones enviadas a /api/traces/* en el formato de payload de ejecuciones de LangSmith, así que un callback de LangChain o el SDK de trazado pueden enviar ejecuciones a la cola de anotación a medida que ocurren:

trace_ingestion:
  enabled: true
  api_key: "your-api-key"
  notify_annotators: true

Lo que Potato añade una vez dentro la traza

Los esquemas son donde una plataforma de anotación se gana su sitio. trajectory_eval lleva la etiqueta de corrección, una taxonomía jerárquica de errores con subtipos, niveles de gravedad con pesos configurables y una puntuación de calidad acumulada, en un solo esquema adjunto a una sola traza:

annotation_schemes:
  - annotation_type: trajectory_eval
    name: step_evaluation
    description: "Mark each step and classify anything that went wrong"
    steps_key: conversation
    step_text_key: text
    error_types:
      - name: execution
        subtypes: [wrong_tool, wrong_args, api_error]
    severities:
      - name: minor
        weight: -1
      - name: critical
        weight: -10
    show_score: true

Los pesos de gravedad son la parte que importa para comparar trazas. Un recuento plano de pasos marcados dice que un agente cometió cuatro errores y otro dos, y la puntuación ponderada dice si esos cuatro eran cosméticos y los dos, peligrosos.

La evaluación comparativa se hace con el esquema pairwise, que tiene tres modos. El modo binario muestra dos recuadros clicables con un botón de empate opcional, el modo de escala sustituye la elección por un deslizador entre los dos ítems y el modo multi_dimension pide un veredicto A/B independiente por cada dimensión con nombre, como utilidad, exactitud y seguridad.

Los agentes de programación tienen su propia visualización, porque un diff unificado leído como cadena JSON no se puede revisar:

La visualización de trazas de programación de Potato con renderizado de diff unificado, resaltado de sintaxis y árbol de archivos

La visualización coding_trace renderiza los diffs con un árbol de archivos y pliega la salida larga del terminal, y el esquema code_review recoge comentarios anclados a líneas en categorías configurables, dimensiones de valoración por archivo y un veredicto al estilo de una pull request. El exportador coding_eval escribe después etiquetas para modelos de recompensa de proceso, anotaciones de revisión de código, pares de preferencia para DPO y puntuaciones compatibles con SWE-bench, que es la forma que necesitan los datos de entrenamiento y no la que necesita un panel de control.

Las trazas de agentes web se renderizan como capturas de pantalla con superposiciones SVG de las acciones y una tira de fotogramas:

Visor de trazas de agentes web con capturas de pantalla, superposiciones SVG de las acciones y navegación por tira de fotogramas

Las ejecuciones multiagente tienen sus propias superficies de anotación en lugar de aplanarse en una sola secuencia de pasos. El registro incluye esquemas para un grafo de interacción que el anotador puede editar, atribución de fallos entre agentes, revisión de traspasos, tarjetas de puntuación por agente y por equipo, contención de herramientas sobre una línea de tiempo compartida y etiquetado de comportamiento emergente. Lo mismo vale para los agentes corporizados y multimodales, con trayectorias de uso del ordenador, interacción de voz full-duplex y anclaje temporal en vídeo como esquemas de primer nivel.

Medir los juicios, no solo recogerlos

La diferencia que aparece más tarde en un proyecto es lo que pasa cuando dos anotadores no coinciden. Potato trata un desacuerdo como una medición y no como un conflicto que resolver, así que las mismas estadísticas de acuerdo, cola de adjudicación, fases de entrenamiento e ítems de referencia que usa un estudio de anotación de texto se aplican a las trazas de agentes sin configuración adicional. La comparación de herramientas del propio Potato recoge, según la revisión del 2026-06-24, que las plataformas de trazado están hechas para recoger juicios humanos como puntuaciones y que ninguna documenta una estadística de fiabilidad sobre esos juicios, y que Langfuse sustituye una anotación previa sobre la misma traza, de modo que allí la doble anotación independiente requiere un apaño.

Eso importa cuando la evaluación es la evidencia. Una tasa de éxito construida a partir de juicios únicos sin revisar no tiene barra de error, y un revisor que se ha desviado se parece exactamente a un agente que ha mejorado.

Observar a un agente mientras se ejecuta

Potato también puede ejecutar un agente dentro de la página de anotación en lugar de reproducir una grabación. El bloque live_agent conecta un modelo de visión a un navegador headless y transmite la sesión al anotador, que puede pausarla, enviar instrucciones o tomar el control manual:

live_agent:
  endpoint_type: anthropic_vision
  ai_config:
    model: claude-sonnet-4-20250514
    api_key: ${ANTHROPIC_API_KEY}
  max_steps: 30
  allow_takeover: true
  allow_instructions: true
 
instance_display:
  fields:
    - key: agent_trace
      type: live_agent
      label: "Live Agent Session"
      display_options:
        show_overlays: true
        show_filmstrip: true

Tres situaciones hacen que esto compense el montaje frente a la revisión a posteriori. Detener una ejecución antes de una acción destructiva es una medida de seguridad que las trazas grabadas no pueden ofrecer. Una toma de control humana registrada a mitad de ejecución se convierte en datos de demostración. Y ver cómo se recupera un agente de una intervención responde a una pregunta que ninguna traza completada contiene.

Usarlas juntas

La configuración habitual en producción usa ambas, y el reparto es limpio porque las herramientas quieren cosas distintas. Instrumenta el agente con LangSmith o Langfuse y deja que se trace cada ejecución. Toma una muestra de las ejecuciones que merecen una opinión humana, que suelen ser los fallos, los casos límite y una muestra de control aleatoria. Conviértelas a Potato, ejecuta el estudio de anotación con varios anotadores por traza y lee el informe de acuerdo junto a las puntuaciones. Devuelve los recuentos de la taxonomía de errores al desarrollo, donde la distribución de subtipos dice si tienes un fallo sistemático o una cola larga.

python -m potato.trace_converter \
  --input langfuse_failed_traces.json \
  --output data/traces_to_review.jsonl \
  --input-format langfuse
 
potato start config.yaml -p 8000

Elegir

Recurre a LangSmith cuando la aplicación está construida sobre LangChain o LangGraph y lo que necesitas es visibilidad en producción, ya que las trazas llegan sin trabajo de instrumentación y el servicio gestionado elimina la cuestión de la infraestructura. Recurre a Langfuse cuando quieras esa misma visibilidad como código abierto con varios proveedores, con versionado de prompts en la misma herramienta. Recurre a Potato cuando el resultado que necesitas es un conjunto defendible de etiquetas humanas, cuando el estudio necesita varios anotadores por ítem y una cifra de acuerdo, cuando los agentes son de programación, multiagente o corporizados hasta el punto de que la traza necesita una visualización hecha a propósito, o cuando los datos tienen que quedarse en tu propia infraestructura. Potato es GPL-3.0-or-later y autoalojado, sin coste por puesto ni por traza.

Lo que aquí se dice sobre LangSmith y Langfuse refleja su documentación tal como se consultó el 2026-06-24, y ambas herramientas publican cambios deprisa. Las correcciones son bienvenidas en el repositorio de GitHub. Para la configuración en sí, consulta la guía de evaluación de agentes, y para un ejemplo completo desde las trazas en bruto hasta los juicios exportados, consulta Evaluar agentes de IA.