Mirrors vs Langfuse

What Langfuse is good at

• The open source offer is genuinely generous, not a demo. MIT (Expat) apart from the ee/ directories, 32,298 GitHub stars, and the self-hosted build includes SSO and project-level RBAC: the exact features that cost $300 a month as the Teams add-on on their cloud.
• OpenTelemetry-native, so the instrumentation you write is not hostage to the vendor. If you leave, your traces still mean something.
• The most mature prompt management here: versioning, labels, and a playground that the rest of the product is wired into.
• Evals, annotation queues, and the playground are all available without a paid plan, and have been since June 2025.
• The cheapest credible cloud tier in the category, an agent graph view that makes a multi-step run readable, datasets and experiments, online evals with both LLM-as-judge and code evaluators, and a GitHub Action for CI. v4 landed on cloud in March 2026.
• ClickHouse acquired them on 16 January 2026, which puts a column store built for exactly this query shape behind the product.

Side by side

Prices and limits checked against langfuse.com on 2 August 2026. Self-hosting is free of license cost, not free: you run and operate the stack.

The actual difference

Langfuse watches. It takes the spans your agent emits, stores them somewhere queryable, and gives you evals, scores, and a prompt workflow on top. Because it is OpenTelemetry-native and MIT, it does that with less lock-in than anything else in this comparison.

What it does not do is stand in for the systems the spans describe. The agent that produced them was talking to a real database and a real API the whole time.

That is where the tool-mocking feature is worth being precise about, because the name suggests otherwise. In the Langfuse playground you can declare a tool by name, description, and JSON Schema, then type the JSON you want returned. It is genuinely useful for exercising a prompt against a response shape. It is not a service: it does not execute anything, it does not hold state between calls, and it cannot represent a database that has different contents after a write than before it. A refund flow that reads a balance, issues a refund, and then reads the balance again cannot be tested against a typed-in string.

Mirrors builds the service instead. Each tool becomes something running, with a schema, fabricated seed records, and state that changes when the agent acts and resets between runs, constructed from your traces, code, or docs rather than declared by hand in a form.

When to use Langfuse instead

If open source matters to you as a requirement rather than a preference, use Langfuse. Self-host it, get SSO and RBAC for nothing, and keep your traces in your own ClickHouse. Nothing in this comparison competes with that, and we are not going to pretend otherwise.

Use it also if you want the cheapest credible hosted tier, if prompt management is the workflow you are actually trying to fix, or if OpenTelemetry portability is a procurement requirement. For a small team that needs to see what its agent did and does not yet have a testing problem, Langfuse Hobby answers the question for $0.

Most teams run both

The seam is the trace, and Langfuse being OTel-native makes it a clean one. Langfuse holds what production did; Mirrors reads those traces to build the environment; the replay of a change against that environment emits spans that go back into Langfuse alongside everything else.

Langfuse datasets and its LLM-as-judge evaluators then score runs that happened somewhere nothing real could break.

What this page compares, and what it does not

These five are the observability and evaluation platforms a team already has open when it asks how to test an agent, which is why they are the pages we wrote. They are not the whole field. Tools that do stand something in for an agent's counterpart, LangWatch's Scenario and Laminar's agent rollouts among them, are outside this comparison, and nothing here is a claim about them.

Standing in for a live dependency is also not a new idea. Record-and-replay HTTP mocking, VCR-style cassettes, predates LLM agents by about fifteen years and is free. What Mirrors adds is the construction and the state: the environment is built from your traces, code, or docs instead of hand-written, and it is a seeded, stateful backend you can reset between runs instead of a fixed transcript of responses.