Opik vs Langfuse: Self-Hosted LLM Observability in 2026

Your agent handled a support ticket at 2am. It made fourteen LLM calls, hit three tools, and confidently told the customer something that isn't true. Now you're staring at a log line that says agent_run completed and nothing else.

That's the gap LLM observability fills. Two open-source platforms come up again and again on the self-hosted end of it: Opik from Comet, and Langfuse. Both trace agent runs, both score outputs, both run entirely on your own infrastructure. Picking between them is the real work, and the honest deciding factor has less to do with features than with how your team is shaped.

What they both do

Let's get the overlap out of the way, because it's substantial.

Both give you full trace trees for multi-step agents, so you can expand a run and see every LLM call, tool invocation and nested function. Both support datasets and experiments, LLM-as-a-judge scoring, prompt management with versioning, and online evaluation rules that flag bad outputs in production. Both ingest via OpenTelemetry, and both are backed by ClickHouse, which is why they handle serious trace volume instead of falling over at a few million spans.

If you only need "show me what the agent did," either one works. Pick on the criteria below instead.

The thing that actually decides it: how each one gates teams

This is the part most comparisons skip, and it's the part that will bite you three months in.

Opik is Apache-2.0 across the whole platform, backend included. No source-available hedging, no open-core carve-out on the tracing engine. But the self-hosted open-source deployment ships without user management. No multi-user accounts, no SSO, no role separation. Fine for a single team behind a VPN. Not fine if you need to give twelve people scoped access and prove who saw what.

Langfuse takes the opposite trade. The core is MIT and explicitly has no scalability limits in the free version. Multi-user works out of the box. What sits behind a paid license key is the governance layer: project-level RBAC roles, audit logs, data retention policies, server-side data masking, SCIM and the org management API.

So both gate the team-and-compliance story. Opik gates it earlier and more bluntly. Langfuse lets a team share an instance for free and charges when you need to control and audit that sharing. Neither is a bait and switch, but you should know which wall you're going to hit.

Who owns the roadmap

Worth knowing before you commit a year of trace history to either one.

ClickHouse acquired Langfuse in January 2026, alongside a $400M Series D. The MIT license stayed intact and self-hosting remains a first-class path, which is more reassurance than most acquisitions offer. Still, Langfuse's roadmap now sits inside a database company that has an obvious interest in you running its analytics engine. Opik remains a Comet project, and Comet's business is the ML platform around it.

Read that however you like. I'd just rather you read it before migrating, not after.

Where each one actually leans

Opik pushes harder on evaluation. It ships a PyTest integration so you can fail a build when your RAG pipeline's hallucination score regresses, an Agent Optimizer SDK for improving prompts programmatically, and a Guardrails service that runs as its own container. If your team treats prompt quality as a testable engineering property, that's a real edge.

Langfuse pushes harder on breadth and adoption. The integration surface is larger, the documentation is deeper, and the sheer install base means your framework probably already has a first-class Langfuse callback. When something breaks at 3am, "more people have hit this before" is an underrated feature.

Instrumentation effort is comparable. Opik:

from opik import track

@track
def answer_question(question: str) -> str:
    return llm.invoke(question)

Langfuse, using the current v4 Python SDK:

from langfuse import observe

@observe()
def answer_question(question: str) -> str:
    return llm.invoke(question)

Both capture nested calls automatically, so decorating your entry point gets you the whole tree.

What it costs to run

Neither of these is a single container, and pretending otherwise is how people end up with an OOM-killed ClickHouse at midnight.

Langfuse needs web and worker processes, PostgreSQL, ClickHouse, Redis and an S3-compatible blob store. Opik needs a backend, a Python backend, a frontend, MySQL, ClickHouse, Redis, ZooKeeper and a blob store, plus another container if you enable Guardrails. Opik's stack is the heavier of the two.

The software is open-source with no license fees for the core, but the infrastructure is real. Rough guidance at Elestio's published Netcup high-frequency CPU tiers, which you should check for current rates:

Start Langfuse at 8 GB and Opik at 16 GB. ClickHouse is the component that will eat your RAM, and trace payloads are bigger than you expect once you're logging full prompts and tool arguments.

How to pick

Choose Opik if evaluation is the point. You want hallucination and relevance scores gating your CI, you're optimizing prompts as a workflow, and your instance lives behind a VPN where the missing user management doesn't matter.

Choose Langfuse if a team needs to share it. Multi-user works without a license key, the integration ecosystem is wider, and you can defer the paid tier until you genuinely need audit logs and RBAC.

Run both briefly if you're undecided. They instrument identically enough that a week of dual-writing traces costs you an afternoon and settles the argument with your own data.

Troubleshooting the self-hosted setup

ClickHouse gets OOM-killed under load. Almost always the default memory limits against a VM that's too small. Move to a larger tier before tuning; both stacks assume ClickHouse has real headroom.

Traces appear in the SDK but never in the UI. On Langfuse this usually means the worker container is down or can't reach Redis. Ingestion is queued, so the web UI stays cheerfully empty while the backlog builds. Check worker logs first.

Blob storage errors on startup. Both platforms need working S3-compatible storage for large payloads and exports. Wrong bucket, wrong region or missing credentials fails at boot rather than degrading gracefully.

Costs climb faster than expected. Full prompt and completion capture on a chatty agent generates far more data than typical app logs. Set retention early, and use capture_input=False or capture_output=False on the noisiest spans.

Getting started

Both are one-click deploys with managed backups, updates and monitoring handled for you: Opik on Elestio and Langfuse on Elestio.

My honest read: most teams should start with Langfuse because sharing an instance shouldn't require a purchase order, then add Opik if evaluation becomes a first-class engineering concern. But if you're already writing eval suites, skip straight to Opik.

Thanks for reading ❤️ See you in the next one 👋