Potato vs LangSmith e Langfuse para avaliação de agentes: uma comparação prática

Três ferramentas, três filosofias

Potato, LangSmith e Langfuse tocam todos na avaliação de agentes, mas partem de pontos de partida diferentes:

• O Potato é orientado à anotação. Foi construído para coletar julgamentos humanos estruturados sobre saídas de IA e depois ampliado para dar suporte a traces de agentes, diffs de código e observação ao vivo. Sua força está na profundidade e na configurabilidade dos esquemas de anotação.
• O LangSmith é orientado à observabilidade. Foi construído para instrumentar, rastrear e depurar aplicações LangChain em produção. Seus recursos de anotação vieram depois, para apoiar fluxos de avaliação dentro do ecossistema LangChain.
• O Langfuse é observabilidade de código aberto. Cobre tracing, gerenciamento de prompts e avaliação para qualquer aplicação LLM. Seus recursos de anotação funcionam, mas são secundários ao monitoramento.

Nenhum deles é universalmente melhor. A escolha certa depende de você precisar principalmente de anotação, observabilidade ou ambos, e de estar ou não comprometido com o ecossistema de um framework específico.

Comparação de recursos

A tabela abaixo compara capacidades relevantes para a avaliação de agentes de IA. Incluímos também o Label Studio, o Argilla e a Scale AI, já que as equipes costumam considerar essas opções também.

Entre essas ferramentas, o Potato é a única que renderiza traces de agentes de codificação com formatação de diff adequada:

CodingTraceDisplay do Potato com renderização de diff unificado, realce de sintaxe e árvore de arquivos

Suporte a formatos de trace em detalhe

Uma das maiores diferenças práticas é quantos formatos de trace de agentes cada ferramenta suporta nativamente.

O Potato inclui conversores para 13 formatos:

# See all available converters
python -m potato.convert_traces --list-formats
 
# Available formats:
#   react          - ReAct-style (Thought/Action/Observation)
#   openai         - OpenAI function calling / tool use
#   anthropic      - Anthropic Messages API with tool_use
#   langchain      - LangChain run traces
#   langfuse       - Langfuse trace exports
#   langsmith      - LangSmith dataset exports
#   autogen        - Microsoft AutoGen conversations
#   crewai         - CrewAI task outputs
#   swe_agent      - SWE-Agent trajectories
#   claude_code    - Claude Code session logs
#   aider          - Aider chat histories
#   webarena       - WebArena episode traces
#   custom         - User-defined format with mapping config

O LangSmith funciona nativamente com traces do LangChain. Se o seu agente foi construído com LangChain ou LangGraph, os traces fluem automaticamente. Caso contrário, você precisa instrumentar manualmente o seu código com o SDK do LangSmith ou converter os seus traces para o formato do LangSmith.

O Langfuse funciona nativamente com traces instrumentados via SDK do Langfuse. Ele suporta Python, JavaScript e tem integrações com LangChain, LlamaIndex e OpenAI. Assim como o LangSmith, exige instrumentação no nível do código, em vez de conversão de traces a posteriori.

Importando traces do LangSmith ou do Langfuse para o Potato

Se você já tem traces no LangSmith ou no Langfuse e quer usar os recursos de anotação do Potato, os conversores cuidam disso:

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

Assim, você pode manter o LangSmith ou o Langfuse para o monitoramento em produção e trazer os traces para o Potato quando quiser uma avaliação humana detalhada.

Anotação por etapa: onde a diferença é maior

A diferença de capacidade mais significativa está na profundidade da anotação por etapa.

O Potato oferece o esquema trajectory_eval com:

• Rótulos de correção por etapa (correto/incorreto)
• Seleção em taxonomia hierárquica de erros
• Níveis de severidade com pesos configuráveis
• Pontuação corrente que se atualiza a cada etapa
• Justificativa em texto livre por etapa
• Tudo isso configurável via YAML

# Potato: rich per-step annotation
annotation_schemes:
  - annotation_type: "trajectory_eval"
    name: "step_eval"
    step_correctness:
      labels: ["correct", "incorrect"]
    error_taxonomy:
      - category: "reasoning"
        types:
          - name: "logical_error"
          - name: "incorrect_assumption"
      - category: "action"
        types:
          - name: "wrong_tool"
          - name: "wrong_arguments"
    severity_levels:
      - name: "minor"
        weight: -1
      - name: "major"
        weight: -5
      - name: "critical"
        weight: -10
    running_score:
      initial: 100

O LangSmith permite anexar uma pontuação numérica ou um rótulo categórico a execuções individuais dentro de um trace. Isso é útil para acompanhamento básico de qualidade, mas não suporta taxonomias de erros, ponderação de severidade ou pontuações correntes. Não há interface de revisão por etapa embutida; você pontua as execuções a partir da visão de detalhe do trace.

O Langfuse suporta pontuação no nível do trace e no nível da observação (span). Você pode anexar pontuações numéricas ou categóricas. Assim como o LangSmith, não há taxonomia estruturada de erros nem sistema de severidade. As pontuações são pares chave-valor planos.

Se você precisa de avaliação detalhada por etapa, digamos para construir dados de treinamento de PRM ou diagnosticar onde um agente falha, o Potato é o único dos três com ferramentas feitas para isso.

Suporte a agentes de codificação

Avaliar agentes de codificação (Claude Code, Aider, SWE-Agent, Devin, OpenHands) significa renderizar diffs de código e saída de terminal para que a revisão seja rápida. É aqui que o Potato se destaca dos demais.

O Potato renderiza:

• Diffs unificados com realce em vermelho/verde e realce de sintaxe
• Saída de terminal com suporte a códigos de cor ANSI
• Comentários inline no diff ancorados a linhas específicas
• Avaliações de qualidade no nível do arquivo
• Vereditos estilo PR de aprovar/solicitar alterações

O LangSmith exibe entradas e saídas de chamadas de ferramenta como JSON formatado. Os diffs de código aparecem como strings de texto bruto dentro das saídas de ferramenta. Não há renderização de diff, realce de sintaxe nem comentários inline.

O Langfuse da mesma forma exibe os dados de trace como JSON estruturado. O conteúdo de código aparece como texto simples. Sem renderização especializada para diffs ou saída de terminal.

Para agentes de codificação, isso muda o dia do revisor. Revisar um diff de 50 linhas em uma visão de diff unificado com realce de sintaxe e comentários inline leva uma fração do tempo que leva para ler o mesmo diff como uma string JSON.

Os traces de agentes web incluem capturas de tela com sobreposições SVG e navegação em filmstrip:

Visualizador de trace de agente web mostrando capturas de tela com sobreposições de ação em SVG e navegação em filmstrip

Observação de agentes ao vivo

O Potato pode observar um agente em execução em tempo real, algo que nem o LangSmith nem o Langfuse fazem em seus fluxos de anotação.

No modo de observação ao vivo do Potato, um anotador pode acompanhar o agente trabalhar passo a passo, pausá-lo para revisar o estado atual, retomá-lo em seguida e assumir o controle da sessão para corrigir o rumo ou concluir a tarefa manualmente.

Isso ajuda em algumas situações: deter um agente antes que ele faça algo destrutivo (segurança), registrar correções humanas como dados de demonstração (treinamento) e ver como um agente responde quando você intervém no meio do processo (avaliação interativa).

# 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

O LangSmith e o Langfuse são projetados para análise a posteriori de traces concluídos, não para interação em tempo real com agentes em execução.

Comparação pareada

Comparar duas saídas de agentes lado a lado é um padrão comum de avaliação, especialmente para testes A/B de versões de modelo ou comparação de arquiteturas de agentes.

O Potato oferece três modos de comparação:

• Lado a lado: ambos os traces visíveis simultaneamente, com rolagem sincronizada
• Sequencial: veja o trace A primeiro, depois o trace B, depois julgue
• Cego: os traces são rotulados aleatoriamente como "A" e "B", sem atribuição de modelo

annotation_schemes:
  - annotation_type: "pairwise"
    name: "comparison"
    mode: "side_by_side"  # or "sequential" or "blind"
    labels:
      - name: "A is better"
      - name: "B is better"
      - name: "Tie"
    criteria:
      - "Which agent completed the task more efficiently?"
      - "Which agent's output is higher quality?"

O LangSmith suporta comparação pareada básica por meio de sua "visão de comparação" em experimentos de avaliação. Você pode comparar execuções entre diferentes versões de modelo, mas a interface foi projetada para inspeção de execuções lado a lado, em vez de anotação estruturada de preferências.

O Langfuse não tem um recurso embutido de comparação pareada para anotação.

Quando usar cada ferramenta

Use o Potato quando:

• A anotação é o seu objetivo principal: você precisa de julgamentos humanos estruturados, não apenas de monitoramento
• Você precisa de suporte a agentes de codificação: renderização de diff, comentários inline, exibição de saída de terminal
• Você está coletando dados de treinamento de PRM: rótulos de correção por etapa com pontuações correntes
• Você precisa de auto-hospedagem: os dados ficam na sua infraestrutura, sem dependência de nuvem
• Você trabalha com múltiplos frameworks de agentes: 13 conversores de formato de trace versus dependência de um único framework
• Você precisa de esquemas de avaliação ricos: avaliação de trajetória, avaliação por rubrica, revisão de código, comparação pareada
• O orçamento é uma restrição: totalmente gratuito e de código aberto

Use o LangSmith quando:

• Você já usa LangChain/LangGraph: os traces fluem automaticamente, sem nenhuma configuração
• O monitoramento em produção é a sua necessidade principal: tracing em tempo real, acompanhamento de latência, monitoramento de custos
• A anotação é secundária: você precisa de pontuação e feedback básicos, não de esquemas de avaliação profundos
• Você quer um serviço gerenciado: nenhuma infraestrutura para manter
• Sua equipe é pequena: a camada gratuita pode ser suficiente para avaliação leve

Use o Langfuse quando:

• Você precisa de observabilidade de código aberto: monitoramento e tracing auto-hospedados
• Você usa vários provedores de LLM: boas integrações com OpenAI, Anthropic, LangChain, LlamaIndex
• A anotação não é o seu caso de uso principal: a pontuação está disponível, mas não é o foco
• Você quer gerenciamento de prompts junto com o tracing: o Langfuse reúne versionamento de prompts com observabilidade
• Você precisa de uma alternativa gratuita ao LangSmith para monitoramento: o núcleo de código aberto do Langfuse cobre a maioria das necessidades de monitoramento

A abordagem complementar: observabilidade + anotação

Para muitas equipes, o arranjo prático é executar uma ferramenta de observabilidade (LangSmith ou Langfuse) para o monitoramento em produção e o Potato para a avaliação humana detalhada. O fluxo de trabalho fica assim:

1. Instrumente o seu agente com o LangSmith ou o Langfuse para tracing em produção
2. Amostre os traces que precisam de revisão humana (falhas, casos extremos, amostras aleatórias)
3. Exporte esses traces da sua ferramenta de observabilidade
4. Converta e importe para o Potato usando os conversores embutidos
5. Faça a avaliação humana com os esquemas de anotação ricos do Potato
6. Retroalimente os resultados no seu ciclo de desenvolvimento

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

Isso te dá a visibilidade em tempo real de uma plataforma de observabilidade junto com a profundidade de anotação de uma ferramenta feita para anotação.

Resumo dos principais diferenciais

Entre as ferramentas gratuitas e auto-hospedadas, o Potato é a única que combina tudo isto:

• Renderização de diff de agentes de codificação com realce de sintaxe e comentários inline
• Coleta de dados para modelos de recompensa de processo (PRM) com rótulos de correção por etapa e de severidade
• Observação ao vivo de agentes de codificação com pausa, retomada e tomada de controle
• Conversão de trace em 13 formatos para agentes construídos com qualquer framework
• Taxonomias hierárquicas de erros com pontuações correntes ponderadas por severidade
• Três modos de comparação pareada (lado a lado, sequencial, cego)
• Avaliação por rubrica multicritério com dimensões e escalas configuráveis
• Revisão de código estilo PR do GitHub com comentários inline categorizados e vereditos

Não conhecemos outra ferramenta, de código aberto ou comercial, que reúna tudo isso. O LangSmith e o Langfuse são ferramentas de observabilidade fortes, mas não são ferramentas de anotação. O Label Studio e o Argilla são ferramentas de anotação genéricas, sem recursos específicos para agentes. A Scale AI oferece anotação gerenciada, mas custa dinheiro e não tem a auto-hospedagem e a personalização que as equipes de pesquisa costumam querer.

Se o seu objetivo é entender como e por que os seus agentes têm sucesso ou falham, e coletar os dados de treinamento para melhorá-los, o Potato cobre uma lacuna que os outros deixam aberta.

Caminhos de migração

Do LangSmith para o Potato (para anotação)

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

Do Langfuse para o Potato (para anotação)

# 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.convert_traces \
  --input langfuse_traces.json \
  --output data/traces.jsonl \
  --format langfuse
 
# 3. Start annotating
potato start config.yaml -p 8000

Do Label Studio ou do Argilla (para avaliação de agentes)

Se você usa atualmente o Label Studio ou o Argilla para anotação genérica e quer adicionar capacidades de avaliação de agentes, o Potato pode rodar junto com a sua ferramenta existente. Use o Label Studio ou o Argilla para as suas tarefas de anotação que não envolvem agentes (NER, classificação etc.) e o Potato para a avaliação específica de agentes que exige renderização de traces, anotação por etapa e revisão de código.

Conclusão

Escolher entre Potato, LangSmith e Langfuse não é uma questão de qual é o melhor no abstrato. Depende do que você precisa principalmente:

• Para monitorar agentes em produção, use o LangSmith ou o Langfuse.
• Para avaliar o comportamento de agentes com anotação humana estruturada, use o Potato.
• Se você precisa dos dois, execute-os juntos. Eles se complementam.

A pergunta a fazer é se o seu objetivo principal é observar o que os agentes fazem ou avaliar o quão bem eles o fazem. Se for avaliação, o Potato foi feito para isso.

Para uma comparação lado a lado mais completa, veja a documentação de comparação e o guia de avaliação de agentes.