Langfuse vs LangSmith vs MLflow: Two Are Observability Tools, One Is an ML Platform (2026)

Langfuse vs LangSmith vs MLflow: Two Are Observability Tools, One Is an ML Platform (2026)

Only two of the three tools in langfuse vs langsmith vs mlflow were built to watch LLMs. MLflow shipped in 2018 out of Databricks as experiment tracking for scikit-learn and XGBoost; GenAI tracing arrived on top of that base years later. Langfuse is MIT-licensed and LLM-native, LangSmith is proprietary and LangChain-native, MLflow is Apache-2.0 and older than both. Lineage, not feature checklists, decides this one. Verdict: Langfuse to own your data, LangSmith for LangGraph shops, MLflow if classical models share your platform.

Key Takeaways

• Langfuse if you want an MIT core you can self-host and own the trace data outright. Note its ee/ folders carry separate commercial terms, which is why GitHub reports the repo as NOASSERTION rather than MIT.
• LangSmith if your app is LangChain or LangGraph and you'll pay per seat for the tightest integration.
• MLflow if you also ship classical ML models and want experiments, model registry and tracing in one place.
• All three now speak OpenTelemetry, so running two of them at once is a real option.

Langfuse vs LangSmith vs MLflow at a Glance

Langfuse is the open-source pick, LangSmith is the LangChain-native pick, and MLflow is the pick when your team ships classical ML beside its LLM features. Two of these are LLM observability tools. The third is an ML platform that learned to trace LLMs, and that difference decides most of these evaluations.

New here? Read our AI observability primer first.

Retention numbers come from the vendors: Langfuse's 30/90-day/3-year tiers per its pricing page, LangSmith's 14-day base and 400-day extended traces per LangChain's pricing (extended is a separate trace type carrying an additional fee, not a retention toggle), and MLflow keeps data as long as your storage does.

Three named picks:

• Pick Langfuse if you want MIT-licensed code, day-one self-hosting, and trace data in your own Postgres and ClickHouse.
• Pick LangSmith if your stack is LangChain or LangGraph and per-seat pricing beats per-trace pricing.
• Pick MLflow if sklearn and XGBoost models run beside your LLM features. For the two-tool detail, see our full Langfuse vs LangSmith head-to-head.

Do You Need an LLM-Native Tool or an ML Platform?

The langfuse vs mlflow half of this query is really a lineage question. MLflow started as experiment tracking and a model registry for classical ML, then added LLM tracing. Langfuse started with LLM tracing and added nothing else. If you ship no classical models, MLflow's lifecycle machinery is surface area you maintain for nothing, and a dedicated AI observability tool is the shorter path.

MLflow is the oldest of the three by a wide margin: Apache-2.0 licensed, Linux Foundation governed, over 27,000 GitHub stars as of 5 August 2026, built to answer "which hyperparameters produced which artifact?" Its GenAI tracing arrived on top of that base. For a team shipping both an XGBoost churn model and a GPT-4o support agent, that buys one system of record: experiments, registry entries and LLM traces in the same database.

The counterweight: ship no classical models and none of that pays rent. MLflow's LLM-native UX is younger than Langfuse's, fewer shortcuts, rougher trace views.

One clarification, because autocomplete shows people searching kubeflow vs mlflow vs airflow: MLflow is not a workflow orchestrator. It does not schedule DAGs; it records what your runs did. Airflow and Kubeflow run jobs, MLflow tracks their output. On the layer question (mlflow vs tensorflow): TensorFlow is a modelling framework, MLflow sits above whatever framework you train with. Leanware's comparison, the only non-vendor editorial result on this SERP, makes the same split.

If your team never opens a Jupyter notebook, MLflow's biggest advantage is dead weight. That single test eliminates it for most readers of this page.

How Much Code Does Your First Trace Actually Take?

About two lines of Python for all three, but the friction lives in different places. Langfuse and LangSmith ask for account keys before your first trace lands; MLflow asks for a running tracking server. Fewest lines of code and least work are not the same thing.

We took the same task, one OpenAI chat call plus one helper, and instrumented it three ways from each vendor's quickstart, re-read 5 August 2026.

Langfuse, via the @observe decorator:

# pip install langfuse
import os
from langfuse import observe
from langfuse.openai import openai  # drop-in wrapper

os.environ["LANGFUSE_PUBLIC_KEY"] = "pk-lf-..."
os.environ["LANGFUSE_SECRET_KEY"] = "sk-lf-..."
os.environ["LANGFUSE_BASE_URL"] = "https://cloud.langfuse.com"

@observe()
def answer(question: str, context: str) -> str:
    r = openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": f"{context}\n\nQ: {question}"}],
    )
    return r.choices[0].message.content

LangSmith, via @traceable:

# pip install langsmith
import os
from langsmith import traceable
from openai import OpenAI

os.environ["LANGSMITH_TRACING"] = "true"
os.environ["LANGSMITH_API_KEY"] = "lsv2-..."
client = OpenAI()

@traceable
def answer(question: str, context: str) -> str:
    r = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": f"{context}\n\nQ: {question}"}],
    )
    return r.choices[0].message.content

MLflow, via mlflow.openai.autolog():

# pip install mlflow
import mlflow
from openai import OpenAI

mlflow.set_tracking_uri("http://localhost:5000")  # server must be running
mlflow.openai.autolog()

def answer(question: str, context: str) -> str:
    r = OpenAI().chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": f"{context}\n\nQ: {question}"}],
    )
    return r.choices[0].message.content

The counts we derived from those three quickstarts:

Counted from each vendor's quickstart, re-read 5 August 2026: Langfuse SDK docs, LangSmith observability quickstart, MLflow tracing quickstart. openai is the app's own dependency, not counted. Recount them yourself.

Our interpretation, labelled as such: the code is nearly identical across all three, so it is not where the decision lives. Langfuse and LangSmith front-load friction into five minutes of account creation. MLflow front-loads it into infrastructure: that one-liner assumes a tracking server, a database behind it, and someone to keep both alive. Its slim mlflow-tracing SDK, which MLflow says is about 95% smaller than the full package, trims the install, not the server.

LLM-as-a-Judge: Same Method, Three Different Homes

All three run LLM-as-a-judge evaluators over datasets, but LangSmith's eval engine is the most productized, Langfuse pairs managed judges with annotation queues and a GitHub Action for CI gating, and MLflow ties judges to its experiment and prompt-optimization tooling. The methodology is identical; the difference is where results live.

Per MLflow's evaluation docs, its judges run inside the same experiment-tracking system as your classical ML metrics, the payoff of the lineage argument above: one dashboard for a churn model and a support agent. Per Langfuse's docs, evaluators attach to traces and feed annotation queues your team works through in the UI.

For the method, read how to evaluate LLM outputs properly; for the wider landscape, the evaluation tools we rate. Agent pipelines need care beyond output scoring, covered in evaluating agents once they're live.

Prompt Management: Only One Versions Prompts Beside Models

Kept short on purpose, because the two-tool detail belongs to our sibling post. The shape of each: Langfuse offers prompt management with versioning, labels and a playground; LangSmith offers a prompt hub with commit-style versioning; MLflow offers a prompt registry storing prompts as first-class entities beside your models.

The one decision-relevant difference: MLflow versions prompts alongside model registry entries, so a prompt and the model it was tuned against share one system of record. Langfuse and LangSmith keep prompts separate from whatever serves your models. If you promote model and prompt together and want an audit trail proving which pairing shipped, that coupling beats any playground. For the deep two-tool detail, see our full Langfuse vs LangSmith head-to-head.

Self-Hosting, Data Ownership and What It Costs to Leave

Langfuse self-hosts as a multi-service stack you fully control, MLflow as a tracking server plus a database you can SQL-query directly, LangSmith only on enterprise terms. The exit question matters more than the entry question: whichever tool you pick, the trace history is the part you cannot re-create.

Deployment reality per tool. Langfuse runs as web, worker, Postgres, ClickHouse and a cache/blob layer since its ClickHouse-era redesign, per Langfuse's scale-engineering post. Context you should have straight: ClickHouse acquired Langfuse on 2026-01-16 alongside a $400M Series D, and both committed that the MIT licence, first-class self-hosting and the roadmap stay unchanged (Langfuse's statement). LangSmith self-hosting is an enterprise-plan concern, per its docs. MLflow is a tracking server, a Postgres-compatible database and object storage.

Exit paths, the section nobody else writes. Langfuse exports to blob storage as JSONL or Parquet via a documented S3 export, plus a full API. MLflow's backend is an open database you can query directly. LangSmith's bulk export sits behind paid plans. The verdict: MLflow's lock-in is the most recoverable, Langfuse close behind, LangSmith below enterprise is where a wrong pick costs you your history.

SSO and RBAC gate Langfuse's Enterprise tier ($2,499/mo) and LangSmith's Enterprise plan; with MLflow you wire your own auth, freedom and work in equal measure.

What Does Each One Cost at 100K, 1M and 10M Traces?

Langfuse meters units, MLflow meters nothing, and LangSmith no longer publishes a comparable unit price at all. Units and traces are not the same object; one user request can be a single trace containing many billable events. Only two of the three columns below can be built from list prices.

That last point is a finding, not a gap in our research. As of 5 August 2026, LangChain's pricing page puts Plus at $39 per seat with 10K base traces included, then meters usage at $1.50 per LCU (compute) and $1.00 per LSU (storage). There is no per-1K-trace rate on the page any more, and no second page carrying one. A LangSmith bill at a stated trace volume is therefore not derivable from list prices, and we are not going to invent a conversion.

Langfuse figures are list prices from its pricing page, read 5 August 2026, times the volume shown. LangSmith's seat price and retention tiers come from the same-day read of LangChain's pricing: base traces at 14-day retention, extended traces at 400 days for an additional fee the page does not quantify. The MLflow column is our estimate, not a vendor quote: managed Postgres ($15-25/mo), object storage and one always-on container ($10-20/mo), growing with stored history.

Check our maths where there is maths to check. Langfuse publishes a graduated overage schedule: $8.00 per 100K units from 100K to 1M, $7.00 from 1M to 10M, $6.50 from 10M to 50M, $6.00 above that. At 1M: $29 plus 900K units at $8 per 100K = $101. At 10M: $29, plus 900K at $8 ($72), plus 9,000K at $7 ($630) = $731.

Note the shape difference: LangSmith bills people plus metered consumption, the other two do not. If your real problem is token spend, a LiteLLM proxy in front of your models cuts the bill before any of these tools meter it.

Can You Run Two of Them Together?

Yes. Langfuse and MLflow both build on OpenTelemetry, so one collector can fan the same GenAI spans to two backends. The realistic pairing: MLflow as the model-lifecycle system of record, Langfuse as the LLM-native trace UX. Technically easy; organisationally, someone has to own the collector.

The mechanism: an OTel collector with two OTLP exporters, using the GenAI semantic conventions so both sides parse spans the same way.

# Illustrative sketch, not a copy-paste-complete collector config
exporters:
  otlp/langfuse:
    endpoint: https://cloud.langfuse.com/api/public/otel:443
    headers:
      Authorization: "Basic <base64 public_key:secret_key>"
  otlp/mlflow:
    endpoint: http://localhost:5000/otel  # your MLflow tracking server

service:
  pipelines:
    traces:
      receivers: [otlp]
      processors: [batch]
      exporters: [otlp/langfuse, otlp/mlflow]  # same spans, two backends

Label this clearly: the arrangement above is our architectural interpretation, not a vendor-supported configuration. Leanware is the only other page on this SERP that mentions running two tools at all, in one paragraph. Dual-shipping means two systems, two bills, duplicated storage, and a collector that pages someone at 3am.

Dual-shipping traces is technically easy and organisationally expensive. The second backend is free until someone has to keep it alive.

Langfuse vs LangSmith vs MLflow: Who Should Pick Which?

The langfuse vs langsmith vs mlflow pros and cons collapse into six profiles. Every row names one tool, because "it depends" without a pick is useless.

If your honest answer is "none of these three," the other seven tools in the ten platforms we ranked include hosted and enterprise-only options we kept off this page.

Frequently Asked Questions

Why use MLflow for LLM tracing?

Use MLflow for LLM tracing when your team already ships classical ML models and wants one system of record: experiment tracking, a model registry and GenAI tracing in a single Apache-2.0 platform, with no per-trace fee. If you ship LLM features only, Langfuse or LangSmith give you a younger, LLM-first experience.

Can you use LangSmith and MLflow together?

Yes. Both accept OpenTelemetry-compatible trace data, so an OTel collector can export the same spans to LangSmith and an MLflow tracking server at once. The cost is operational: two backends, two bills, duplicated storage. Most teams we talk to pick one system of record and skip the second.

Is LangSmith open source?

No. LangSmith is proprietary, closed-source software from LangChain Inc. The LangSmith client SDK is open, but the platform, UI and backend are not. If an open-source licence matters to you, Langfuse (MIT) and MLflow (Apache 2.0) are the two options in this comparison you can self-host freely.

Is MLflow only for classical machine learning?

No. MLflow added first-class GenAI support: mlflow.openai.autolog() traces OpenAI calls automatically, @mlflow.trace covers custom functions, and built-in judges evaluate LLM outputs. The classical-ML heritage shows in the UX, which is less LLM-native than Langfuse's, but the tracing itself is production-grade.

Is MLflow a workflow orchestrator like Airflow or Kubeflow?

No. MLflow does not schedule DAGs or run pipelines; it records what your runs did: parameters, metrics, artifacts and traces. Airflow and Kubeflow orchestrate jobs, MLflow tracks their results. People confuse the three because they co-occur in MLOps stacks, but they sit at different layers and often run together.

What are the open-source alternatives to LangSmith and MLflow?

Langfuse (MIT) is the closest open-source LangSmith alternative, with self-hosting and OTel-native tracing, and MLflow itself is open source under Apache 2.0. Beyond this comparison, Lunary, Arize Phoenix and OpenLIT are open-source LLM observability options worth a look before you commit to a proprietary platform.

Which of the three is cheapest at 10 million traces a month?

MLflow, counting infrastructure only: our estimate is $150-400 per month for Postgres, object storage and a container. Langfuse Cloud lands at $731 for 10M units on Core plus its graduated overage. LangSmith cannot be priced from its page: since mid-2026 LangChain publishes seat and LCU/LSU rates, not a per-trace list price.

Does Langfuse replace MLflow, or the other way round?

Neither replaces the other cleanly. Langfuse replaces MLflow's tracing and eval layers for LLM-only teams and drops the experiment-tracking and model-registry machinery. MLflow replaces Langfuse when classical ML models share your platform and one system of record beats two. They overlap on tracing; they diverge on everything around it.

Is Langfuse still open source now that ClickHouse has acquired it?

Yes, as of the 2026-01-16 announcement. ClickHouse acquired Langfuse alongside a $400M Series D, and both companies publicly committed to keeping the MIT licence, first-class self-hosting and an unchanged roadmap. That is a public commitment, not a permanent legal guarantee, but today nothing about the self-hosted story has changed.

Sources

Every source below is editorial and dofollow; none is paid or exchanged.

If You Only Remember Three Things

• Two of the three were built for LLMs. MLflow was built in 2018 for classical ML and learned tracing later.
• Langfuse if you want MIT-licensed, self-hosted trace data you own outright. LangSmith if your app is LangChain or LangGraph. MLflow if classical ML models share your platform.
• Ask the exit question first: Langfuse exports to S3, MLflow's database is yours to query, LangSmith's bulk export sits behind paid plans.
• At 10M events a month: $731 on Langfuse Cloud list price and $150-400 of infrastructure on MLflow (our estimate). LangSmith has no comparable figure since it stopped publishing a per-trace rate.

The verdict, restated: pick on lineage, not features. Want a second opinion on which fits your stack, or help wiring it up? Talk to Techsy. We pick these tools for client agent deployments, happy to tell you which one and why.