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.

¹ Os "Agent Graphs" (beta) do Langfuse renderizam uma execução multiagentes como um grafo, mas como uma visualização de depuração somente leitura — não há forma documentada de um anotador marcar o caminho crítico ou sinalizar arestas nele. ² A Scale AI anota trajetórias de GUI/uso de computador como um engajamento de dados gerenciado (por exemplo, seu trabalho CUA-Suite no CVAT), não como um recurso self-service que você configura. ³ O "Voice Showdown" da Scale é baseado em turnos; a pontuação de barge-in/sobreposição full-duplex está listada como planejada, ainda não disponível (em 2026-03-20).

Comparação observada em 2026-06-24 contra LangSmith (docs.langchain.com), Langfuse (núcleo MIT, lançamento contínuo), Label Studio 1.23.0, Argilla 2.8.0 e páginas de produto da Scale AI. Essas ferramentas evoluem rápido — se algo aqui estiver desatualizado, correções são bem-vindas no repositório do GitHub.

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), e suas score configs categóricas permitem que você defina um conjunto fixo de rótulos — uma taxonomia de erros utilizável — e anexe várias pontuações nomeadas ao mesmo span. O que ele não oferece como esquema de primeira classe é uma taxonomia hierárquica ou uma pontuação corrente ponderada por severidade que se acumula ao longo das etapas; você monta isso por conta própria a partir de score configs planas.

Então a versão honesta da diferença é mais estreita do que costumava ser: o Langfuse e o Label Studio (que agora importa traces de LangGraph/CrewAI/AutoGen para revisão por etapa) ambos fazem pontuação estruturada por etapa. Onde o Potato continua sendo feito sob medida é na combinação — uma taxonomia hierárquica de erros mais pesos de severidade mais uma pontuação corrente em um único esquema trajectory_eval — que é o que você quer para construir dados de treinamento de PRM ou identificar onde um agente começa a errar.

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

Duas dessas superfícies são onde a afirmação é mais forte. De cada ferramenta que pesquisamos (comercial e de código aberto), o Potato é a única que oferece superfícies configuráveis pelo anotador para estrutura de equipes multiagentes e revisão de agentes multimodais:

• Um grafo de interação multiagentes editável pelo anotador e clicável — marque o caminho crítico, sinalize o handoff ruim. O mais próximo disso em outros lugares, os "Agent Graphs" do Langfuse, é uma visualização de depuração somente leitura.
• Atribuição de falhas entre agentes, revisão de handoff como um objeto de primeira classe, scorecards por agente e por equipe, uma linha do tempo de contenção de ferramentas e marcação de comportamento emergente — nenhum dos quais as outras ferramentas oferecem como construtos de anotação embutidos.
• Trajetórias de uso de computador com ancoragem de cliques, linhas do tempo de voz full-duplex com pontuação de barge-in e ancoragem temporal de vídeo com IoU ao vivo. A Scale AI faz ancoragem de GUI e avaliação de voz, mas como engajamentos de conjuntos de dados gerenciados, e sua arena de voz ainda é baseada em turnos.

Além disso, o Potato continua sendo a única ferramenta gratuita e auto-hospedada que combina renderização de diff de agentes de codificação com comentários inline, coleta de dados para PRM, observação ao vivo com pausa/retomada/tomada de controle, ingestão de traces de qualquer framework, uma taxonomia hierárquica de erros com uma pontuação corrente ponderada por severidade, três modos de comparação pareada e revisão de código estilo PR.

Não conhecemos outra ferramenta, de código aberto ou comercial, que reúna tudo isso — verificado contra LangSmith, Langfuse, Labelbox, Scale AI, Label Studio, Argilla e Braintrust em 2026-06-24 (veja a nota de rodapé datada sob a tabela de comparação). O LangSmith e o Langfuse são ferramentas de observabilidade fortes, cujos recursos de anotação são pontuações no escopo do span, não superfícies de estrutura de agentes. O Label Studio e o Argilla são ferramentas de anotação genéricas; o Label Studio acrescentou importação de traces, mas nenhum dos dois oferece as superfícies multiagentes ou de agentes multimodais acima. O Labelbox e a Scale oferecem produtos de dados de avaliação de agentes, mas como serviços pagos, em nuvem ou gerenciados, em vez de uma ferramenta auto-hospedada que uma equipe de pesquisa pode executar e personalizar.

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.