Last updated October 13, 2026. Licenses, GitHub stars, self-host docs, OpenTelemetry support, and commercial pricing were checked against each project’s repository, documentation, and pricing pages on that date.
Most LLM observability guides mix hosted SaaS with open source, then bury the self-host path in a footnote. If your traces carry prompts, tool args, and customer text, that mix is the wrong shortlist.
The 8 best open source LLM observability tools you can self-host in 2026 are Langfuse, Opik, Arize Phoenix, Helicone, LangWatch, Agenta, Laminar, and OpenLIT. This guide is the self-host spoke of our AgentOps tools map and pairs with our broader AI agent observability tools roundup, which owns the commercial and hybrid view.
We ranked tools that publish an OSI-approved or clearly source-available license, a documented Docker or Kubernetes install, and a product UI for traces or sessions. No vendor paid for placement or reviewed this page, per our editorial standards and disclosure policy.
Self-hosting is free on the license for every tool on this list; you pay for compute, storage, and the optional managed cloud if you want someone else on call. The real differences are license shape, OpenTelemetry depth, evals overlap, and how much ops work a production deploy needs.
TL;DR
- Langfuse is the default full-stack pick: MIT core, about 35.7k GitHub stars on October 13, 2026, Docker Compose in minutes, and Helm or Terraform for production.
- Opik (Comet) is the cleanest Apache 2.0 platform: same codebase as cloud, free self-host of tracing plus evals, Pro Cloud from $19 per month.
- Arize Phoenix is free to self-host and OpenTelemetry-native, but ships under Elastic License 2.0, which is source-available rather than OSI-open.
- Helicone fits gateway-first teams that want request, cost, and session monitoring behind their own firewall under Apache 2.0.
- LangWatch, Agenta, Laminar, and OpenLIT cover agent simulations, agent workspaces, agent-native tracing, and OTel plus GPU monitoring respectively.
- On a 500k-span month, a single-node self-host often lands near $45 to $90 in infra, while Langfuse Cloud Core and Opik Pro Cloud land near $69 and $44 on published list prices.
The 8 Best Open Source LLM Observability Tools at a Glance
The table below is the shortlist view. Stars are from each public GitHub repository on October 13, 2026. “Self-host” means a documented Docker Compose or Kubernetes path for the full product UI, rather than only an SDK.
| Tool | License | GitHub stars (Oct 13, 2026) | Self-host path | OTel / OTLP | Evals overlap | Cloud entry | Best for |
|---|---|---|---|---|---|---|---|
| Langfuse | MIT core; EE folders commercial | 35.7k | Docker, Helm, Terraform | Native OTLP ingest | Datasets, judges, experiments | Hobby free; Core $29/mo | Full AgentOps on your servers |
| Opik (Comet) | Apache 2.0 | 22.5k | Docker, Kubernetes | Native OTel | Test suites, online rules, optimizer | Free Cloud; Pro $19/mo | Permissive license + evals |
| Arize Phoenix | Elastic License 2.0 | 11.8k | Docker, Helm | OpenInference / OTel | Pre-built LLM and tool evals | Free OSS; AX Pro $50/mo | Light OTel-first self-host |
| Helicone | Apache 2.0 | 6.2k | Docker, Helm | Via OpenLLMetry / gateway | Evals and experiments | Hobby free; Pro $79/mo | AI gateway + cost analytics |
| LangWatch | Apache 2.0 open-core | 4.9k | Docker Compose | OTel support | Simulations, online monitors | Developer free; Growth €29/seat | Agent sims + observability |
| Agenta | MIT core; EE commercial | 4.8k | Docker Compose (OSS) | Run logs / SDK | Evaluations and versioning | Hobby free; Starter $29/mo | Self-hosted agent workspace |
| Laminar | Apache 2.0 | 3.4k | Docker Compose, Helm | OTel-native SDK | Events, datasets, SQL | Free; paid cloud tiers | Agent-native tracing |
| OpenLIT | Apache 2.0 | 2.8k | Docker, Helm | OTel-native end to end | Evals, guardrails, prompt hub | OSS free; Cloud soon | OTel + GPU + coding agents |
Decision kernel: choose Langfuse when you want one MIT-licensed AgentOps platform, Opik when Apache 2.0 and evals matter most, Phoenix when you already speak OpenTelemetry and accept ELv2, and Helicone when a gateway should own request and cost logs. Add LangWatch for simulations, Laminar for agent-first tracing, OpenLIT for GPU and OTel export, and Agenta when the workspace itself is the product.
Verdict: Langfuse and Opik cover most self-host shortlists. Phoenix stays on the list because teams already run it widely, with the ELv2 caveat stated up front. For the hosted-only view of Langfuse versus LangSmith versus Braintrust, see our three-way comparison.
What Counts as Open Source LLM Observability You Can Self-Host?
Open source LLM observability means a product that records traces, spans, sessions, costs, or scores for LLM and agent runs, ships under a public license you can read, and runs the control plane on infrastructure you control. Self-hostable means Docker Compose or Kubernetes docs that stand up the UI and storage without an Enterprise-only binary.
We excluded tools that only open an SDK while the server stays proprietary, and tools whose self-host path requires a paid Enterprise license for the core UI. Lunary’s public docs, for example, tie Docker and Kubernetes installs to Enterprise Edition. LangSmith self-hosting is an Enterprise add-on, so it appears under Left Off rather than in the ranked eight.
License shapes you will actually see
- OSI-approved permissive (MIT, Apache 2.0): Opik, Helicone, Laminar, OpenLIT, and LangWatch’s Apache core. Fork, modify, and redistribute under the license terms.
- Open-core (MIT or Apache core + commercial ee/): Langfuse and Agenta. Core platform features run without a license key; project RBAC, audit logs, or similar extras need a commercial key.
- Source-available (Elastic License 2.0): Arize Phoenix. Free to self-host for your own use; you may not offer Phoenix as a hosted service to third parties.
OpenTelemetry is the portability layer
Every serious shortlist in 2026 should start from OpenTelemetry and OTLP. If your app already emits OTLP, you can point the same spans at Langfuse, Phoenix, Opik, Laminar, or OpenLIT and change backends without rewriting instrumentation. Helicone often sits in front as a gateway and can still feed OpenTelemetry-compatible pipelines through OpenLLMetry-style exporters.
# Not executed here: point an OTLP exporter at a self-hosted collector
export OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4317
export OTEL_EXPORTER_OTLP_PROTOCOL=grpc
# Then configure the collector to forward GenAI spans to Langfuse, Phoenix, Opik, or OpenLIT.Treat the snippet as a pattern, not a tested install. Each vendor’s docs name the exact auth headers, ports, and semantic conventions (OpenInference for Phoenix, Langfuse’s OTel mapper, Opik’s OTel intake).
How We Ranked These Open Source LLM Observability Tools
We scored each candidate on six axes, then ordered the eight by a mix of production readiness and fit for self-hosted LLM or agent workloads. Stars are a popularity signal, not a quality score.
- License clarity: OSI-approved beats source-available; open-core is fine when core tracing and evals run without a key.
- Self-host path: documented Compose for local, Helm or Terraform for production, same codebase as cloud when claimed.
- Tracing depth: nested spans, sessions or threads, token and cost fields, agent graphs where advertised.
- OpenTelemetry: native OTLP ingest or first-class OTel SDK beats proprietary-only SDKs.
- Evals overlap: datasets, LLM judges, online scoring, or CI hooks without forcing a second product.
- Ops honesty: ClickHouse, Postgres, Redis, and object storage needs are stated, because self-hosting is real work.
We also read the current SERP and common LLM answers for queries such as “open source llm observability” and “self host langfuse alternatives.” Those answers usually cite Langfuse, Phoenix, and Opik, then trail into Helicone or generic APM. This page goes deeper on licenses, install paths, and a worked infra cost, and it links out to our AI agent evaluation tools guide when evals are the buying job.
The 8 Best Open Source LLM Observability Tools You Can Self-Host
1. Langfuse: best overall open source LLM observability platform
Verdict: Langfuse is the safest default when you want one self-hosted platform for traces, prompts, datasets, and evals. The core is MIT licensed, the cloud and self-hosted codebases match, and ClickHouse’s January 2026 acquisition came with a public commitment to keep the project open under its existing license.
Langfuse is an open source LLM engineering platform for observability, prompt management, datasets, and evaluation. The public repository showed about 35.7k GitHub stars on October 13, 2026.
Self-host docs cover Docker Compose for local and low-scale deploys, plus Kubernetes Helm and Terraform modules for AWS, Azure, and GCP. That production path is why Langfuse keeps winning “self host llm observability” shortlists.
Best for: Teams that want one self-hosted system of record for LLM traces, prompts, and evals
Key observability features
- Nested traces and agent graphs, sessions, users, token and cost tracking
- Prompt versioning, playground, and experiments
- Datasets, LLM-as-judge, human annotation queues, and a CI experiment GitHub Action
- Native OpenTelemetry / OTLP ingest alongside Python and JavaScript SDKs
- Public APIs and blob export for warehouses
Self-hosting and OpenTelemetry
OSS self-hosting is free with unlimited usage under the MIT core, per self-hosted pricing. Enterprise features such as project-level RBAC, audit logs, retention policies, SCIM, and server-side masking need a license key for the ee/ modules.
A minimal Compose stack is fine for demos. Production expects Langfuse web and worker containers plus Postgres, ClickHouse, Redis, and object storage, so budget an operator, rather than only a VM.
Pricing
- Cloud Hobby: free, 50k units/month, 2 users, 30-day access
- Core: $29/month, 100k units included, then about $8 per 100k (graduates lower at higher volume), unlimited users
- Pro: $199/month with multi-year retention; Enterprise from $2,499/month published
- Self-hosted OSS: $0 platform fee; Self-hosted Enterprise: custom
A billable unit is a trace, observation, or score. On Core, 500k units in a month is roughly $29 + $32 = $61 before you count how many observations each trace creates.
Pros and cons
Pros
- Deepest open-core AgentOps feature set with strong docs and community
- MIT core with unlimited self-hosted usage
- First-class OTel plus many framework integrations
Cons
- Production Compose or Helm still means operating ClickHouse and friends
- Some org controls sit behind the Enterprise key
- Cloud unit math needs care when every span counts
2. Opik (Comet): best Apache 2.0 self-hosted observability and evals
Verdict: Opik is the pick when legal wants a clean Apache 2.0 license and engineering still needs tracing, online evals, and prompt tooling in one repo. Comet publishes the server, UI, and evaluation components under Apache 2.0 with no feature gate between self-host and cloud for core capabilities.
Opik is Comet’s open source LLM observability and evaluation platform. The comet-ml/opik repository showed about 22.5k stars on October 13, 2026.
Self-host docs cover a local install script and a production Kubernetes path. Comet notes that self-host includes tracing and evaluation features, while some user-management extras stay on managed plans.
Best for: Teams that need permissive licensing and first-class evals beside traces
Key observability features
- Agent tracing, execution graphs, sessions, token and cost tracking
- Online evaluation rules on production traces
- Test suites, assertions, datasets, experiments, and 30+ built-in metrics
- Prompt library, playground, and agent optimization toolkit
- OpenTelemetry intake for polyglot services
Self-hosting and OpenTelemetry
Docker gets you a laptop or single-node install quickly. Kubernetes is the documented production stance when you outgrow local volumes.
The Apache 2.0 license across the platform components Comet ships in the repo usually shortens procurement reviews compared with ELv2 or dual-license products.
Pricing
- Open Source: $0, full feature set on your infra
- Free Cloud: $0, 25k spans/month, 60-day retention, up to 10 members
- Pro Cloud: $19/month, 100k spans included, then about $5 per 100k
- Enterprise: custom, SSO, flexible deploy, compliance packs
On Pro Cloud, 500k spans is about $19 + $20 = $39 to $44 depending on how overages are rounded, before longer retention add-ons.
Pros and cons
Pros
- True Apache 2.0 server plus UI
- Strong evals and online scoring without a second product
- Low Pro Cloud entry price if you later leave self-host ops
Cons
- Younger ecosystem than Langfuse for some framework adapters
- Self-host omits some hosted user-management features
- You still operate the data plane
3. Arize Phoenix: best lightweight OpenTelemetry self-host
Verdict: Phoenix is the lightest full UI many teams stand up, and it is deeply tied to OpenInference semantic conventions. Read the license before you standardize: Phoenix is Elastic License 2.0, free to self-host, but not OSI-open, and you may not offer it as a managed service to others.
Arize Phoenix covers tracing, evaluation, prompt experiments, and datasets. The Arize-ai/phoenix repo showed about 11.8k stars on October 13, 2026.
Self-hosting docs state there are no usage limits or feature gates for self-hosted Phoenix, and the stack can be air-gapped. Storage is SQLite or PostgreSQL rather than ClickHouse.
Best for: OpenTelemetry-first teams that accept ELv2 and want a small self-host footprint
Key observability features
- Trace explorer for LLM and agent spans
- Pre-built evals, including tool selection and tool invocation metrics
- Datasets, experiments, and prompt playground-style flows
- Docker images and an OCI Helm chart on Docker Hub
- OTLP gRPC ingest (commonly port 4317) beside the UI port 6006
Self-hosting and OpenTelemetry
A typical Docker Compose path runs the phoenix container with Postgres. That is fewer moving parts than Langfuse’s ClickHouse-backed production stack.
Arize AX is the separate managed and enterprise product with its own pricing (Pro from about $50/month). AX self-host is an Enterprise conversation. Phoenix and AX share instrumentation ideas, not the same storage engine.
Pricing
- Phoenix self-host: $0 platform fee
- Arize AX Free: limited spans and retention
- Arize AX Pro: about $50/month entry on published pages
- Arize AX Enterprise: custom, including self-host options
Confirm current AX meters on Arize’s pricing page before budgeting; Phoenix itself does not bill per span when you run it.
Pros and cons
Pros
- Fastest OTel-native UI to stand up
- Strong pre-built eval templates for tools and RAG
- No platform fee and air-gap friendly
Cons
- ELv2 is source-available, not OSI-approved
- Single-tenant by design; multi-team isolation often means multiple instances
- Enterprise SSO and deep multi-level RBAC live in AX, not Phoenix
4. Helicone: best open source gateway plus LLM observability
Verdict: Helicone is the open source choice when you want an AI gateway in the request path and observability as a consequence of proxying. One-line base URL changes capture OpenAI-compatible traffic, costs, sessions, and users without sprinkling decorators through every service.
Helicone markets itself as an AI gateway and LLM observability platform. The Helicone/helicone repository is Apache 2.0 and showed about 6.2k stars on October 13, 2026.
Self-hosting docs cover Docker Compose and Kubernetes. Helicone states the open source deployment includes the core observability features teams use on cloud.
Best for: Teams that already want a unified AI gateway and cost analytics
Key observability features
- Request logging, sessions, user analytics, and custom properties
- Cost and latency dashboards, caching to cut provider spend
- Alerts, reports, and Helicone Query Language on paid cloud tiers
- Gateway routing, fallbacks, and multi-provider access
- OpenLLMetry-related async logging paths for OpenTelemetry users
Self-hosting and OpenTelemetry
Gateway architecture means Helicone sees traffic that other tools only see if you instrument every client. That is an advantage for polyglot stacks and a design choice you must accept for latency and trust boundaries.
Run it inside your VPC when prompts cannot leave your network. Keep provider API keys in your own secret store either way.
Pricing
- Hobby: free, 10,000 requests/month, 1 GB storage, 1 seat
- Pro: $79/month, unlimited seats, alerts and reports, usage-based beyond free requests
- Team: $799/month, more orgs, SOC 2 and HIPAA packaging
- Enterprise / on-prem: custom; self-host OSS: $0 platform fee
Helicone’s cloud bill is request- and storage-metered beyond Hobby. Self-host swaps that meter for your own Postgres and object storage costs.
Pros and cons
Pros
- Apache 2.0 with a real self-host story
- Fastest path to logs when you can put a gateway in front
- Caching can reduce model spend enough to fund the platform
Cons
- Weaker as a deep agent-graph debugger than Langfuse or Opik
- Gateway hop adds an operational dependency
- Pro cloud entry is higher than Langfuse Core or Opik Pro
5. LangWatch: best open-core platform for agent simulations plus observability
Verdict: LangWatch combines traces with multi-turn agent simulations, which is rare in the open-core set. If your buying job is “break the agent in CI before users do,” it earns a slot beside the pure observability tools.
LangWatch is an open-core agent observability and evaluation platform. The langwatch/langwatch repository showed about 4.9k stars on October 13, 2026, primarily under Apache 2.0, with enterprise modules under a commercial license per editions and licensing.
Self-hosting runs on Docker Compose with your own ClickHouse. LangWatch says you can self-host without a license for unlimited members and usage; Enterprise adds SSO, RBAC, SCIM, audit logs, and support.
Best for: Platform teams that need simulations and production traces together
Key observability features
- Traces, graphs, sessions, topic clustering, token and cost tracking
- Scenario simulations with judge agents and tool-call verification
- Offline experiments, online monitors, and annotation inboxes
- Prompt versioning and playground
- Python and TypeScript SDKs, plus OpenTelemetry support
Self-hosting and OpenTelemetry
Expect a ClickHouse-backed Compose stack similar in spirit to other modern LLM ops tools. Start local, then harden auth and backups before production traffic.
Pricing
- Developer: €0, 50k events/month, 2 users, 14-day access
- Growth: €29 per core seat / month, 200k events included, then €5 per 100k
- Enterprise: custom, hybrid or self-hosted with governance features
At one Growth seat and 500k events, list pricing is about €29 + €15 = €44 before retention overages, using the published €5 per 100k rate after 200k included.
Pros and cons
Pros
- Simulations and observability in one open-core product
- Generous self-host posture for core features
- Strong fit for platform teams governing many agents
Cons
- Smaller community than Langfuse or Opik
- Seat-based Growth pricing differs from pure usage vendors
- Enterprise modules still matter for SSO-heavy orgs
6. Agenta: best self-hosted open source agent workspace with run logs
Verdict: Agenta has evolved into a full agent workspace with chat, tools, MCP, and automations. It still belongs on an open source LLM observability shortlist because the OSS edition includes run logs, evaluations, and versioned agent configuration you can keep on your own servers.
Agenta’s Agenta-AI/agenta repository showed about 4.8k stars on October 13, 2026. Docs describe an MIT-licensed core with commercial code under ee/ directories, similar in shape to other open-core AgentOps tools (open source vs commercial).
Self-hosted OSS is listed as free forever on pricing, with Docker Compose deployment, unlimited users and projects, RBAC, and SSO in the open edition. Enterprise adds audit logs, custom domains, and commercial support.
Best for: Teams standardizing on a self-hosted agent workspace with built-in logs and evals
Key observability features
- Run logs for agent turns and automations
- Evaluations and versioned agent configuration
- Prompt and instruction management inside the workspace
- MCP servers, tools, and integrations for agent actions
- Human approvals and tool permissions
Self-hosting and OpenTelemetry
Treat Agenta as the workspace that happens to emit the observability you need, not as a drop-in OTel backend for arbitrary apps. If you only need a trace database for many services, Langfuse or Opik fit better.
Pricing
- Self-hosted OSS: $0
- Cloud Hobby: $0 with daily credit limits
- Cloud Starter: $29/month with included credits, unlimited members
- Business: $299/month; Enterprise: custom
Cloud metering is credit-based for model and runtime use. Self-host removes Agenta’s credit meter and leaves you with model provider bills plus infra.
Pros and cons
Pros
- MIT core with a real self-host edition
- Observability sits next to the agents you run
- No per-seat price on paid cloud plans
Cons
- Less of a universal OTel sink than Langfuse, Phoenix, or OpenLIT
- Product scope is broader than classic LLM observability
- Team should want the workspace, rather than only the debugger
7. Laminar: best open source observability purpose-built for AI agents
Verdict: Laminar is the agent-native tracer in this set: OpenTelemetry SDK, browser-session context, SQL over spans, and a UI aimed at agent failures rather than generic APM. YC S24 backing and an Apache 2.0 license make it a credible smaller alternative to Langfuse when agents, not raw LLM calls, are the unit of work.
The lmnr-ai/lmnr repository showed about 3.4k stars on October 13, 2026 under Apache 2.0.
Self-hosting supports a lightweight Docker Compose quickstart on port 5667 and a fuller compose or Helm path for production. Some AI-assisted UI features need an LLM provider key in your environment file.
Best for: Teams debugging browser or tool-heavy agents who want Apache 2.0
Key observability features
- Automatic tracing for common agent and browser-use stacks
- Natural-language events (Signals) for issue patterns
- SQL access to span data
- Datasets and evaluation workflows
- OpenTelemetry-native instrumentation
Self-hosting and OpenTelemetry
Compose up is enough to evaluate the product. Production should use the full compose file or Helm, with backups for the data volume and auth configured before exposing the UI.
Pricing
- Free: $0/month with included data allotment (about 1 GB on published cards)
- Paid cloud tiers scale with retained data and Signals usage; Starter and Pro have been published around $30 and $150 historically, so confirm the live calculator
- Self-host OSS: $0 platform fee; some Signals or Slack alert extras may need an enterprise key
Cloud packs meter data and Signals tokens, so self-host is often cheaper once browser-heavy agent traces grow large.
Pros and cons
Pros
- Apache 2.0 with agent-first UX
- Strong browser and computer-use tracing story
- SQL over traces for power users
Cons
- Smaller community and fewer third-party guides
- Cloud pricing is less “simple seat” than competitors
- Full production compose is heavier than the quickstart implies
8. OpenLIT: best OpenTelemetry-native stack with GPU and coding-agent monitoring
Verdict: OpenLIT pitches “agent harness engineering”: OpenTelemetry tracing, evals, guardrails, prompt hub, and GPU monitoring in one Apache 2.0 package. It is the right eighth pick when your LLM apps share clusters with GPUs and coding agents, and you already standardize on OTel collectors.
The openlit/openlit repository showed about 2.8k stars on October 13, 2026 under Apache 2.0.
Pricing lists OSS self-host as free with unlimited usage via Docker or Helm. OpenLIT Cloud is listed as coming soon. Docs describe a stack with OpenLIT, ClickHouse, and an OpenTelemetry Collector.
Best for: Platform teams standardized on OpenTelemetry who also watch GPUs and coding agents
Key observability features
- OTel-native tracing for LLMs, MCP, vector DBs, and coding agents
- Prompt Hub, Vault for keys, and OpenGround model comparisons
- Evaluations and guardrails in the SDK
- GPU utilization, memory, temperature, and power dashboards
- Fleet Hub for collector monitoring via OpAMP
Self-hosting and OpenTelemetry
If you already run an OTel collector, OpenLIT fits as another backend rather than a separate instrumentation religion. Export to Grafana or Datadog remains possible because the data plane speaks OTLP.
Pricing
- OSS self-host: $0, unlimited usage
- Cloud: waitlist, pricing at launch
- Enterprise governance extras (custom roles, audit logs, alerts) called out separately from OSS
Until Cloud launches, budget only infra. ClickHouse plus a collector on a small cluster is the typical shape.
Pros and cons
Pros
- Apache 2.0 and OTel-native end to end
- GPU and coding-agent coverage others skip
- No per-trace fee on OSS
Cons
- Smaller star count and fewer case studies
- Cloud maturity still catching up
- Ops surface includes ClickHouse and collectors
Self-Host Versus Cloud: A Worked Cost Example
License fees are zero for OSS self-host on this list. The bill is infrastructure, people time, and the optional managed tier. Here is a worked example for about 500,000 LLM spans a month on a single product team.
| Option | What you pay | Ballpark / month | When it wins |
|---|---|---|---|
| Self-host (Langfuse, Opik, Phoenix, OpenLIT, etc.) | VM or node + disk + DB backups; $0 license | $45 to $90 infra on a 4 vCPU / 16 GB box | Data residency, predictable infra, ops skill on staff |
| Langfuse Cloud Core | $29 + usage units | About $60 to $70 at ~500k units | You want Langfuse without ClickHouse on-call |
| Opik Pro Cloud | $19 + $5/100k extra spans | About $39 to $44 at 500k spans | Cheapest managed full platform on list prices |
| Helicone Pro | $79 + usage beyond 10k requests | $79+ | Gateway and cache savings offset the seat |
| LangWatch Growth | €29/seat + €5/100k events | About €44 at 1 seat / 500k events | Simulations matter as much as traces |
Self-hosting wins on data control; managed cloud often wins on total cost once you count engineer time. A single weekend incident on an under-watched ClickHouse node can erase months of saved SaaS fees. Many teams self-host staging and buy cloud for production, using OpenTelemetry so the app does not care.
How to Choose an Open Source LLM Observability Tool
- License gate: need OSI-approved? Prefer Opik, OpenLIT, Laminar, Helicone, or LangWatch. MIT core with ee/ extras? Langfuse or Agenta. ELv2 acceptable? Phoenix.
- Primary job: full AgentOps platform (Langfuse, Opik), gateway and cost (Helicone), simulations (LangWatch), agent workspace (Agenta), agent-native debug (Laminar), OTel plus GPU (OpenLIT), light OTel UI (Phoenix).
- Deploy shape: Compose POC works for all eight. Production Helm stories are strongest for Langfuse, Opik, Helicone, Phoenix, and OpenLIT.
- Instrumentation: already on OTel? Phoenix, OpenLIT, Langfuse, Opik, Laminar. Proxy-only? Helicone.
If you are leaving LangSmith specifically, also read our LangSmith alternatives guide. If evals, not tracing, are the budget owner, start from the evaluation tools listicle instead and come back here for the self-host observability layer.
Minimal Self-Host Patterns (Not Executed Here)
These snippets show the shape of each vendor’s quickstart. They are not executed in our environment. Always pin versions and follow the vendor’s current README.
Langfuse Docker Compose
git clone --depth=1 https://github.com/langfuse/langfuse.git
cd langfuse
docker compose up
# UI defaults to http://localhost:3000 per Langfuse self-hosting docsOpik local install
git clone https://github.com/comet-ml/opik.git
cd opik
# Follow Comet's local installation script in the self-host docs
# Production: use the documented Kubernetes / Helm pathPhoenix Docker
# Pattern from Phoenix self-hosting docs: Phoenix + Postgres
# UI on 6006, OTLP gRPC commonly on 4317
docker pull arizephoenix/phoenix:latest
# Prefer a pinned version-X.Y.Z tag in productionHelicone, Laminar, LangWatch, Agenta, OpenLIT
Each ships a Compose file in-repo or in docs: Helicone (self-host overview), Laminar (`docker compose up -d` in lmnr-ai/lmnr), LangWatch (self-hosting overview), Agenta (Compose on the OSS plan), OpenLIT (Docker or Helm per pricing and docs). Pin images, configure auth before public exposure, and back up the database volume from day one.
Left Off the Ranked List (and Why)
- LangSmith: excellent for LangGraph, but self-host is Enterprise. Covered in our observability tools and LangSmith alternatives pieces.
- Braintrust: strong eval-gated hosted platform; self-host is not free OSS. See Braintrust vs Maxim vs Galileo.
- Traceloop OpenLLMetry: Apache 2.0 instrumentation that exports OTLP to many backends. Useful plumbing, not a full product UI, so it is a companion rather than a ranked platform.
- SigNoz: powerful open source OTel APM with LLM support, but it is a general observability suite first. Worth a look if your org already standardized on SigNoz.
- Lunary: useful product, but public self-host docs require Enterprise Edition, so it fails our free self-host bar.
- HoneyHive and other hosted-only platforms: fine commercially, out of scope for an open source self-host list.
Upcoming AgentStack comparisons will cover Arize Phoenix vs Langfuse vs Helicone and Langfuse alternatives in more depth. This page stays on the open source self-host angle so those posts can own head-to-head keywords.
Frequently Asked Questions About Open Source LLM Observability
What is the best open source LLM observability tool to self-host in 2026?
Langfuse is the best overall default for most teams, with an MIT core, mature self-host docs, and full traces, prompts, and evals in one platform. Choose Opik when legal needs a clean Apache 2.0 license, or Phoenix when you want a lighter OpenTelemetry UI and can accept Elastic License 2.0.
Is Arize Phoenix truly open source?
Phoenix is free to self-host with no feature gates, but it ships under Elastic License 2.0. That license is source-available rather than OSI-approved, and it forbids offering Phoenix as a managed service to third parties. Its OpenInference instrumentation libraries remain Apache 2.0.
Can Langfuse be self-hosted for free?
Yes. Langfuse OSS runs under the MIT license with unlimited usage on your own infrastructure via Docker Compose, Helm, or Terraform. Enterprise add-ons such as project-level RBAC and audit logs need a commercial license key, while core tracing, prompts, and evals do not.
How much does self-hosted LLM observability cost?
Platform licenses are $0 for the eight tools on this list. A small production box often lands near $45 to $90 per month for compute and disk, before engineer time. Managed clouds such as Opik Pro or Langfuse Core can cost less once you count operations work.
Do these tools support OpenTelemetry?
Langfuse, Opik, Phoenix, Laminar, OpenLIT, and LangWatch document OpenTelemetry or OTLP ingest paths in their docs. Helicone often sits as a gateway and can still feed OpenTelemetry-compatible pipelines. Prefer OTLP instrumentation so you can swap backends without rewriting application code.
Related AgentStack Guides
Self-hosting the observability layer often goes with self-hosting the model proxy. Our LiteLLM alternatives guide compares open source and managed LLM routing gateways.
Need routing, budgets, and failover in front of these tools? See the 9 best LLM gateways for enterprise AI teams.
For paid and suite exits as well as OSS swaps, see 7 Best Langfuse Alternatives.
- AgentOps tools map (pillar)
- 12 Best AI Agent Observability Tools in 2026
- 10 Best AI Agent Evaluation Tools in 2026
- Langfuse vs LangSmith vs Braintrust
- LangSmith Alternatives
- Braintrust vs Maxim vs Galileo
- AI Agent Frameworks
- Observability category
- Evals & Testing category
Bottom Line
The best open source LLM observability stack in 2026 is the one you can legally run, honestly operate, and instrument once with OpenTelemetry. Langfuse is the all-purpose self-host platform, Opik is the Apache 2.0 evals-heavy alternative, Phoenix is the light OTel UI with an ELv2 caveat, and Helicone owns the gateway lane. LangWatch, Agenta, Laminar, and OpenLIT fill simulations, workspace, agent-native, and GPU niches.
Start with Compose on a non-production project, emit OTLP, and only then decide whether to keep self-host or buy the vendor cloud. For questions about this guide, contact the AgentStack desk.
For a deep three-way self-host comparison of just these stacks, see Arize Phoenix vs Langfuse vs Helicone.