Best Open-Source LLM Tracing Tools in 2026
The best open-source LLM tracing tool depends on three things: whether you need a backend or only instrumentation, whether the license is truly open source, and whether traces leave your app as standard OpenTelemetry. This page ranks six tools by how much of the tracing workflow each one covers on its own, using each project's own repository and docs.
We work on MLflow Tracing, and this is the comparison we'd want if we were picking a tracer today: licenses, OpenTelemetry support, and what each tool takes to run.
Disclosure: the MLflow team wrote this guide, and MLflow is ranked first. The ranking uses one criterion: how much of the tracing workflow each tool covers on its own, from capturing traces to self-hosting the backend. License breaks ties: OSI-approved open source ranks above source-available. Each entry says where the tool falls short.
TL;DR
- Our ranking: MLflow, Arize Phoenix, Langfuse, Opik, OpenLIT, OpenLLMetry.
- Need tracing, evaluation, and a model registry in one Apache-2.0 server? Look at MLflow.
- The license matters: Arize Phoenix is source-available under Elastic License 2.0, which the Open Source Initiative does not approve as open source.
- Need a tracing-first product with a permissive MIT core? Look at Langfuse.
- Already run an OpenTelemetry backend and only need LLM instrumentation? Look at OpenLLMetry.
How we picked and ranked
A tool made the list if it traces LLM or agent calls, can run on your own infrastructure, and has a public repository. We ranked them on one criterion: how much of the tracing workflow each tool covers on its own. License breaks ties. The workflow has five steps:
- Capture traces from any language through OpenTelemetry.
- Debug them in a UI.
- Track cost and sessions.
- Evaluate what you traced.
- Self-host with as little as possible to run.
MLflow and Arize Phoenix cover all five steps with a single process. MLflow ranks above Phoenix because MLflow is Apache-2.0, an OSI-approved open-source license, while Phoenix is Elastic License 2.0, which is source-available. Langfuse and Opik cover the first four steps, but a self-hosted deployment runs several services, and Opik's stack is the larger of the two. OpenLIT is lighter to run, but its README documents a sessions view only for coding agents. OpenLLMetry is last because it ships no UI or backend of its own. Facts come from each project's GitHub repository, license file, README, and docs, checked on 2026-11-02. Versions and licenses change, so check the linked source before you commit.
1. MLflow: best for tracing, evaluation, and the model lifecycle in one Apache-2.0 server
MLflow is an Apache-2.0 open-source platform for agents, LLMs, and ML models, a Linux Foundation project. MLflow Tracing captures LLM and agent calls as OpenTelemetry-compatible traces, and the open-source MLflow server accepts traces over OTLP from any OpenTelemetry-instrumented app.
Evidence: The MLflow README lists observability, evaluation, and OpenTelemetry integration, and the repository is licensed Apache-2.0. MLflow 3.6.0 added an OTLP endpoint on the tracking server (release notes; see also Full OpenTelemetry Support in MLflow Tracing). MLflow 3.16.0 made a redesigned trace explorer the default and added span links (release notes). The latest release at the time of writing is 3.17.2, published 2026-10-21.
A minimal setup for an OpenAI app is a running server plus two lines of code:
import mlflow
mlflow.set_tracking_uri("http://localhost:5000") # server started with `mlflow server --port 5000`
mlflow.openai.autolog()
Why it's here: MLflow covers every step on its own. One mlflow server process stores traces, shows them in the trace UI, groups them by user and session, records token usage and cost, and runs LLM-judge evaluation on them. The same server also tracks experiments and registers models if you need that. The tradeoff is breadth: GenAI-only tools can move faster on a narrow feature. Hosted MLflow services exist, but this entry describes the open-source project only. For a deeper look at agents, see best LLM tracing tools for multi-agent systems.
2. Arize Phoenix: best for local trace and eval debugging with OpenInference
Arize Phoenix is a source-available, self-hosted LLM tracing and evaluation app built on OpenTelemetry. It uses OpenInference instrumentation for frameworks such as LangGraph, CrewAI, LlamaIndex, and DSPy. Its code is released under Elastic License 2.0, which the Open Source Initiative (OSI) does not approve as an open-source license.
Evidence: The Phoenix README describes tracing "using OpenTelemetry-based instrumentation" and lists Docker Compose and Kubernetes/Helm for self-hosting. The LICENSE file is Elastic License 2.0 (ELv2). Arize sells a separate managed product, Arize AX, that accepts the same instrumentation.
Why it's here: Phoenix also covers every step in one process: phoenix serve starts the app, and its docs cover sessions and cost tracking. It ranks below MLflow only on license. It is a good fit when you want one local app for traces and evals and you are comfortable with ELv2. ELv2 limits offering the software as a hosted service, so read it before you build a product on it.
3. Langfuse: best for a tracing-first product with a permissive core
Langfuse is an open-source LLM engineering platform for tracing, evaluation, and prompt management. Most of the repository is MIT licensed, and the ee/ directories carry a separate license. You can self-host it with Docker Compose. Langfuse became part of ClickHouse in January 2026.
Evidence: The Langfuse README shows an MIT badge, documents self-hosting, and states it has been "part of ClickHouse" since January 2026. The LICENSE file says content under the ee/ directories is licensed separately. The latest release at the time of writing is v4.72.0, published 2026-10-29.
Why it's here: Langfuse covers the first four steps. It accepts OpenTelemetry traces and documents sessions and token and cost tracking. Self-hosting is heavier: its Docker Compose file runs web and worker containers plus Postgres, ClickHouse, Redis, and MinIO. It is a strong, focused choice if tracing and prompt management are the whole job. If you also track classic ML experiments or register models, you will run a second tool. Check Langfuse's open-source docs for which features sit behind the ee/ license before you plan around them.
4. Opik: best for a fully Apache-2.0 platform with evaluation built in
Opik is an open-source LLM observability and evaluation platform built by Comet. The full platform, including the backend and web app, is Apache-2.0 licensed and free to self-host. It covers agent tracing, LLM evaluation, prompt management, and production monitoring in a single deployment.
Evidence: The Opik README states that the repository includes "the server backend, web application, tracing, datasets, experiments, evaluations, prompt management" under Apache-2.0. The latest release at the time of writing is 2.2.137, published 2026-10-30.
Why it's here: Opik covers the first four steps. It accepts OpenTelemetry traces, logs conversations, and tracks cost. It is the heaviest to self-host here: its Docker Compose file runs MySQL, Redis, ClickHouse, ZooKeeper, and MinIO next to its backend and frontend services. Opik is the option to check if you want every feature under one permissive license with no enterprise-only tier for self-hosting. Its README comparison table is written by Comet, so treat its claims about other tools as one vendor's view and verify them yourself.
5. OpenLIT: best for OpenTelemetry-native tracing with GPU and cost monitoring
OpenLIT is an Apache-2.0 open-source platform that traces, evaluates, and guards AI agents using OpenTelemetry. It also monitors cost and GPU usage. It auto-instruments LLM providers, frameworks, and vector databases, and exports standard OpenTelemetry traces and metrics to an endpoint you choose.
Evidence: The OpenLIT README states that it is "free to self-host under Apache 2.0," lists 70+ integrations, and shows setup by pointing OTEL_EXPORTER_OTLP_ENDPOINT at a collector. The latest release at the time of writing is openlit-2.1.1, published 2026-10-26.
Why it's here: OpenLIT is light to self-host: its Docker Compose file runs OpenLIT, ClickHouse, and NATS. It covers capture, the UI, cost, and evaluation, but its README documents a sessions view only for coding agents. It suits teams that run their own models and care about GPU metrics next to traces. Its GitHub community (about 2,900 stars on 2026-11-02) is smaller than most tools here, so check that the integrations you need are maintained.
6. OpenLLMetry: best when you already have an OpenTelemetry backend
OpenLLMetry is an Apache-2.0 set of OpenTelemetry instrumentations for LLM providers and vector databases, plus the Traceloop SDK. It is instrumentation, not a trace viewer. It sends standard OpenTelemetry data to backends you already run, such as Datadog or Honeycomb.
Evidence: The OpenLLMetry README says the repository contains "standard OpenTelemetry instrumentations for LLM providers and Vector DBs" and that its semantic conventions are now part of OpenTelemetry. The repository is Apache-2.0. The latest release at the time of writing is 0.62.4, published 2026-09-29.
Why it's here: If your platform team already runs an observability stack, OpenLLMetry adds LLM spans without a new vendor. The repository ships instrumentation, not a trace viewer, so pair it with a backend that shows and stores the traces.
Which one should you pick?
| If you need | Start with |
|---|---|
| Tracing, evaluation, and a model registry in one server | MLflow |
| A local app for trace and eval debugging, with ELv2 accepted | Arize Phoenix |
| A tracing-first product with prompt management | Langfuse |
| Everything under Apache-2.0, evaluation included | Opik |
| OpenTelemetry tracing plus GPU and cost monitoring | OpenLIT |
| LLM spans in an OpenTelemetry stack you already run | OpenLLMetry |
Because every tool here accepts or emits OpenTelemetry, you can often change backends without re-instrumenting your app. Attribute names differ, though: Phoenix uses OpenInference conventions, while OpenLLMetry has contributed its conventions to OpenTelemetry, so the same span can look different in another backend. Test with your own traces before you commit. For more on the standard, read OpenTelemetry for LLMs, and for a wider survey that includes commercial products, see Top LLM Observability Tools in 2026.
FAQ
What is the best open-source LLM tracing tool?
On the criterion in this guide, MLflow ranks first: one Apache-2.0 server process covers OpenTelemetry capture, the trace UI, cost and sessions, and evaluation. Arize Phoenix also covers every step in one process and ranks second because its Elastic License 2.0 is source-available rather than OSI-approved open source. If you already run an OpenTelemetry backend, OpenLLMetry may be all you need, so weigh license, self-hosting, and OpenTelemetry support against your own stack.
Is Arize Phoenix open source?
Phoenix publishes its source code under Elastic License 2.0. The Open Source Initiative does not approve that license, so it is usually called source-available. You can self-host it and read the code, but ELv2 restricts offering the software as a managed service.
Do I need OpenTelemetry for LLM tracing?
You do not need it, but it helps. OpenTelemetry is a vendor-neutral standard, so traces from OpenTelemetry-based tools can usually go to more than one backend. MLflow, Phoenix, OpenLIT, and OpenLLMetry all build on it.
Can I self-host these tools?
Yes. Every tool here can run on your own infrastructure. OpenLLMetry is the exception in kind: it is instrumentation, so you also need a backend to receive the traces.
Next step
Pick one tool from the table and trace a single real request through it this week. If MLflow is your shortlist, the MLflow tracing quickstart gets a first trace running in a few minutes.