Imagine an LLM customer service application gets a refund rule wrong: a user asks, “Can a membership used for half a year still be refunded?” and it says yes, while the actual policy is no. At this point, what the developer needs to investigate is why it answered that way, not what it answered—which policy passage was retrieved, which version of the prompt was used, which intermediate steps were running in parallel, and how many tokens this question consumed. Langfuse addresses this “after something goes wrong” trouble: it records one application interaction as one expandable trace—the complete record of one request from input to output—so the team can look back, evaluate, and change the next version of the prompt. This is an illustrative scenario, not a story about a particular customer.
The official website defines Langfuse as an open-source AI engineering platform covering tracing, prompt management, evaluation, and experiments, available as cloud-hosted or self-hosted. Langfuse website[1] It joined ClickHouse in January 2026; its YC profile lists its status as Acquired. YC company page[2] That is getting ahead of the story; first, look at how the product works.
Record First, Then Talk About Evaluation
There are three ways to integrate: instrument with the SDK, use OpenTelemetry, or route model calls to the Langfuse AI Gateway. The first two are asynchronous; data is sent in batches in the background and does not block the application. The Gateway, by contrast, replaces the base URL and API key in the application with its own, so calls go through its request path; it is built in Rust and optimized for low latency. The official FAQ says that prompts in the SDK are cached on the client after the first fetch, with no added latency afterward; for calls going through the AI Gateway, the official website says its availability guarantee lets the application keep working when Langfuse is unreachable. Official FAQ[1] If you want to avoid touching the request path entirely, use the first two; choosing the Gateway means adding one more route between you and the model provider that you must configure and look after, with the official low-latency and availability guarantees offsetting this cost.
Open one trace that answered incorrectly, and you can see the complete execution flow of this request: which model APIs were called, which passages of context were retrieved, which version of the system prompt was used, which steps ran in parallel, and how many tokens and how much money each step cost. Complex calls are represented as nested traces; cost and latency can be broken down by user, session, feature, model, and prompt version. YC company page[2] If all you want to know is “where it is expensive and where it is slow,” this layer is enough; to investigate “why it answered incorrectly,” you still need to compare the retrieved original policy text with the prompt version.
Image: Langfuse official display[1], accessed 2026-11-10, original interface preserved.
Evaluation attaches at this same point: put the failing input and expected output into a dataset, change one version of the prompt, run one more experiment, and compare the scores of the two versions on the same inputs. Output quality can be evaluated with user feedback, LLM-as-a-judge (having another model score against criteria), and human annotation. YC company page[2] The product takes over recording and comparison; it does not decide for the team what counts as good. Evaluation criteria, human annotation, and which prompt version to change still require people; if self-hosted, infrastructure and permission policies also have to be managed by yourself. What I appreciate most is that it ties evaluation back to traces and prompt versions, rather than only giving a pretty score—a score is hard to explain once it is separated from “what was checked at the time and which prompt version was used.”
Customers Drove Prompt Management Into the Product
Langfuse did not first draw a platform architecture diagram and then look for customers. The team started in 2022, first built the usage-billing product Finto, and entered YC W23 in November 2022; after arriving in San Francisco, customers liked Finto, but the team did not want to build yet another product in a mature small market. They spent most of the YC batch trying out LLM applications; most ideas were replaced within under two weeks, and the last one, for multi-file editing, lasted longer. This trial and error convinced them that LLM applications are hard to build and need methodical evaluation. So they pivoted to open-source LLM developer tools. [3]
After the first version was complete, the first batch of customers came from the YC batch. Early customers spent a lot of time in the product iterating and testing, giving feedback, and also referring the team to others; the team therefore decided to open-source it and release the repo, launching publicly in July/August 2023 as LLM App product analytics. In the first few months they focused only on tracing/observability; across the New Year they decided to do prompt management because early customers requested it and because the tight coupling of prompt and tracing had additional value; the first version went live within a few days. This order matters: it was not a “platform vision” that came first; customers pushed prompt management out.
After the public launch, they closed a $4M seed round, with investors including Lightspeed Venture Partners, La Famiglia, Y Combinator, and angel investors. This is financing, not subscription revenue; publicly available materials contain no ARR/MRR, gross margin, infrastructure costs, or customer concentration, so neither revenue nor profit can be calculated. [3]
Charging by Data Point, with Bills That Follow Debugging
Langfuse is aimed at LLM application developers and teams doing evaluation; paid cloud plans are billed by data points sent to the platform, and the bill belongs to the team or company that owns the account; with self-hosting, the team using it bears the infrastructure. Self-hosting is free under the MIT license, with core features (observability, evaluation, prompt management, datasets) unlimited; self-hosted Enterprise adds project-level RBAC, audit logs, data retention policies, a management API, and SLA support. Website[1] Cloud-hosted billing is not per seat but by tracing data points: traces (complete application interactions), observations (spans/events/generations within a trace), and scores. [4]
The two axes need to be looked at separately. Capacity axis: the free Hobby tier includes 50k units/month; paid plans include the first 100k units/month, with volume-based declining pricing above that. Retention axis: Hobby has 30 days of access, Core 90 days, Pro and Enterprise 3 years; Pro and Enterprise also include Data retention management. [4]
Paying more buys not only more units but also longer access. For example, for a small team that has just launched, 50k units/month may be enough to catch the most recent incident; to dig up one prompt change from three months ago, you need Core with its 90-day window; to look back half a year, you need the 3-year window of Pro or Enterprise. The official website only lists access windows and the Data retention management feature; it does not fully explain the deletion window; if compliance requires confirming when data is deleted, you still have to ask directly.
If you want to compare hosted tracing, LangSmith also separates “how much is recorded” and “how long it is kept”: it prices by seats plus trace volume, basic trace retention is 14 days, and extending to 180 days costs extra. LangSmith pricing page[5] The two split things differently. To compare, compare how many traces you send per month and how long you need to keep them under the same task, not just say “who is cheaper.”
Not Planning to Sell, Yet Selling to ClickHouse
The acquisition announcement is candid: the company had not planned to sell, had already received very good Series A term sheets, and was looking forward to the Christmas holiday; it changed its mind because it believed that together with ClickHouse it could move faster while remaining open-source, self-hostable, and oriented toward production workloads. Existing open-source/self-hosting commitments and the Cloud product, endpoints, and contracts remain unchanged; the entire team joins ClickHouse to continue building Langfuse. [6]
The technical reason is also direct: the first version ran on Postgres to ship quickly; after adoption grew, high-throughput writes and fast analytical reads became bottlenecks, and v3 moved the core data layer to ClickHouse. Langfuse Cloud is a large ClickHouse Cloud customer, and the ClickHouse team also uses Langfuse; the v2→v3 upgrade brought thousands of teams to ClickHouse. The acquisition amount and payment method were not disclosed.
This acquisition reads like a footnote the product wrote for itself: a tool that records LLM application data ended up tied to a database company; but the company had not planned to sell, already had very good Series A term sheets, and chose ClickHouse because it believed that together they could move faster. I think the most valuable thing about Langfuse is not that evaluation score, but turning the execution process of LLM applications into queryable data.