Potato vs. LangSmith und Langfuse für die Agent-Evaluation: ein praktischer Vergleich

Drei Werkzeuge, drei Herangehensweisen

Potato, LangSmith und Langfuse berühren alle die Agent-Evaluation, kommen aber von unterschiedlichen Ausgangspunkten:

• Potato setzt bei der Annotation an. Es wurde gebaut, um strukturierte menschliche Urteile über KI-Ausgaben zu sammeln, und später um Agent-Traces, Code-Diffs und Live-Beobachtung erweitert. Seine Stärke ist die Tiefe und Konfigurierbarkeit der Annotationsschemata.
• LangSmith setzt bei der Observability an. Es wurde gebaut, um LangChain-Anwendungen im Produktivbetrieb zu instrumentieren, zu tracen und zu debuggen. Die Annotationsfunktionen kamen später dazu, um Evaluationsabläufe innerhalb des LangChain-Ökosystems zu unterstützen.
• Langfuse ist Open-Source-Observability. Es deckt Tracing, Prompt-Verwaltung und Evaluation für beliebige LLM-Anwendungen ab. Die Annotationsfunktionen sind brauchbar, stehen aber hinter dem Monitoring zurück.

Keines dieser Werkzeuge ist pauschal besser. Die richtige Wahl hängt davon ab, ob vor allem Annotation, Observability oder beides gebraucht wird, und ob man sich auf ein bestimmtes Framework-Ökosystem festlegt.

Funktionsvergleich

Die folgende Tabelle vergleicht Fähigkeiten, die für die Evaluation von KI-Agenten relevant sind. Label Studio, Argilla und Scale AI sind ebenfalls aufgeführt, weil Teams diese oft mit abwägen.

¹ Langfuse „Agent Graphs" (Beta) stellt einen Multi-Agent-Lauf als Graph dar, aber als reine Debugging-Ansicht ohne Schreibzugriff. Es gibt keinen dokumentierten Weg, auf dem ein Annotator dort den kritischen Pfad markieren oder Kanten kennzeichnen könnte. ² Scale AI annotiert GUI- und Computer-Use-Trajektorien im Rahmen eines betreuten Datenprojekts (etwa die CUA-Suite-Arbeit in CVAT), nicht als Funktion, die man selbst konfiguriert. ³ Scales „Voice Showdown" ist turnbasiert; die Bewertung von Vollduplex-Barge-in und Überlappungen ist als geplant gelistet, aber noch nicht verfügbar (Stand 2026-03-20).

Vergleich erhoben am 2026-06-24 gegen LangSmith (docs.langchain.com), Langfuse (MIT-Kern, fortlaufende Releases), Label Studio 1.23.0, Argilla 2.8.0 und die Produktseiten von Scale AI. Diese Werkzeuge entwickeln sich schnell. Falls hier etwas veraltet ist, sind Korrekturen im GitHub-Repository willkommen.

Unter diesen Werkzeugen ist Potato das einzige, das Traces von Coding-Agenten mit ordentlicher Diff-Formatierung darstellt:

Potatos CodingTraceDisplay mit Unified-Diff-Darstellung, Syntaxhervorhebung und Dateibaum

Unterstützte Trace-Formate im Detail

Einer der größten praktischen Unterschiede ist, wie viele Agent-Trace-Formate ein Werkzeug nativ unterstützt.

Potato bringt Konverter für 15 Formate mit:

# 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

Einen eigenen langsmith-Konverter gibt es nicht: LangSmith-Exporte laufen über langchain, AutoGen und CrewAI über multi_agent. Steht dein Framework nicht auf der Liste, versucht --auto-detect, anhand der Feldsignaturen einen Konverter zu wählen; eigene Konverter schreibst du als Unterklasse von BaseTraceConverter.

LangSmith arbeitet nativ mit LangChain-Traces. Ist der Agent mit LangChain oder LangGraph gebaut, fließen die Traces automatisch ein. Andernfalls muss der Code von Hand mit dem LangSmith SDK instrumentiert oder die Traces müssen in das LangSmith-Format überführt werden.

Langfuse arbeitet nativ mit Traces, die über das Langfuse SDK instrumentiert wurden. Es unterstützt Python und JavaScript und bietet Integrationen für LangChain, LlamaIndex und OpenAI. Wie LangSmith setzt es eine Instrumentierung auf Code-Ebene voraus statt einer nachträglichen Trace-Konvertierung.

LangSmith- oder Langfuse-Traces nach Potato importieren

Wer bereits Traces in LangSmith oder Langfuse liegen hat und die Annotationsfunktionen von Potato nutzen möchte, verwendet die Konverter:

# 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

So lässt sich LangSmith oder Langfuse für das Monitoring im Produktivbetrieb behalten, während die Traces für eine ausführliche menschliche Evaluation nach Potato wandern.

Annotation pro Schritt: hier ist der Abstand am größten

Der deutlichste Unterschied liegt in der Tiefe der Annotation pro Schritt.

Potato bietet das Schema trajectory_eval mit:

• Korrektheitslabels pro Schritt (correct/incorrect)
• Auswahl aus einer hierarchischen Fehlertaxonomie
• Schweregraden mit konfigurierbaren Gewichten
• einem laufenden Punktestand, der sich mit jedem Schritt aktualisiert
• einer Freitextbegründung pro Schritt
• alles davon per YAML konfigurierbar

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

LangSmith erlaubt es, einzelnen Runs innerhalb eines Trace einen numerischen Score oder ein kategoriales Label anzuhängen. Das taugt für einfaches Qualitätstracking, unterstützt aber keine Fehlertaxonomien, keine Gewichtung nach Schweregrad und keine laufenden Punktestände. Eine eigene Review-Oberfläche pro Schritt gibt es nicht; bewertet wird aus der Trace-Detailansicht heraus.

Langfuse unterstützt Scoring auf Trace-Ebene und auf Ebene der Observation (Span), und seine kategorialen Score Configs erlauben eine feste Labelmenge, also eine brauchbare Fehlertaxonomie, sowie mehrere benannte Scores am selben Span. Was es nicht als eigenständiges Schema anbietet, ist eine hierarchische Taxonomie oder ein nach Schweregrad gewichteter laufender Punktestand, der sich über die Schritte hinweg aufsummiert; das baut man sich aus flachen Score Configs selbst zusammen.

Ehrlicherweise ist der Abstand also kleiner als früher: Langfuse und Label Studio (das inzwischen LangGraph-, CrewAI- und AutoGen-Traces für die Prüfung pro Schritt importiert) beherrschen beide strukturiertes Scoring pro Schritt. Wofür Potato gebaut ist, ist die Kombination aus hierarchischer Fehlertaxonomie, Schweregradgewichten und laufendem Punktestand in einem einzigen trajectory_eval-Schema. Genau das braucht man, um PRM-Trainingsdaten zu bauen oder um festzunageln, wo ein Agent zuerst falsch abbiegt.

Unterstützung für Coding-Agenten

Coding-Agenten zu evaluieren (Claude Code, Aider, SWE-Agent, Devin, OpenHands) heißt, Code-Diffs und Terminalausgaben so darzustellen, dass das Review zügig läuft. Hier zieht Potato an den anderen vorbei.

Potato stellt dar:

• Unified Diffs mit Rot/Grün-Markierung und Syntaxhervorhebung
• Terminalausgaben samt ANSI-Farbcodes
• Inline-Kommentare im Diff, an konkrete Zeilen geheftet
• Qualitätsbewertungen pro Datei
• Urteile im PR-Stil (annehmen / Änderungen anfordern)

LangSmith zeigt Ein- und Ausgaben von Tool-Aufrufen als formatiertes JSON. Code-Diffs erscheinen als rohe Textstrings innerhalb der Tool-Ausgaben. Es gibt keine Diff-Darstellung, keine Syntaxhervorhebung und keine Inline-Kommentare.

Langfuse zeigt Trace-Daten ebenfalls als strukturiertes JSON. Code erscheint als reiner Text. Für Diffs oder Terminalausgaben gibt es keine besondere Darstellung.

Bei Coding-Agenten verändert das den Arbeitstag der Reviewer. Ein Diff über 50 Zeilen in einer syntaxhervorgehobenen Unified-Diff-Ansicht mit Inline-Kommentaren zu prüfen, dauert einen Bruchteil der Zeit, die dasselbe Diff als JSON-String kostet.

Traces von Web-Agenten enthalten Screenshots mit SVG-Overlays und eine Filmstreifen-Navigation:

Trace-Viewer für Web-Agenten mit Screenshots, SVG-Overlays der Aktionen und Filmstreifen-Navigation

Live-Beobachtung von Agenten

Potato kann einen laufenden Agenten in Echtzeit beobachten, was weder LangSmith noch Langfuse in ihren Annotationsabläufen tun.

Im Live-Beobachtungsmodus von Potato sieht ein Annotator dem Agenten Schritt für Schritt zu, pausiert ihn, um den aktuellen Zustand zu prüfen, setzt ihn danach fort und kann die Sitzung übernehmen, um den Kurs zu korrigieren oder die Aufgabe von Hand zu beenden.

Das hilft in einigen Situationen: einen Agenten zu stoppen, bevor er etwas Zerstörerisches tut (Sicherheit), menschliche Korrekturen als Demonstrationsdaten festzuhalten (Training) und zu sehen, wie ein Agent auf einen Eingriff mitten im Lauf reagiert (interaktive Evaluation).

# 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 und Langfuse sind auf die nachträgliche Analyse abgeschlossener Traces ausgelegt, nicht auf die Interaktion mit laufenden Agenten in Echtzeit.

Paarweiser Vergleich

Zwei Agent-Ausgaben nebeneinander zu vergleichen, ist ein gängiges Evaluationsmuster, besonders beim A/B-Test von Modellversionen oder beim Vergleich von Agent-Architekturen.

Potato bietet drei Vergleichsmodi:

• Nebeneinander: Beide Traces gleichzeitig sichtbar, mit synchronisiertem Scrollen
• Nacheinander: erst Trace A ansehen, dann Trace B, dann urteilen
• Blind: Die Traces werden zufällig mit „A" und „B" beschriftet, ohne Angabe des Modells

annotation_schemes:
  - annotation_type: "pairwise"

LangSmith unterstützt einen einfachen paarweisen Vergleich über die Vergleichsansicht in Evaluationsexperimenten. Runs verschiedener Modellversionen lassen sich gegenüberstellen, aber die Oberfläche ist auf die Inspektion zweier Runs ausgelegt und nicht auf strukturierte Präferenzannotation.

Langfuse hat keinen eingebauten paarweisen Vergleich für die Annotation.

Wann welches Werkzeug

Potato nutzen, wenn:

• Annotation das Hauptziel ist: Es geht um strukturierte menschliche Urteile, nicht nur um Monitoring
• Coding-Agenten unterstützt werden müssen: Diff-Darstellung, Inline-Kommentare, Terminalausgabe
• PRM-Trainingsdaten gesammelt werden: Korrektheitslabels pro Schritt mit laufendem Punktestand
• Self-Hosting nötig ist: Die Daten bleiben in der eigenen Infrastruktur, ohne Cloud-Abhängigkeit
• mehrere Agent-Frameworks im Einsatz sind: 15 Trace-Konverter statt Bindung an ein einzelnes Framework
• reichhaltige Evaluationsschemata gebraucht werden: Trajektorien-Evaluation, Rubrik-Evaluation, Code-Review, paarweiser Vergleich
• das Budget knapp ist: vollständig kostenlos und Open Source

LangSmith nutzen, wenn:

• LangChain/LangGraph ohnehin im Einsatz ist: Traces fließen ohne Konfiguration automatisch ein
• Monitoring im Produktivbetrieb im Vordergrund steht: Tracing in Echtzeit, Latenz- und Kostenüberwachung
• Annotation zweitrangig ist: Es reichen einfache Bewertungen und Rückmeldungen statt tiefer Evaluationsschemata
• ein Managed Service gewünscht ist: keine eigene Infrastruktur zu betreiben
• das Team klein ist: Der kostenlose Tarif kann für leichte Evaluation ausreichen

Langfuse nutzen, wenn:

• Observability als Open Source gebraucht wird: selbst gehostetes Monitoring und Tracing
• mehrere LLM-Anbieter im Einsatz sind: gute Integrationen für OpenAI, Anthropic, LangChain und LlamaIndex
• Annotation nicht der Hauptanwendungsfall ist: Scoring gibt es, steht aber nicht im Mittelpunkt
• Prompt-Verwaltung zusammen mit Tracing gewünscht ist: Langfuse bündelt Prompt-Versionierung mit Observability
• eine kostenlose Alternative zu LangSmith fürs Monitoring gesucht wird: Der Open-Source-Kern von Langfuse deckt die meisten Monitoring-Bedürfnisse ab

Der ergänzende Ansatz: Observability plus Annotation

Für viele Teams ist die praktische Aufstellung, ein Observability-Werkzeug (LangSmith oder Langfuse) fürs Monitoring im Produktivbetrieb zu betreiben und Potato für die ausführliche menschliche Evaluation. Der Ablauf sieht so aus:

1. Den Agenten instrumentieren mit LangSmith oder Langfuse für das Tracing im Produktivbetrieb
2. Traces auswählen, die eine menschliche Prüfung brauchen (Fehlschläge, Grenzfälle, Zufallsstichproben)
3. Diese Traces exportieren aus dem Observability-Werkzeug
4. Konvertieren und importieren nach Potato mit den mitgelieferten Konvertern
5. Menschliche Evaluation durchführen mit den reichhaltigen Annotationsschemata von Potato
6. Ergebnisse zurückspielen in den Entwicklungszyklus

# 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

Damit gibt es die Sichtbarkeit in Echtzeit einer Observability-Plattform und daneben die Annotationstiefe eines Werkzeugs, das für Annotation gebaut wurde.

Zusammenfassung der Unterschiede

Bei zwei dieser Oberflächen ist die Aussage am stärksten. Von allen untersuchten Werkzeugen (kommerziell wie Open Source) ist Potato das einzige, das vom Annotator konfigurierbare Oberflächen für die Teamstruktur von Multi-Agent-Systemen und für das Review multimodaler Agenten bietet:

• Einen anklickbaren, vom Annotator bearbeitbaren Interaktionsgraphen für Multi-Agent-Systeme: den kritischen Pfad markieren, den schlechten Handoff kennzeichnen. Das Nächstliegende anderswo, Langfuses „Agent Graphs", ist eine Debugging-Ansicht ohne Schreibzugriff.
• Fehlerzuordnung über Agenten hinweg, Handoff-Review als eigenständiges Objekt, Scorecards pro Agent und pro Team, eine Zeitleiste für Werkzeugkonflikte und Tagging emergenten Verhaltens. Nichts davon bieten die anderen Werkzeuge als eingebautes Annotationskonstrukt.
• Computer-Use-Trajektorien mit Klick-Grounding, Vollduplex-Sprachzeitleisten mit Bewertung von Barge-in und zeitliches Grounding in Videos mit live berechnetem IoU. Scale AI macht GUI-Grounding und Sprachevaluation, aber als betreute Datenprojekte, und die Sprach-Arena ist weiterhin turnbasiert.

Darüber hinaus bleibt Potato das einzige kostenlose, selbst hostbare Werkzeug, das Diff-Darstellung für Coding-Agenten mit Inline-Kommentaren, Erhebung von PRM-Daten, Live-Beobachtung mit Pause, Fortsetzen und Übernahme, Trace-Import aus beliebigen Frameworks, eine hierarchische Fehlertaxonomie mit nach Schweregrad gewichtetem laufendem Punktestand, drei Modi für paarweisen Vergleich und Code-Review im PR-Stil vereint.

Uns ist kein anderes Werkzeug bekannt, ob Open Source oder kommerziell, das all das bündelt. Geprüft wurde gegen LangSmith, Langfuse, Labelbox, Scale AI, Label Studio, Argilla und Braintrust, Stand 2026-06-24 (siehe die datierte Fußnote unter der Vergleichstabelle). LangSmith und Langfuse sind starke Observability-Werkzeuge, deren Annotationsfunktionen Scores auf Span-Ebene sind und keine Oberflächen für Agent-Strukturen. Label Studio und Argilla sind allgemeine Annotationswerkzeuge; Label Studio hat den Trace-Import nachgerüstet, aber keines von beiden bietet die oben genannten Oberflächen für Multi-Agent- oder multimodale Agenten. Labelbox und Scale bieten Datenprodukte für die Agent-Evaluation an, allerdings als kostenpflichtige Cloud- oder Managed Services und nicht als selbst hostbares Werkzeug, das ein Forschungsteam betreiben und anpassen kann.

Wer verstehen will, wie und warum seine Agenten gelingen oder scheitern, und die Trainingsdaten sammeln will, um sie zu verbessern, findet bei Potato eine Lücke geschlossen, die die anderen offen lassen.

Migrationswege

Von LangSmith zu Potato (für die 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

Von Langfuse zu Potato (für die 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

Von Label Studio oder Argilla (für die Agent-Evaluation)

Wer derzeit Label Studio oder Argilla für allgemeine Annotation nutzt und Funktionen zur Agent-Evaluation ergänzen möchte, kann Potato parallel zum bestehenden Werkzeug betreiben. Label Studio oder Argilla übernehmen dann die Annotationsaufgaben ohne Agentenbezug (NER, Klassifikation und Ähnliches), Potato die agentenspezifische Evaluation, die Trace-Darstellung, Annotation pro Schritt und Code-Review braucht.

Fazit

Die Wahl zwischen Potato, LangSmith und Langfuse ist keine Frage danach, was im Abstrakten am besten ist. Sie hängt davon ab, was hauptsächlich gebraucht wird:

• Um Agenten im Produktivbetrieb zu überwachen, eignen sich LangSmith oder Langfuse.
• Um das Verhalten von Agenten mit strukturierter menschlicher Annotation zu evaluieren, eignet sich Potato.
• Wer beides braucht, betreibt sie zusammen. Sie ergänzen einander.

Die Frage lautet, ob es hauptsächlich darum geht, zu beobachten, was Agenten tun, oder zu bewerten, wie gut sie es tun. Geht es um die Bewertung, ist Potato dafür gebaut.

Einen ausführlicheren Vergleich bieten die Vergleichsdokumentation und der Leitfaden zur Agent-Evaluation.