latitude vs langfuse

What Each Product Actually Is

Latitude V2, released in June 2026 by Latitude Data S.L. in Barcelona, traces sessions, tools, memory and cost over OpenTelemetry with about 40 integrations. Evaluations are rule conditions, an LLM judge or custom JavaScript, and can be generated from Signals; an alignment check measures how often an evaluation agrees with human annotations. Human annotation and "Flaggers", datasets built from real traces, and monitors in-app, by email and in Slack complete the loop. Agent Dispatch, added in July 2026, sends Claude Code or Cursor to open pull requests that fix what the evaluations found.

The product has moved a lot, and it is fair to state that as history: data apps, then a prompt playground, then Latitude Agents, then V2 as agent observability only. V2 removed the prompt gateway, triggers and hosted tools. V1 keeps running for existing customers, but new features ship only to V2, and PromptL and prompt management are V1 features.

Langfuse covers tracing (its SDK is a thin layer over the OpenTelemetry client, and the server accepts OTLP), prompt management with versions and labels, evaluation (LLM-as-a-judge, code evaluators, user feedback, manual labels and custom pipelines over the API), datasets for experiments, a playground, and threshold alerts to Slack, webhooks or GitHub Actions. Its README says it has been part of ClickHouse since January 2026.

Both trace, both judge, both are MIT. The difference is what each does after a failure is found. Latitude pushes toward an automated fix; Langfuse gives you the prompts, datasets and experiments to make the fix yourself.

Side by Side

Neither blocks, and both say so. Latitude's evaluations score sessions after they complete and never block or change a response; its "guardrails" limit what Agent Dispatch may do, not live traffic. Langfuse's evaluators run asynchronously and do not interrupt the application, and its security docs leave run-time protection to separate libraries.

Where Latitude Is Stronger

• Failures become pull requests. Agent Dispatch hands a finding to Claude Code or Cursor, which opens a fix PR. Langfuse can trigger a GitHub Action from an alert, but the fix is yours to write.
• Judges checked against humans. The alignment check measures how often an evaluation agrees with human annotations, which is the number that tells you whether to trust the judge at all.
• Signals to evaluations. Evaluations can be generated from Signals rather than written from scratch.
• Seats are not the meter. Every plan, including the free Starter tier, has unlimited seats; Langfuse Hobby allows two users.
• One license, one image set. The whole platform is MIT, and every self-host option "deploys the same images with the same configurable values".

Latitude's cloud runs in AWS eu-central-1. That suits teams that want EU data residency without self-hosting; teams that need another region self-host or talk to sales about Enterprise custom cloud and on-premises deployment.

Where Langfuse Is Stronger

• Prompt management. Versioned prompts with labels, cached client-side by the SDK, linked to traces so scores can be compared by prompt version, and editable without a deploy. Latitude V2 does not have it.
• A larger project. About 34,600 GitHub stars against roughly 4,600, backing from ClickHouse, and integrations with LangChain, LlamaIndex, the OpenAI SDK, the Vercel AI SDK and more.
• A lighter self-host stack. Postgres, ClickHouse, Redis or Valkey and object storage, plus Terraform templates for AWS, Azure and GCP. Latitude adds Temporal and pgvector to a similar set.
• Alerts with a delivery choice. Threshold alerts on observations and on numeric, categorical or boolean scores, with warning and alert levels, sent to Slack, a webhook or GitHub Actions.
• A cheaper first paid step. Core is $29 a month with unlimited users and 90 days of data; Latitude Pro is $99.

Community size is not the whole comparison. Latitude's unlimited seats favour organisations where product, support and engineering all read traces, while Langfuse's two-user Hobby tier moves a growing team onto Core sooner. And Latitude's MIT licence covers the whole platform, where a handful of Langfuse features - instance management, audit logs, project-level RBAC on self-host - sit with the enterprise licence. Count who needs a login and which admin features your security team will ask for before you decide.

Latitude's Langfuse Import

Latitude publishes an import from Langfuse, alongside imports from LangSmith and Braintrust. Per its docs, you give Latitude a Langfuse public key (pk-lf-...) and secret key (sk-lf-...), choose a time range and a trace limit, and sessions, users, tags, metadata, messages, tool calls, token usage and cost map directly; prompt references (promptName, promptVersion) land in span metadata. The docs add: "Importing only reads from Langfuse. Nothing is changed or deleted at the source."

Read that neutrally. It is a vendor making it easy to try its product on data you already have, which is useful, and it says nothing about which product is better. It also shows what does not travel: evaluators, datasets and alert rules are not in the documented list, and prompts arrive as references in metadata rather than as managed prompts, which fits a V2 that has no prompt management. A trial import costs little; a full move means rebuilding the judges and re-checking them against human labels.

One Failure, Both Platforms

A sales-assistant agent sometimes promises discounts it is not allowed to offer. Nothing errors; the conversation reads well; the promise is simply wrong.

1. Latitude: signal, aligned judge, dispatched fix

   A Signal describing "offers a discount outside the approved list" generates an evaluation, an LLM judge over completed sessions. Reviewers annotate a sample, and the alignment check tells you how often the judge agrees with them. A monitor posts to Slack when the rate rises, and Agent Dispatch sends Claude Code or Cursor to open a pull request that tightens the prompt or the tool.

2. Langfuse: evaluator, alert, prompt version

   An LLM-as-a-judge evaluator with your own prompt runs on matching observations, sampled, and annotation queues let reviewers label a batch. A score alert goes to Slack or a webhook past a threshold. You edit the prompt in prompt management, test it in an experiment against a dataset of the bad sessions, and promote the new version by label, with no deploy.

3. The next bad promise

   Both platforms score it after the conversation ends. Latitude's route to the fix is a PR written by a coding agent and reviewed by you; Langfuse's is a prompt version you write and promote yourself.

Which route is faster depends on where the fix lives. If it is in code or tool definitions, a dispatched PR saves time. If it is in a prompt that product people edit, managed prompts with labels save more.

Pricing and Buying

Only one side of this can be turned into a bill. At 10,000 sessions a month of 1 trace, 20 observations and 2 scores each, Langfuse Core meters 230,000 units: $29 + 1.3 × $8 = $39.40 a month, assuming pro rata overage. Latitude's pricing page does not say what a credit measures, so the same 10,000 sessions might fit inside the free 20K credits or need Pro plus extra credits; ask before you estimate.

Self-hosted, both are free and the bill is your infrastructure and your time. Latitude needs Postgres with pgvector, ClickHouse, Redis, Temporal and an object store, deployable with Docker Compose on one host, Helm on Kubernetes, or Railway. Langfuse needs Postgres, ClickHouse, Redis or Valkey and S3-compatible storage, with Docker Compose for testing and Helm or Terraform for production.