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

Tres herramientas, tres filosofías

Potato, LangSmith y Langfuse tocan todas la evaluación de agentes, pero llegan a ella desde puntos de partida distintos:

• Potato parte de la anotación. Se construyó para recoger juicios humanos estructurados sobre salidas de IA y luego se amplió para admitir trazas de agente, diffs de código y observación en vivo. Su punto fuerte es la profundidad y la configurabilidad de sus esquemas de anotación.
• LangSmith parte de la observabilidad. Se construyó para instrumentar, trazar y depurar aplicaciones de LangChain en producción. Sus funciones de anotación llegaron después, para dar soporte a los flujos de evaluación dentro del ecosistema de LangChain.
• Langfuse es observabilidad de código abierto. Cubre trazado, gestión de prompts y evaluación para cualquier aplicación con LLM. Sus funciones de anotación funcionan, pero son secundarias frente a la monitorización.

Ninguna es mejor en términos absolutos. La elección correcta depende de si lo que necesitas sobre todo es anotación, observabilidad o ambas, y de si estás comprometido con el ecosistema de un framework concreto.

Comparación de funcionalidades

La tabla siguiente compara capacidades relevantes para la evaluación de agentes de IA. Incluimos también Label Studio, Argilla y Scale AI, porque los equipos suelen sopesar esas opciones.

¹ Los «Agent Graphs» de Langfuse (beta) representan una ejecución multiagente como un grafo, pero como vista de depuración de solo lectura: no hay una forma documentada de que un anotador marque el camino crítico o señale aristas sobre él. ² Scale AI anota trayectorias de GUI y de uso del ordenador como un encargo gestionado de datos (por ejemplo, su trabajo con CUA-Suite en CVAT), no como una funcionalidad autoservicio que puedas configurar. ³ El «Voice Showdown» de Scale funciona por turnos; la puntuación full-duplex de interrupciones y solapamientos figura como prevista, todavía no disponible (a fecha de 2026-03-20).

Comparación observada el 2026-06-24 frente a LangSmith (docs.langchain.com), Langfuse (núcleo MIT, publicación continua), Label Studio 1.23.0, Argilla 2.8.0 y las páginas de producto de Scale AI. Estas herramientas se mueven rápido: si algo aquí ha quedado desactualizado, se agradecen correcciones en el repositorio de GitHub.

Entre estas herramientas, Potato es la única que renderiza trazas de agentes de coding con formato de diff en condiciones:

El CodingTraceDisplay de Potato con renderizado de diff unificado, resaltado de sintaxis y árbol de archivos

Soporte de formatos de traza en detalle

Una de las mayores diferencias prácticas está en cuántos formatos de traza de agente admite cada herramienta de forma nativa.

Potato incluye conversores para 15 formatos:

# See all available converters
python -m potato.trace_converter --list-formats
 
# Available formats:
#   react                 - ReAct-style (Thought/Action/Observation)
#   openai                - OpenAI Chat Completions and Assistants API
#   anthropic             - Anthropic Messages API with tool_use
#   langchain             - LangChain / LangSmith run trace exports
#   langfuse              - Langfuse observation and trace exports
#   multi_agent           - CrewAI, AutoGen, and LangGraph multi-agent logs
#   swebench              - SWE-bench benchmark traces
#   swe_agent_trajectory  - SWE-Agent trajectory files
#   claude_code           - Claude Code and coding-agent session logs
#   aider                 - Aider chat histories with edit blocks
#   webarena              - WebArena / VisualWebArena episode traces
#   web_agent             - Mind2Web, Computer Use, and raw browser recordings
#   mcp                   - Model Context Protocol interaction logs
#   otel                  - OpenTelemetry / OTLP trace exports
#   atif                  - Agent Trace Interchange Format

No hay un conversor langsmith aparte: las exportaciones de LangSmith pasan por langchain, y AutoGen y CrewAI pasan por multi_agent. Si tu framework no está en la lista, --auto-detect intentará elegir un conversor a partir de las firmas de los campos, y puedes escribir el tuyo heredando de BaseTraceConverter.

LangSmith funciona de forma nativa con trazas de LangChain. Si tu agente está hecho con LangChain o LangGraph, las trazas entran automáticamente. Si no, tienes que instrumentar tu código a mano con el SDK de LangSmith o convertir tus trazas al formato de LangSmith.

Langfuse funciona de forma nativa con trazas instrumentadas mediante el SDK de Langfuse. Admite Python y JavaScript, y tiene integraciones con LangChain, LlamaIndex y OpenAI. Igual que LangSmith, exige instrumentación a nivel de código en lugar de conversión de trazas a posteriori.

Importar trazas de LangSmith o Langfuse a Potato

Si ya tienes trazas en LangSmith o Langfuse y quieres usar las funciones de anotación de Potato, los conversores se encargan:

# Export from LangSmith and convert
python -m potato.trace_converter \
  --input langsmith_export.jsonl \
  --output data/traces.jsonl \
  --input-format langchain
 
# Export from Langfuse and convert
python -m potato.trace_converter \
  --input langfuse_traces.json \
  --output data/traces.jsonl \
  --input-format langfuse

Así puedes quedarte con LangSmith o Langfuse para la monitorización en producción y llevar las trazas a Potato cuando quieras una evaluación humana detallada.

Anotación por paso: donde la distancia es mayor

La diferencia de capacidad más importante está en la profundidad de la anotación por paso.

Potato ofrece el esquema trajectory_eval con:

• Etiquetas de corrección por paso (correcto/incorrecto)
• Selección sobre una taxonomía jerárquica de errores
• Niveles de gravedad con pesos configurables
• Marcador acumulado que se actualiza en cada paso
• Justificación en texto libre por paso
• Todo ello configurable desde YAML

# Potato: rich per-step annotation
annotation_schemes:
  - annotation_type: "trajectory_eval"

LangSmith permite adjuntar una puntuación numérica o una etiqueta categórica a ejecuciones concretas dentro de una traza. Sirve para un seguimiento básico de la calidad, pero no admite taxonomías de errores, ponderación por gravedad ni marcadores acumulados. No hay una interfaz de revisión por paso integrada; puntúas las ejecuciones desde la vista de detalle de la traza.

Langfuse admite puntuar a nivel de traza y a nivel de observación (span), y sus score configs categóricos permiten definir un conjunto fijo de etiquetas —una taxonomía de errores utilizable— y adjuntar varias puntuaciones con nombre al mismo span. Lo que no ofrece como esquema de primer nivel es una taxonomía jerárquica ni un marcador acumulado ponderado por gravedad que se vaya sumando a lo largo de los pasos; eso te lo montas tú a partir de score configs planos.

Así que la versión honesta de la distancia es más corta de lo que era: tanto Langfuse como Label Studio (que ahora importa trazas de LangGraph/CrewAI/AutoGen para revisión por paso) hacen puntuación estructurada por paso. Donde Potato sigue siendo específico es en la combinación: una taxonomía jerárquica de errores más pesos de gravedad más un marcador acumulado en un solo esquema trajectory_eval, que es lo que quieres para construir datos de entrenamiento de PRM o para localizar dónde se tuerce un agente por primera vez.

Soporte para agentes de coding

Evaluar agentes de coding (Claude Code, Aider, SWE-Agent, Devin, OpenHands) implica renderizar diffs de código y salida de terminal para que la revisión vaya rápida. Aquí Potato saca ventaja al resto.

Potato renderiza:

• Diffs unificados con resaltado en rojo y verde y resaltado de sintaxis
• Salida de terminal con soporte de códigos de color ANSI
• Comentarios en línea sobre el diff anclados a líneas concretas
• Valoraciones de calidad por archivo
• Veredictos de aprobación o petición de cambios al estilo de un PR

LangSmith muestra las entradas y salidas de las llamadas a herramientas como JSON formateado. Los diffs de código aparecen como cadenas de texto en bruto dentro de las salidas de herramienta. No hay renderizado de diffs, ni resaltado de sintaxis, ni comentarios en línea.

Langfuse muestra igualmente los datos de traza como JSON estructurado. El contenido de código aparece como texto plano. No hay renderizado especializado para diffs ni para salida de terminal.

Para agentes de coding, esto cambia el día a día del revisor. Revisar un diff de 50 líneas en una vista de diff unificado con resaltado de sintaxis y comentarios en línea lleva una fracción del tiempo que cuesta leer ese mismo diff como una cadena JSON.

Las trazas de agentes web incluyen capturas de pantalla con superposiciones SVG y navegación tipo tira de fotogramas:

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

Observación de agentes en vivo

Potato puede observar un agente en ejecución en tiempo real, algo que ni LangSmith ni Langfuse hacen en sus flujos de anotación.

En el modo de observación en vivo de Potato, un anotador puede ver trabajar al agente paso a paso, pausarlo para revisar su estado actual, reanudarlo después y tomar el control de la sesión para reconducirla o terminar la tarea a mano.

Esto ayuda en unas cuantas situaciones: parar a un agente antes de que haga algo destructivo (seguridad), registrar correcciones humanas como datos de demostración (entrenamiento) y ver cómo responde un agente cuando intervienes a mitad de camino (evaluación interactiva).

# Enable live observation in Potato config
live_observation:
  enabled: true
  agent_endpoint: "http://localhost:5000/agent"
  allow_pause: true
  allow_takeover: true
  auto_pause_on:
    - action_type: "delete"
    - action_type: "execute"
    - confidence_below: 0.3

LangSmith y Langfuse están pensados para el análisis a posteriori de trazas ya terminadas, no para la interacción en tiempo real con agentes en ejecución.

Comparación por pares

Comparar dos salidas de agente una junto a otra es un patrón de evaluación habitual, sobre todo para pruebas A/B de versiones de modelo o para comparar arquitecturas de agente.

Potato ofrece tres modos de comparación:

• Lado a lado: ambas trazas visibles a la vez, con desplazamiento sincronizado
• Secuencial: ves primero la traza A, después la traza B y luego juzgas
• Ciego: las trazas se etiquetan aleatoriamente como «A» y «B» sin indicar el modelo

annotation_schemes:
  - annotation_type: "pairwise"

LangSmith admite una comparación por pares básica a través de su «vista de comparación» en los experimentos de evaluación. Puedes comparar ejecuciones de distintas versiones de modelo, pero la interfaz está pensada para inspeccionar ejecuciones lado a lado, no para anotar preferencias de forma estructurada.

Langfuse no tiene una función integrada de comparación por pares para anotación.

Cuándo usar cada herramienta

Usa Potato cuando:

• La anotación es tu objetivo principal: necesitas juicios humanos estructurados, no solo monitorización
• Necesitas soporte para agentes de coding: renderizado de diffs, comentarios en línea, salida de terminal
• Estás recogiendo datos de entrenamiento para PRM: etiquetas de corrección por paso con marcadores acumulados
• Necesitas autoalojamiento: los datos se quedan en tu infraestructura, sin dependencia de la nube
• Trabajas con varios frameworks de agente: 15 conversores de formato de traza frente a la dependencia de un único framework
• Necesitas esquemas de evaluación ricos: evaluación de trayectorias, evaluación con rúbrica, revisión de código, comparación por pares
• El presupuesto es una limitación: es gratuito y de código abierto por completo

Usa LangSmith cuando:

• Ya estás usando LangChain/LangGraph: las trazas entran automáticamente sin configurar nada
• La monitorización en producción es tu necesidad principal: trazado en tiempo real, seguimiento de latencia, control de costes
• La anotación es secundaria: necesitas puntuación y comentarios básicos, no esquemas de evaluación profundos
• Quieres un servicio gestionado: sin infraestructura que mantener
• Tu equipo es pequeño: el plan gratuito puede bastar para una evaluación ligera

Usa Langfuse cuando:

• Necesitas observabilidad de código abierto: monitorización y trazado autoalojados
• Usas varios proveedores de LLM: buenas integraciones con OpenAI, Anthropic, LangChain y LlamaIndex
• La anotación no es tu caso de uso principal: la puntuación está disponible, pero no es el foco
• Quieres gestión de prompts junto al trazado: Langfuse combina el versionado de prompts con la observabilidad
• Necesitas una alternativa gratuita a LangSmith para monitorizar: el núcleo de código abierto de Langfuse cubre casi todas las necesidades de monitorización

El enfoque complementario: observabilidad + anotación

Para muchos equipos, el montaje práctico consiste en usar una herramienta de observabilidad (LangSmith o Langfuse) para la monitorización en producción y Potato para la evaluación humana detallada. El flujo queda así:

1. Instrumenta tu agente con LangSmith o Langfuse para el trazado en producción
2. Muestrea las trazas que necesiten revisión humana (fallos, casos límite, muestras aleatorias)
3. Exporta esas trazas desde tu herramienta de observabilidad
4. Conviértelas e impórtalas en Potato con los conversores incluidos
5. Lanza la evaluación humana con los esquemas de anotación de Potato
6. Devuelve los resultados a tu ciclo de desarrollo

# Example: convert failed traces exported from Langfuse and import to Potato
python -m potato.trace_converter \
  --input langfuse_failed_traces.json \
  --output data/traces_to_review.jsonl \
  --input-format langfuse

Así tienes la visibilidad en tiempo real de una plataforma de observabilidad junto con la profundidad de anotación de una herramienta hecha para anotar.

Resumen de diferencias clave

Hay dos superficies en las que la afirmación se sostiene con más fuerza. De todas las herramientas que revisamos (comerciales y de código abierto), Potato es la única que ofrece superficies configurables por el anotador para la estructura de equipos multiagente y la revisión de agentes multimodales:

• Un grafo de interacción multiagente editable por el anotador y navegable con clics: marca el camino crítico, señala el traspaso defectuoso. Lo más parecido en otras herramientas, los «Agent Graphs» de Langfuse, es una vista de depuración de solo lectura.
• Atribución de fallos entre agentes, revisión de traspasos como objeto de primer nivel, marcadores por agente y por equipo, una línea de tiempo de contención de herramientas y etiquetado de comportamiento emergente, nada de lo cual ofrecen las demás herramientas como construcciones de anotación integradas.
• Trayectorias de uso del ordenador con anclaje de clics, líneas de tiempo de voz full-duplex con puntuación de interrupciones y anclaje temporal en vídeo con IoU en vivo. Scale AI hace anclaje sobre GUI y evaluación de voz, pero como encargos gestionados de conjuntos de datos, y su arena de voz sigue siendo por turnos.

Además de eso, Potato sigue siendo la única herramienta gratuita y autoalojada que combina renderizado de diffs para agentes de coding con comentarios en línea, recogida de datos PRM, observación en vivo con pausa, reanudación y toma de control, ingesta de trazas de cualquier framework, una taxonomía jerárquica de errores con marcador acumulado ponderado por gravedad, tres modos de comparación por pares y revisión de código al estilo de un PR.

No conocemos otra herramienta, de código abierto o comercial, que reúna todo esto; comprobado frente a LangSmith, Langfuse, Labelbox, Scale AI, Label Studio, Argilla y Braintrust a fecha de 2026-06-24 (mira la nota fechada bajo la tabla comparativa). LangSmith y Langfuse son herramientas sólidas de observabilidad cuyas funciones de anotación son puntuaciones limitadas al span, no superficies sobre la estructura del agente. Label Studio y Argilla son herramientas de anotación generales; Label Studio ha añadido importación de trazas, pero ninguna ofrece las superficies multiagente o de agentes multimodales anteriores. Labelbox y Scale ofrecen productos de datos para evaluación de agentes, pero como servicios de pago, en la nube o gestionados, en lugar de una herramienta autoalojada que un equipo de investigación pueda ejecutar y personalizar.

Si tu objetivo es entender cómo y por qué tus agentes aciertan o fallan, y recoger los datos de entrenamiento para mejorarlos, Potato cubre un hueco que las demás dejan abierto.

Rutas de migración

De LangSmith a Potato (para anotación)

# 1. Export your dataset from LangSmith
langsmith export dataset my_eval_dataset -o langsmith_data.jsonl
 
# 2. Convert to Potato format
python -m potato.trace_converter \
  --input langsmith_data.jsonl \
  --output data/traces.jsonl \
  --input-format langchain
 
# 3. Create your Potato config and start annotating
potato start config.yaml -p 8000

De Langfuse a Potato (para anotación)

# 1. Export traces from Langfuse via API
import requests
 
response = requests.get(
    "https://cloud.langfuse.com/api/public/traces",
    headers={"Authorization": "Bearer your_api_key"},
    params={"limit": 500}
)
 
with open("langfuse_traces.json", "w") as f:
    json.dump(response.json()["data"], f)

# 2. Convert to Potato format
python -m potato.trace_converter \
  --input langfuse_traces.json \
  --output data/traces.jsonl \
  --input-format langfuse
 
# 3. Start annotating
potato start config.yaml -p 8000

Desde Label Studio o Argilla (para evaluación de agentes)

Si ahora mismo usas Label Studio o Argilla para anotación general y quieres añadir capacidades de evaluación de agentes, Potato puede funcionar junto a tu herramienta actual. Usa Label Studio o Argilla para tus tareas de anotación no agénticas (NER, clasificación, etc.) y Potato para la evaluación específica de agentes que requiere renderizado de trazas, anotación por paso y revisión de código.

Conclusión

Elegir entre Potato, LangSmith y Langfuse no va de cuál es mejor en abstracto. Depende de qué necesites sobre todo:

• Para monitorizar agentes en producción, usa LangSmith o Langfuse.
• Para evaluar el comportamiento de un agente con anotación humana estructurada, usa Potato.
• Si necesitas las dos cosas, úsalas juntas. Se complementan.

La pregunta que hay que hacerse es si tu objetivo principal es observar lo que hacen los agentes o evaluar lo bien que lo hacen. Si es evaluar, Potato está hecho para eso.

Para una comparación más completa, consulta la documentación de comparación y la guía de evaluación de agentes.