Potato face à LangSmith et Langfuse pour l'évaluation d'agents : une comparaison pratique

Trois outils, trois philosophies

Potato, LangSmith et Langfuse touchent tous à l'évaluation d'agents, mais ils y viennent depuis des points de départ différents :

• Potato part de l'annotation. Il a été construit pour recueillir des jugements humains structurés sur des sorties d'IA, puis étendu à la prise en charge des traces d'agents, des diffs de code et de l'observation en direct. Sa force tient à la finesse et à la configurabilité de ses schémas d'annotation.
• LangSmith part de l'observabilité. Il a été construit pour instrumenter, tracer et déboguer des applications LangChain en production. Ses fonctions d'annotation sont venues ensuite, pour accompagner les flux d'évaluation à l'intérieur de l'écosystème LangChain.
• Langfuse est une solution d'observabilité open source. Elle couvre le traçage, la gestion des prompts et l'évaluation pour n'importe quelle application LLM. Ses fonctions d'annotation fonctionnent, mais restent secondaires par rapport à sa surveillance.

Aucun n'est meilleur dans l'absolu. Le bon choix dépend de ce dont vous avez surtout besoin — annotation, observabilité, ou les deux — et de votre attachement à l'écosystème d'un framework donné.

Comparaison des fonctionnalités

Le tableau ci-dessous compare les capacités qui comptent pour l'évaluation d'agents IA. Nous y ajoutons Label Studio, Argilla et Scale AI, que les équipes mettent souvent dans la balance elles aussi.

¹ Les « Agent Graphs » de Langfuse (bêta) affichent une exécution multi-agents sous forme de graphe, mais comme vue de débogage en lecture seule — rien dans la documentation ne permet à un annotateur d'y marquer le chemin critique ou de signaler une arête. ² Scale AI annote les trajectoires GUI et d'usage de l'ordinateur dans le cadre de prestations de données gérées (par exemple ses travaux CUA-Suite dans CVAT), et non comme une fonctionnalité en libre-service que vous configurez. ³ Le « Voice Showdown » de Scale fonctionne par tours ; la notation full-duplex des interruptions et des chevauchements est annoncée comme prévue, pas encore disponible (au 2026-03-20).

Comparaison observée le 2026-06-24 face à LangSmith (docs.langchain.com), Langfuse (noyau MIT, publication continue), Label Studio 1.23.0, Argilla 2.8.0 et les pages produit de Scale AI. Ces outils évoluent vite : si quelque chose ici a vieilli, les corrections sont bienvenues sur le dépôt GitHub.

Parmi ces outils, Potato est le seul à afficher les traces d'agents de coding avec un vrai formatage de diff :

Le CodingTraceDisplay de Potato, avec rendu des diffs unifiés, coloration syntaxique et arborescence de fichiers

Prise en charge des formats de trace en détail

L'une des plus grandes différences pratiques tient au nombre de formats de traces d'agents que chaque outil gère nativement.

Potato inclut des convertisseurs pour 15 formats :

# 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

Il n'existe pas de convertisseur langsmith distinct : les exports LangSmith passent par langchain, et AutoGen et CrewAI passent par multi_agent. Si votre framework n'est pas dans la liste, --auto-detect tentera de choisir un convertisseur d'après les signatures de champs, et vous pouvez écrire le vôtre en dérivant BaseTraceConverter.

LangSmith fonctionne nativement avec les traces LangChain. Si votre agent est construit avec LangChain ou LangGraph, les traces arrivent automatiquement. Sinon, il faut instrumenter votre code à la main avec le SDK LangSmith, ou convertir vos traces au format LangSmith.

Langfuse fonctionne nativement avec les traces instrumentées via le SDK Langfuse. Il prend en charge Python et JavaScript, et propose des intégrations avec LangChain, LlamaIndex et OpenAI. Comme LangSmith, il demande une instrumentation au niveau du code plutôt qu'une conversion de traces après coup.

Importer des traces LangSmith ou Langfuse dans Potato

Si vous avez déjà des traces dans LangSmith ou Langfuse et voulez utiliser les fonctions d'annotation de Potato, les convertisseurs s'en chargent :

# 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

Vous pouvez donc garder LangSmith ou Langfuse pour la surveillance en production et faire entrer les traces dans Potato quand vous voulez une évaluation humaine détaillée.

L'annotation par étape : c'est là que l'écart est le plus grand

La différence de capacité la plus marquée porte sur la finesse de l'annotation par étape.

Potato propose le schéma trajectory_eval avec :

• Des étiquettes de justesse par étape (correcte / erronée)
• Le choix dans une taxonomie d'erreurs hiérarchique
• Des niveaux de gravité aux poids configurables
• Un score courant qui se met à jour à chaque étape
• Une justification en texte libre par étape
• Le tout configurable en YAML

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

LangSmith permet d'attacher une note numérique ou une étiquette catégorielle à chaque exécution individuelle d'une trace. C'est utile pour un suivi de qualité basique, mais sans taxonomies d'erreurs, pondération de gravité ni score courant. Il n'y a pas d'interface de revue par étape intégrée : vous notez les exécutions depuis la vue détaillée de la trace.

Langfuse permet de noter au niveau de la trace et au niveau de l'observation (span), et ses score configs catégorielles permettent de définir un ensemble d'étiquettes fixe — une taxonomie d'erreurs utilisable — et d'attacher plusieurs notes nommées au même span. Ce qu'il ne fournit pas comme schéma de premier plan, c'est une taxonomie hiérarchique ou un score courant pondéré par la gravité qui s'accumule au fil des étapes ; vous les assemblez vous-même à partir de score configs plates.

La version honnête de l'écart est donc plus étroite qu'avant : Langfuse et Label Studio (qui importe désormais des traces LangGraph, CrewAI et AutoGen pour la revue par étape) font tous deux de la notation structurée par étape. Là où Potato reste conçu pour cet usage, c'est dans la combinaison — taxonomie d'erreurs hiérarchique, poids de gravité et score courant dans un seul schéma trajectory_eval — c'est-à-dire ce qu'il vous faut pour construire des données d'entraînement PRM ou repérer où un agent dérape en premier.

Prise en charge des agents de coding

Évaluer des agents de coding (Claude Code, Aider, SWE-Agent, Devin, OpenHands) suppose d'afficher les diffs de code et la sortie du terminal pour que la relecture aille vite. C'est là que Potato prend de l'avance sur les autres.

Potato affiche :

• Des diffs unifiés avec surlignage rouge/vert et coloration syntaxique
• La sortie du terminal avec prise en charge des codes de couleur ANSI
• Des commentaires en ligne dans le diff, ancrés à des lignes précises
• Des notes de qualité par fichier
• Des verdicts façon PR : approuver ou demander des modifications

LangSmith affiche les entrées et sorties des appels d'outils sous forme de JSON formaté. Les diffs de code apparaissent comme des chaînes de texte brut à l'intérieur des sorties d'outils. Pas de rendu de diff, pas de coloration syntaxique, pas de commentaires en ligne.

Langfuse affiche de même les données de trace en JSON structuré. Le contenu de code apparaît en texte brut. Aucun rendu spécialisé pour les diffs ou la sortie du terminal.

Pour les agents de coding, cela change la journée du relecteur. Relire un diff de 50 lignes dans une vue de diff unifié colorée, avec commentaires en ligne, prend une fraction du temps qu'il faut pour lire le même diff sous forme de chaîne JSON.

Les traces d'agents web incluent les captures d'écran avec surcouches SVG et une navigation en pellicule :

Visionneuse de traces d'agent web montrant des captures d'écran avec surcouches SVG des actions et navigation en pellicule

Observation d'agent en direct

Potato peut observer un agent en cours d'exécution en temps réel, ce que ni LangSmith ni Langfuse ne font dans leurs flux d'annotation.

Dans le mode d'observation en direct de Potato, un annotateur peut regarder l'agent travailler étape par étape, le mettre en pause pour examiner son état courant, le relancer ensuite, et reprendre la session en main pour corriger la trajectoire ou terminer la tâche à la main.

C'est utile dans quelques situations : arrêter un agent avant qu'il ne fasse quelque chose de destructeur (sécurité), enregistrer les corrections humaines comme données de démonstration (entraînement), et voir comment un agent réagit quand vous intervenez en cours de route (évaluation interactive).

# 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 et Langfuse sont conçus pour l'analyse après coup de traces terminées, pas pour l'interaction en temps réel avec des agents en cours d'exécution.

Comparaison par paires

Comparer deux sorties d'agents côte à côte est un schéma d'évaluation courant, notamment pour tester des versions de modèles en A/B ou comparer des architectures d'agents.

Potato propose trois modes de comparaison :

• Côte à côte : les deux traces visibles en même temps, défilement synchronisé
• Séquentiel : d'abord la trace A, puis la trace B, puis le jugement
• Aveugle : les traces sont étiquetées « A » et « B » au hasard, sans indication du modèle

annotation_schemes:
  - annotation_type: "pairwise"

LangSmith propose une comparaison par paires basique via sa « vue de comparaison » dans les expériences d'évaluation. Vous pouvez comparer des exécutions entre différentes versions de modèles, mais l'interface vise l'inspection côte à côte des exécutions plutôt que l'annotation structurée de préférences.

Langfuse n'a pas de fonction de comparaison par paires intégrée pour l'annotation.

Quand utiliser chaque outil

Utilisez Potato quand :

• L'annotation est votre objectif premier : il vous faut des jugements humains structurés, pas seulement de la surveillance
• Il vous faut la prise en charge des agents de coding : rendu des diffs, commentaires en ligne, affichage de la sortie du terminal
• Vous recueillez des données d'entraînement PRM : étiquettes de justesse par étape avec scores courants
• Il vous faut l'auto-hébergement : les données restent sur votre infrastructure, sans dépendance au cloud
• Vous travaillez avec plusieurs frameworks d'agents : 15 convertisseurs de formats de traces plutôt qu'une dépendance à un seul framework
• Il vous faut des schémas d'évaluation riches : évaluation de trajectoire, grille d'évaluation, revue de code, comparaison par paires
• Le budget est une contrainte : entièrement gratuit et open source

Utilisez LangSmith quand :

• Vous utilisez déjà LangChain/LangGraph : les traces arrivent automatiquement, sans configuration
• La surveillance en production est votre besoin principal : traçage en temps réel, suivi de la latence, suivi des coûts
• L'annotation est secondaire : il vous faut de la notation et du retour basiques, pas des schémas d'évaluation poussés
• Vous voulez un service géré : aucune infrastructure à maintenir
• Votre équipe est petite : l'offre gratuite peut suffire pour une évaluation légère

Utilisez Langfuse quand :

• Il vous faut de l'observabilité open source : surveillance et traçage auto-hébergés
• Vous utilisez plusieurs fournisseurs de LLM : bonnes intégrations avec OpenAI, Anthropic, LangChain, LlamaIndex
• L'annotation n'est pas votre usage principal : la notation existe, mais n'est pas le cœur du produit
• Vous voulez la gestion des prompts en plus du traçage : Langfuse associe le versionnage des prompts à l'observabilité
• Il vous faut une alternative gratuite à LangSmith pour la surveillance : le noyau open source de Langfuse couvre l'essentiel des besoins de surveillance

L'approche complémentaire : observabilité + annotation

Pour beaucoup d'équipes, le montage pratique consiste à faire tourner un outil d'observabilité (LangSmith ou Langfuse) pour la surveillance en production et Potato pour l'évaluation humaine détaillée. Le déroulé ressemble à ceci :

1. Instrumentez votre agent avec LangSmith ou Langfuse pour le traçage en production
2. Échantillonnez les traces qui demandent une relecture humaine (échecs, cas limites, tirages aléatoires)
3. Exportez ces traces depuis votre outil d'observabilité
4. Convertissez et importez dans Potato avec les convertisseurs intégrés
5. Menez l'évaluation humaine avec les schémas d'annotation riches de Potato
6. Réinjectez les résultats dans votre cycle de développement

# 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

Vous obtenez ainsi la visibilité en temps réel d'une plateforme d'observabilité et la finesse d'annotation d'un outil pensé pour l'annotation.

Récapitulatif des principaux différenciateurs

Deux de ces surfaces sont celles où l'affirmation est la plus solide. De tous les outils que nous avons passés en revue (commerciaux comme open source), Potato est le seul à proposer des surfaces configurables par l'annotateur pour la structure d'équipe multi-agents et la revue d'agents multimodaux :

• Un graphe d'interaction multi-agents cliquable et modifiable par l'annotateur : marquez le chemin critique, signalez la mauvaise passation. Ce qui s'en approche le plus ailleurs, les « Agent Graphs » de Langfuse, est une vue de débogage en lecture seule.
• L'attribution des échecs entre agents, la revue des passations comme objet de premier plan, des tableaux de bord par agent et par équipe, une chronologie des conflits d'outils et l'étiquetage des comportements émergents : aucun des autres outils n'offre ces constructions d'annotation en natif.
• Les trajectoires d'usage de l'ordinateur avec ancrage des clics, les chronologies vocales full-duplex avec notation des interruptions et l'ancrage temporel vidéo avec IoU en direct. Scale AI fait de l'ancrage GUI et de l'évaluation vocale, mais sous forme de prestations de données gérées, et son arène vocale fonctionne encore par tours.

À cela s'ajoute que Potato reste le seul outil gratuit et auto-hébergeable qui réunit le rendu des diffs d'agents de coding avec commentaires en ligne, la collecte de données PRM, l'observation en direct avec pause, reprise et reprise en main, l'ingestion de traces quel que soit le framework, une taxonomie d'erreurs hiérarchique avec score courant pondéré par la gravité, trois modes de comparaison par paires et une revue de code façon PR.

Nous ne connaissons pas d'autre outil, open source ou commercial, qui regroupe tout cela — vérification faite face à LangSmith, Langfuse, Labelbox, Scale AI, Label Studio, Argilla et Braintrust au 2026-06-24 (voir la note datée sous le tableau comparatif). LangSmith et Langfuse sont de solides outils d'observabilité dont les fonctions d'annotation se limitent à des notes portées sur des spans, pas à des surfaces sur la structure de l'agent. Label Studio et Argilla sont des outils d'annotation généralistes ; Label Studio y a greffé l'import de traces, mais aucun des deux n'offre les surfaces multi-agents ou multimodales ci-dessus. Labelbox et Scale proposent des produits de données pour l'évaluation d'agents, mais sous forme de services payants, cloud ou gérés, plutôt que d'un outil auto-hébergeable qu'une équipe de recherche peut faire tourner et adapter.

Si votre objectif est de comprendre comment et pourquoi vos agents réussissent ou échouent, et de recueillir les données d'entraînement qui les amélioreront, Potato couvre un manque que les autres laissent ouvert.

Chemins de migration

De LangSmith vers Potato (pour l'annotation)

# 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 vers Potato (pour l'annotation)

# 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

Depuis Label Studio ou Argilla (pour l'évaluation d'agents)

Si vous utilisez aujourd'hui Label Studio ou Argilla pour de l'annotation généraliste et voulez y ajouter des capacités d'évaluation d'agents, Potato peut tourner à côté de votre outil actuel. Gardez Label Studio ou Argilla pour vos tâches d'annotation non liées aux agents (NER, classification, etc.) et prenez Potato pour l'évaluation propre aux agents, celle qui demande le rendu des traces, l'annotation par étape et la revue de code.

Conclusion

Choisir entre Potato, LangSmith et Langfuse, ce n'est pas décider lequel est le meilleur dans l'absolu. Cela dépend de ce dont vous avez surtout besoin :

• Pour surveiller des agents en production, prenez LangSmith ou Langfuse.
• Pour évaluer le comportement d'un agent avec une annotation humaine structurée, prenez Potato.
• S'il vous faut les deux, faites-les tourner ensemble. Ils se complètent.

La question à se poser est de savoir si votre objectif principal est d'observer ce que font vos agents ou d'évaluer à quel point ils le font bien. Si c'est l'évaluation, Potato est fait pour ça.

Pour une comparaison plus complète, voir la documentation comparative et le guide d'évaluation d'agents.