Potato, LangSmith e Langfuse per la valutazione degli agenti: un confronto pratico

Tre strumenti, tre filosofie

Potato, LangSmith e Langfuse toccano tutti la valutazione degli agenti, ma ci arrivano da punti di partenza diversi:

• Potato nasce dall'annotazione. È stato costruito per raccogliere giudizi umani strutturati sugli output dell'AI, e poi esteso alle tracce degli agenti, ai diff del codice e all'osservazione dal vivo. Il suo punto forte è la profondità e la configurabilità degli schemi di annotazione.
• LangSmith nasce dall'osservabilità. È stato costruito per strumentare, tracciare e debuggare applicazioni LangChain in produzione. Le funzionalità di annotazione sono arrivate dopo, a supporto dei flussi di valutazione dentro l'ecosistema LangChain.
• Langfuse è osservabilità open source. Copre tracing, gestione dei prompt e valutazione per qualsiasi applicazione LLM. Le sue funzionalità di annotazione funzionano, ma restano secondarie rispetto al monitoraggio.

Nessuno dei tre è migliore in assoluto. La scelta giusta dipende da che cosa ti serve soprattutto — annotazione, osservabilità o entrambe — e dal fatto che tu sia legato o meno all'ecosistema di un framework specifico.

Confronto delle funzionalità

La tabella qui sotto confronta le capacità rilevanti per la valutazione degli agenti AI. Includiamo anche Label Studio, Argilla e Scale AI, dato che spesso i team li mettono sul piatto.

¹ Gli «Agent Graphs» di Langfuse (in beta) mostrano l'esecuzione multi-agente come grafo, ma come vista di debug in sola lettura: non è documentato alcun modo per far segnare all'annotatore il percorso critico o marcare gli archi. ² Scale AI annota le traiettorie GUI e di computer use come ingaggio gestito sui dati (per esempio il lavoro su CUA-Suite in CVAT), non come funzionalità self-serve che configuri tu. ³ La «Voice Showdown» di Scale è a turni; il punteggio full-duplex su interruzioni e sovrapposizioni è indicato come previsto, non ancora disponibile (al 2026-03-20).

Confronto rilevato il 2026-06-24 su LangSmith (docs.langchain.com), Langfuse (core MIT, rilasci continui), Label Studio 1.23.0, Argilla 2.8.0 e le pagine di prodotto di Scale AI. Questi strumenti si muovono in fretta: se qui qualcosa è ormai superato, le correzioni sono benvenute sul repository GitHub.

Tra questi strumenti, Potato è l'unico che mostra le tracce dei coding agent con una formattazione dei diff decente:

Il CodingTraceDisplay di Potato con rendering dei diff unificati, syntax highlighting e albero dei file

I formati di traccia nel dettaglio

Una delle differenze pratiche più grosse è quanti formati di traccia degli agenti ciascuno strumento supporta in modo nativo.

Potato include convertitori per 15 formati:

# 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

Non esiste un convertitore langsmith separato: le esportazioni di LangSmith passano da langchain, mentre AutoGen e CrewAI passano da multi_agent. Se il tuo framework non è in elenco, --auto-detect proverà a scegliere un convertitore dalle firme dei campi, e puoi scrivere il tuo estendendo BaseTraceConverter.

LangSmith funziona in modo nativo con le tracce LangChain. Se il tuo agente è costruito con LangChain o LangGraph, le tracce arrivano da sole. Altrimenti devi strumentare il codice a mano con l'SDK di LangSmith, oppure convertire le tracce nel formato di LangSmith.

Langfuse funziona in modo nativo con le tracce strumentate tramite l'SDK Langfuse. Supporta Python e JavaScript e ha integrazioni con LangChain, LlamaIndex e OpenAI. Come LangSmith, richiede la strumentazione a livello di codice invece della conversione delle tracce a posteriori.

Importare in Potato le tracce di LangSmith o Langfuse

Se hai già tracce in LangSmith o Langfuse e vuoi usare le funzionalità di annotazione di Potato, ci pensano i convertitori:

# 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

Puoi quindi tenere LangSmith o Langfuse per il monitoraggio in produzione e portare le tracce in Potato quando vuoi una valutazione umana dettagliata.

Annotazione per singolo passo: dove il divario è più ampio

La differenza di capacità più significativa sta nella profondità dell'annotazione per singolo passo.

Potato offre lo schema trajectory_eval con:

• Etichette di correttezza a livello di passo (corretto/sbagliato)
• Selezione da una tassonomia gerarchica degli errori
• Livelli di gravità con pesi configurabili
• Punteggio progressivo che si aggiorna a ogni passo
• Motivazione a testo libero per ogni passo
• Tutto questo è configurabile via YAML

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

LangSmith permette di attaccare un punteggio numerico o un'etichetta categoriale alle singole run dentro una traccia. Va bene per un tracciamento di qualità di base, ma non supporta tassonomie degli errori, pesi di gravità o punteggi progressivi. Non c'è un'interfaccia dedicata alla revisione passo per passo: le run si valutano dalla vista di dettaglio della traccia.

Langfuse supporta l'assegnazione di punteggi a livello di traccia e a livello di observation (span), e le sue score config categoriali permettono di definire un insieme fisso di etichette — una tassonomia degli errori utilizzabile — e di attaccare più punteggi con nome allo stesso span. Quello che non offre come schema di prima classe è una tassonomia gerarchica o un punteggio progressivo pesato per gravità che si accumuli lungo i passi; quelli te li costruisci a mano a partire da score config piatte.

La versione onesta del divario è quindi più stretta di un tempo: sia Langfuse sia Label Studio (che ora importa tracce LangGraph/CrewAI/AutoGen per la revisione passo per passo) fanno punteggio strutturato per singolo passo. Dove Potato resta costruito apposta è nella combinazione: una tassonomia gerarchica degli errori più i pesi di gravità più un punteggio progressivo in un solo schema trajectory_eval, che è quello che serve per costruire dati di addestramento per PRM o per individuare il punto esatto in cui un agente inizia a sbagliare.

Supporto ai coding agent

Valutare i coding agent (Claude Code, Aider, SWE-Agent, Devin, OpenHands) vuol dire mostrare i diff del codice e l'output del terminale in modo che la revisione scorra veloce. È qui che Potato stacca gli altri.

Potato mostra:

• Diff unificati con evidenziazione rosso/verde e syntax highlighting
• Output del terminale con supporto ai codici colore ANSI
• Commenti inline sul diff ancorati a righe specifiche
• Valutazioni di qualità a livello di file
• Verdetti approva/richiedi modifiche in stile PR

LangSmith mostra input e output delle chiamate agli strumenti come JSON formattato. I diff del codice compaiono come stringhe di testo grezzo dentro gli output degli strumenti. Non c'è rendering dei diff, né syntax highlighting, né commenti inline.

Langfuse allo stesso modo mostra i dati delle tracce come JSON strutturato. Il codice compare come testo semplice. Nessun rendering specializzato per diff o output del terminale.

Per i coding agent, questo cambia la giornata di chi revisiona. Rivedere un diff di 50 righe in una vista a diff unificato con syntax highlighting e commenti inline richiede una frazione del tempo che serve a leggere lo stesso diff come stringa JSON.

Le tracce degli agenti web includono screenshot con overlay SVG e navigazione a filmstrip:

Visualizzatore di tracce di agenti web con screenshot, overlay SVG delle azioni e navigazione a filmstrip

Osservazione dal vivo degli agenti

Potato può osservare un agente in esecuzione in tempo reale, cosa che né LangSmith né Langfuse fanno nei loro flussi di annotazione.

Nella modalità di osservazione dal vivo di Potato l'annotatore può guardare l'agente lavorare passo dopo passo, metterlo in pausa per esaminare lo stato attuale, farlo ripartire e prendere il controllo della sessione per correggere la rotta o portare a termine il compito a mano.

Serve in alcune situazioni: fermare un agente prima che faccia qualcosa di distruttivo (sicurezza), registrare le correzioni umane come dati dimostrativi (addestramento) e vedere come reagisce un agente quando intervieni mentre sta lavorando (valutazione interattiva).

# 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 e Langfuse sono pensati per l'analisi a posteriori di tracce già concluse, non per l'interazione in tempo reale con agenti in esecuzione.

Confronto a coppie

Confrontare due output di un agente affiancati è un pattern di valutazione comune, soprattutto per gli A/B test tra versioni di un modello o per confrontare architetture di agenti.

Potato offre tre modalità di confronto:

• Affiancata: entrambe le tracce visibili insieme, con scorrimento sincronizzato
• Sequenziale: prima la traccia A, poi la traccia B, poi il giudizio
• Cieca: le tracce vengono etichettate a caso come «A» e «B» senza indicare il modello

annotation_schemes:
  - annotation_type: "pairwise"

LangSmith supporta un confronto a coppie di base attraverso la sua «comparison view» negli esperimenti di valutazione. Puoi confrontare run di versioni diverse del modello, ma l'interfaccia è pensata per l'ispezione affiancata delle run più che per l'annotazione strutturata delle preferenze.

Langfuse non ha una funzionalità integrata di confronto a coppie per l'annotazione.

Quando usare quale strumento

Usa Potato quando:

• L'annotazione è il tuo obiettivo principale: ti servono giudizi umani strutturati, non solo monitoraggio
• Ti serve il supporto ai coding agent: rendering dei diff, commenti inline, output del terminale
• Stai raccogliendo dati di addestramento per PRM: etichette di correttezza a livello di passo con punteggi progressivi
• Ti serve il self-hosting: i dati restano sulla tua infrastruttura, senza dipendenze cloud
• Lavori con più framework di agenti: 15 convertitori di formati contro il lock-in su un solo framework
• Ti servono schemi di valutazione ricchi: trajectory eval, rubric eval, code review, confronto a coppie
• Il budget è un vincolo: interamente gratuito e open source

Usa LangSmith quando:

• Usi già LangChain/LangGraph: le tracce arrivano da sole, senza configurazione
• Il monitoraggio in produzione è la tua esigenza principale: tracing in tempo reale, latenza, costi
• L'annotazione è secondaria: ti servono punteggi e feedback di base, non schemi di valutazione profondi
• Vuoi un servizio gestito: nessuna infrastruttura da mantenere
• Il tuo team è piccolo: il piano gratuito può bastare per una valutazione leggera

Usa Langfuse quando:

• Ti serve osservabilità open source: monitoraggio e tracing self-hosted
• Usi più provider di LLM: buone integrazioni con OpenAI, Anthropic, LangChain, LlamaIndex
• L'annotazione non è il tuo caso d'uso principale: i punteggi ci sono, ma non sono il centro
• Vuoi la gestione dei prompt insieme al tracing: Langfuse unisce il versionamento dei prompt all'osservabilità
• Ti serve un'alternativa gratuita a LangSmith per il monitoraggio: il core open source di Langfuse copre quasi tutte le esigenze di monitoraggio

L'approccio complementare: osservabilità + annotazione

Per molti team la soluzione pratica è tenere uno strumento di osservabilità (LangSmith o Langfuse) per il monitoraggio in produzione e Potato per la valutazione umana dettagliata. Il flusso è questo:

1. Strumenta il tuo agente con LangSmith o Langfuse per il tracing in produzione
2. Campiona le tracce che hanno bisogno di revisione umana (fallimenti, casi limite, campioni casuali)
3. Esporta quelle tracce dal tuo strumento di osservabilità
4. Converti e importa in Potato con i convertitori integrati
5. Esegui la valutazione umana con gli schemi di annotazione di Potato
6. Riporta i risultati nel tuo ciclo di sviluppo

# 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

Così ottieni la visibilità in tempo reale di una piattaforma di osservabilità insieme alla profondità di annotazione di uno strumento nato per annotare.

Riepilogo dei fattori distintivi

Su due di queste superfici l'affermazione è più solida che altrove. Di tutti gli strumenti che abbiamo esaminato (commerciali e open source), Potato è l'unico a offrire superfici configurabili dall'annotatore per la struttura dei team multi-agente e per la revisione degli agenti multimodali:

• Un grafo di interazione multi-agente cliccabile e modificabile dall'annotatore: segna il percorso critico, marca l'handoff sbagliato. La cosa più vicina altrove, gli «Agent Graphs» di Langfuse, è una vista di debug in sola lettura.
• Attribuzione dei fallimenti tra agenti, revisione degli handoff come oggetto di prima classe, scorecard per agente e per team, una timeline della contesa sugli strumenti e il tagging dei comportamenti emergenti: nessuno degli altri strumenti li offre come costrutti di annotazione integrati.
• Traiettorie di computer use con grounding dei click, timeline vocali full-duplex con punteggio delle interruzioni e grounding temporale su video con IoU dal vivo. Scale AI fa grounding su GUI e valutazione vocale, ma come ingaggi gestiti sui dati, e la sua arena vocale è ancora a turni.

Oltre a questo, Potato resta l'unico strumento gratuito e self-hosted che mette insieme rendering dei diff dei coding agent con commenti inline, raccolta di dati PRM, osservazione dal vivo con pausa/ripresa/subentro, ingestione di tracce da qualsiasi framework, tassonomia gerarchica degli errori con punteggio progressivo pesato per gravità, tre modalità di confronto a coppie e code review in stile PR.

Non ci risulta che esista un altro strumento, open source o commerciale, che offra tutto questo insieme: verificato su LangSmith, Langfuse, Labelbox, Scale AI, Label Studio, Argilla e Braintrust al 2026-06-24 (vedi la nota datata sotto la tabella di confronto). LangSmith e Langfuse sono buoni strumenti di osservabilità, le cui funzionalità di annotazione sono punteggi limitati agli span, non superfici sulla struttura degli agenti. Label Studio e Argilla sono strumenti di annotazione generici; Label Studio ci ha innestato sopra l'import delle tracce, ma nessuno dei due offre le superfici multi-agente o multimodali di cui sopra. Labelbox e Scale offrono prodotti dati per la valutazione degli agenti, ma come servizi a pagamento, cloud o gestiti, non come strumento self-hosted che un gruppo di ricerca può far girare e personalizzare.

Se il tuo obiettivo è capire come e perché i tuoi agenti riescono o falliscono, e raccogliere i dati di addestramento per migliorarli, Potato copre uno spazio che gli altri lasciano scoperto.

Percorsi di migrazione

Da LangSmith a Potato (per l'annotazione)

# 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

Da Langfuse a Potato (per l'annotazione)

# 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

Da Label Studio o Argilla (per la valutazione degli agenti)

Se al momento usi Label Studio o Argilla per l'annotazione generica e vuoi aggiungere capacità di valutazione degli agenti, Potato può girare accanto allo strumento che hai già. Usa Label Studio o Argilla per i compiti di annotazione non legati agli agenti (NER, classificazione e simili) e Potato per la valutazione specifica degli agenti, quella che richiede rendering delle tracce, annotazione per singolo passo e code review.

Conclusione

Scegliere tra Potato, LangSmith e Langfuse non è una questione di quale sia il migliore in astratto. Dipende da che cosa ti serve soprattutto:

• Per monitorare gli agenti in produzione, usa LangSmith o Langfuse.
• Per valutare il comportamento degli agenti con annotazione umana strutturata, usa Potato.
• Se ti servono entrambe le cose, falli girare insieme. Si completano a vicenda.

La domanda da porsi è se il tuo obiettivo principale sia osservare che cosa fanno gli agenti oppure valutare quanto lo fanno bene. Se è la valutazione, Potato è costruito per quello.

Per un confronto affiancato più esteso, vedi la documentazione di confronto e la guida alla valutazione degli agenti.