PromptWake vs Langfuse
Langfuse traces the LLM calls your application makes. PromptWake records the AI conversations your developers have. They are not alternatives — here is how to tell which one your question belongs to.
you are building an AI feature and need traces, evals, prompt versioning and cost data for the calls your own code makes.
your developers use AI to write code and you need a record of what was asked, what was answered and what changed.
| Capability | Langfuse | PromptWake |
|---|---|---|
| What it observes | LLM calls made by your application | AI coding sessions on developer machines |
| How it is wired in | SDK or OpenTelemetry instrumentation in your code | Daemon reading what AI tools already write to disk |
| Requires code changes | Yes | No |
| Sees Cursor / Claude Code sessions | No | Yes — that is the product |
| Evaluation and scoring | Yes — datasets, evals, LLM-as-judge | No |
| Links to file diffs | No | Yes — prompt, response and changed lines together |
| Self-hosting | Yes, fully open source | Local-first by default; self-host on Enterprise |
Langfuse comes up in our evaluations often enough that it is worth being direct: it is not a competitor, and if what you need is what Langfuse does, no amount of feature comparison will make us the right answer. The two products observe different things, and the confusion is caused by both being described with the word 'prompts'.
Two different meanings of the word prompt
Langfuse observes the prompts your software sends. You instrument your application — via its SDK or OpenTelemetry — and every call your code makes to a model becomes a trace: inputs, outputs, latency, token cost, the chain of steps that produced it. On top of that sits prompt versioning, datasets, evaluations and a playground. It is an excellent product for the job of running an AI feature in production, it is fully open source, and it self-hosts cleanly.
PromptWake observes the prompts your developers type. A background daemon reads the files that Claude Code, Cursor, Copilot, Codex and the rest already write to disk, and turns them into a timeline of prompt, response and the file diff that resulted. There is no SDK, because there is no application to instrument — the subject is the engineering work, not the product.
Langfuse answers 'is our AI feature working, and what does it cost'. PromptWake answers 'what did AI build for us, and can we reconstruct why'.
The test that settles it in one sentence
Ask where the model call happens. If it happens inside software you ship, you want an observability platform, and Langfuse is one of the best of them. If it happens inside a tool your developers run on their laptops, no observability platform will see it — those calls never pass through your code, your gateway or your infrastructure.
This is the part teams get wrong in evaluations. An organisation adopts an LLM observability platform, wires it into their product, and reasonably assumes they now have visibility into AI usage. They have visibility into one kind of AI usage. The Cursor session that rewrote the payment handler is not in it, and cannot be, because nothing about that session touched their stack.
Where we are genuinely behind
If you are comparing capabilities rather than categories, the honest list is short and one-sided. Langfuse has evaluation infrastructure — datasets, scoring, LLM-as-judge — and we have none. It has prompt versioning as a first-class workflow; ours is incidental. It is fully open source and self-hostable by anyone, where our self-hosting is an Enterprise arrangement. If those matter to you, they matter.
What we have that it structurally cannot is the connection to the code. A trace tells you what the model returned. Our record tells you which lines of your repository that answer became, which is the thing you need when a change has to be explained months later.
Using both
Most teams that need one eventually need both, and they do not overlap. Langfuse covers the AI you ship; we cover the AI that ships your code. If your organisation has a single budget line labelled 'AI tooling', that is a budgeting accident rather than a product decision — the two answer different questions to different people, one to the team running a feature, one to the team explaining a codebase.
If you are not sure which is your question, start from the consequence you are trying to avoid. If the worst outcome is your AI feature behaving badly for a customer, start with observability. If it is an incident nobody can explain because the conversation that produced the code is gone, start here.