Nine Open-Source LangSmith Alternatives, Audited on 5 October 2026

Visual needed: Open-source LangSmith alternatives licence audit, checked 5 October 2026 Independence disclosure: this publication sells no product in this comparison. Nine of the ten pages currently ranking for this query were written by a vendor inside their own comparison. Langfuse, Confident AI, MLflow, Braintrust, ZenML and OpenObserve each rank or frame their own tool as the answer. Every repo fact, licence and price below carries a verification date of 5 October 2026 and a primary-source URL. Nothing here was deployed, benchmarked or measured. This is a documentary audit of licences, issue trackers, changelogs and published price pages.

TL;DR: the open-source LangSmith alternatives worth shortlisting

An open-source LangSmith alternative shortlist splits three ways on licence. That split decides more than any feature grid.

Category	Tools	What it means for you
Clean permissive	Comet Opik, MLflow, Laminar, OpenLLMetry	Apache-2.0 across the repo, no secondary licence detected
Open core	Langfuse	MIT except ee/, which is why GitHub reports the repo licence as NOASSERTION
Source-available	Arize Phoenix	Elastic License 2.0, uncapped self-hosting, not OSI-approved

The closest like-for-like swap is Langfuse: tracing, prompt management, datasets and evals in one self-hostable product. It is also the largest project in the category at 35,386 stars (github.com/langfuse/langfuse, checked 5 Oct 2026). Two tools win on licence rather than features. Pick Comet Opik if legal review is the binding constraint. Pick MLflow if you want Linux Foundation governance instead of a single venture-backed roadmap.

Two traps. Helicone has been in maintenance mode since Mintlify’s acquisition announcement of 3 March 2026, and it still appears in current roundups as a live recommendation. Several tools marketed as alternatives are not open source at all: Braintrust (only braintrust-proxy is MIT, at 412 stars and 104 open issues), Galileo, Fiddler AI, and Confident AI’s platform. DeepEval the library is OSS. The platform is not.

Visual needed: Audited licence matrix for twelve LLM observability tools Visual brief: Audited licence matrix. Rows: LangSmith, Langfuse, Comet Opik, Arize Phoenix, MLflow, Laminar, Agenta, Helicone, Lunary, OpenObserve, OpenLLMetry, Braintrust. Columns: licence as reported by GitHub, licence as stated in the LICENSE file, OSI-approved (Y/N), enterprise carve-out directories, SSO in OSS build, RBAC in OSS build, audit logs in OSS build, self-host path (binary/Compose/K8s/Enterprise-only), verification date. Source each row from the repo’s own LICENSE file at a pinned commit and the vendor’s self-hosting docs. Never from another vendor’s comparison page.

Why teams go looking for a LangSmith alternative

Start with the distinction that most roundups blur. LangChain and LangGraph are MIT-licensed (147,450 stars, 617 open issues, langchain-core==1.6.6 released 2026-09-29) and langsmith-sdk is open source. The platform itself is published nowhere. Backend, UI and storage layer are all closed. You can patch what emits telemetry. You cannot patch what stores it.

Self-hosting is therefore a procurement question, and it is where most open-source LangSmith alternative searches begin. LangChain’s own documentation describes self-hosted LangSmith as an add-on to the Enterprise plan, “designed for our largest, most security-conscious customers,” with Kubernetes as the documented install path. Developer and Plus tiers are cloud-only. A data-residency requirement becomes a sales cycle.

Then billing. Plus is $39/seat/month. A ten-person team pays $390 before a single trace lands. The free Developer tier is capped at one seat, so evaluating the product alongside one colleague costs money. Retention is a second meter: the included window is 14 days, and extending it is a per-trace upgrade at $0.0025.

What LangSmith is genuinely best at deserves a fair hearing, because a reader who has used it will spot an unfair page immediately. One environment variable traces a LangChain or LangGraph app with no instrumentation work. Run Tree rendering shows agent structure natively, in a way generic span viewers approximate badly. Annotation queues are mature. Threshold alerting works out of the box. ZenML’s head-to-head awards LangSmith the alerting and eval-ergonomics rounds, and ZenML is not a LangChain partner.

So reframe the search. For most people typing this query, the problem is lock-in, not features. Which is why the next two sections are licence and exit rather than a feature grid.

What “open source” actually means in LLM observability (audited licences)

One in ten competing pages attempts this. The rest print a green checkmark in an “Open source?” column and move on. Licence is the first filter on any open-source LangSmith alternative, not the last.

Tool	Licence (LICENSE file)	GitHub reports	OSI-approved	Carve-out
Comet Opik	Apache-2.0	Apache-2.0	Yes	None detected
MLflow	Apache-2.0	Apache-2.0	Yes	None
Langfuse	MIT except ee/	NOASSERTION	MIT yes, repo mixed	ee/ directories
Arize Phoenix	Elastic License 2.0	ELv2	No	Hosted-service restriction
Laminar	Apache-2.0	Apache-2.0	Yes	None detected
OpenLLMetry	Apache-2.0	Apache-2.0	Yes	None
OpenObserve	AGPL-3.0	AGPL-3.0	Yes	Enterprise features
Lunary	Open core	—	Core yes	Docker/K8s, PII masking
Braintrust (proxy only)	MIT	MIT	Yes	Platform not published

Licences verified against each repository’s LICENSE file and GitHub’s reported licence field on the date given above.

Elastic License 2.0, in operational terms: you may read the source, run it, self-host it with no usage cap, and air-gap it. You may not offer it as a competing hosted service. It is not OSI-approved, and some legal teams treat non-OSI as a hard no regardless of what the terms permit. Comparison tables routinely file ELv2 next to MIT without the asterisk.

AGPL-3.0 reads the same way in reverse. Untroubling for internal use. A real review item if you embed observability inside a product you distribute to third parties.

Three questions replace “is it open source?”:

1. Can I run the whole product myself, or only part of it?
2. Are SSO, RBAC and audit logging in the build I can run, or behind the enterprise wall?
3. What am I permitted to do with it afterwards, including offering it to customers?

The carve-outs are specific per tool. Langfuse ships self-hosted SSO and organisation-level RBAC in the free OSS distribution. Project-level RBAC is an Enterprise or Cloud add-on. OpenObserve gates evaluations and SSO. Agenta gates RBAC and SOC 2 behind its Business tier. Opik’s self-hostable build is described as the full platform, but Comet still sells an Enterprise tier. Verify which specific security controls you need rather than assuming the OSS build covers your compliance checklist.

Carry one caveat through the rest of this page. Licences in this category change. Check the LICENSE file at the commit you deploy, not the one in a blog post.

Two LangSmith behaviours documented in LangChain’s own docs that nobody writes about

Orphaned child spans expire silently. The OTLP ingestion endpoint is asynchronous: it accepts a batch, returns 200, and materialises runs in the background. A child span whose parent never arrives sits in a buffer and then expires. It never appears as a run. No error surfaces, because the 200 was already sent.

The actionable consequence: a partially instrumented service looks healthy while dropping data. If you are mid-migration and instrumenting service by service, reconcile run counts against your own request counts. Do not trust the dashboard to tell you what is missing. The architecture guarantees it cannot.

Second behaviour: retention auto-upgrade triggers. A trace moves from base to extended retention when feedback is added to any run on that trace (manual annotation, an online evaluator, or an SDK call), when an annotation queue receives any run from the trace, or when an automation rule matches any run within it. Extended retention bills. LangChain’s billing documentation acknowledges that auto-upgrades affect your bill.

The asymmetry is the part worth reporting. You can opt out of the upgrade when creating or editing an online evaluator. The annotation-queue and automation-rule paths have no equivalent switch. The features a team naturally adopts as it matures are the ones that quietly change what it pays.

Both behaviours are documented rather than hidden, which is to LangChain’s credit. This is a due-diligence section, not an exposé. Both claims trace to OpenObserve’s audit and should be re-verified against current LangSmith docs, with the check dated at publication.

The parallel question is the one nobody asks of the alternatives. What is each one’s documented silent-drop behaviour? Most publish nothing on the subject. That absence is itself a finding.

Screen for project health before you screen for features

Four signals, each answering a different question. Last push date: is anyone there. Latest release tag and date: is it shipping, not merely committing. Open-issue count read against repo size: backlog or abandonment. Ownership change in the last 18 months: whose roadmap is this now. Run all four on any open-source LangSmith alternative before you read a feature list.

Project	Stars	Open issues	Last push	Latest release	Ownership change
langfuse/langfuse	35,386	988	2026-10-05	v4.50.0 (2026-10-02)	ClickHouse, Jan 2026
mlflow/mlflow	28,258	2,160	2026-10-05	v3.16.1 (2026-09-17)	Linux Foundation
langchain-ai/langchain	147,450	617	—	langchain-core 1.6.6 (2026-09-29)	None
braintrustdata/braintrust-proxy	412	104	2026-10-04	—	None
Helicone	~4.4k	—	—	—	Mintlify, 3 Mar 2026

Read MLflow’s 2,160 open issues honestly rather than as a gotcha. That is a decade-old project spanning classical ML and GenAI, with a correspondingly broad surface. Daily pushes and monthly releases are the live signal. The backlog is a function of scope and age.

Staleness is easy to demonstrate on this keyword. OpenObserve’s July 2026 table lists Langfuse at roughly 31,500 stars. ZenML’s November 2025 table lists 17,900. The repo sits at 35,386 today. Any star-count table in this category is a dated snapshot and should be labelled as one, including this page’s.

ZenML’s table has a second problem, and it works as a verification example. It lists “LangSmith” at 670 stars. That is the langsmith-sdk client repository, not a platform, so the row compares a product to an SDK. Its “105M PyPI downloads” for LangSmith counts SDK installs pulled in transitively by LangChain. Neither figure should be repeated.

Ownership changes to factor in. Langfuse was acquired by ClickHouse in January 2026, with the MIT core intact, self-hosting still working at production scale, and Cloud endpoints unchanged per OpenObserve’s audit. Verify that independently. Mintlify acquired Helicone and announced on 3 March 2026 that “Helicone’s services will remain live for the foreseeable future in maintenance mode.” That covers security updates, new model support and bug fixes. No new capability is coming.

The archived-repo check, demonstrated: an archived repository with zero open issues and no push for six months is not a healthy project that ran out of bugs. It is a closed project. Read “archived” and “last push” together, then apply that pair to anything a roundup recommends.

Visual needed: Project-health scorecard with verification date stamp Visual brief: Project-health scorecard with a visible “checked on 5 October 2026” stamp in the header. Columns: stars, open issues, last push, latest release and date, licence, ownership change in last 18 months. Gather every row on one day. Cite Helicone’s and Langfuse’s acquisition announcements from primary sources, not roundups.

The nine open-source LangSmith alternatives

Every entry below uses the same five fields: what it is, licence reality, where it beats LangSmith, where it does not, who should pick it. The “where it does not” field never gets skipped. That field is why this page is worth linking. Ordering rule, stated so it is auditable: entries run from closest runnable replacement for a self-hosting LangSmith team to furthest, not by vendor preference. Every weakness claim carries a GitHub issue URL, a LICENSE reference, or a docs URL. There is no “users report” phrasing anywhere on this page.

1. Langfuse, the closest like-for-like swap

What you get self-hosted: tracing on an observations data model, prompt management with versioning and a production tag, dataset management, offline and online evaluation, annotation queues, and usage-based rather than per-seat billing. Docker Compose for evaluation. Kubernetes with ClickHouse, Postgres, Redis and object storage for production.

Licence reality: MIT except the ee/ directories, which is why GitHub reports NOASSERTION. Self-hosted SSO and organisation-level RBAC ship in the free OSS distribution. Project-level RBAC does not.

Where it genuinely beats LangSmith: no sales call to self-host, framework-agnostic by design via OTLP rather than by accommodation, and raw SQL access to your own ClickHouse when self-hosted. Querying your own columnar store is a different class of data access from paginating a vendor API. Its changelog shows active work on the evaluation surface through September 2026, including evaluators run over historical observations to backfill scores, Assistant-driven dataset and dashboard creation across thousands of observations, and alert creation (langfuse.com/changelog).

Where it does not, with citations:

• Pydantic v1 dependency breaks on Python 3.14; issue opened the day 3.14 shipped, 179 reactions (issues/9618).
• Experiments and Evaluators cannot extract thinking and text blocks from Anthropic reasoning models such as claude-haiku-4-5-20251001, breaking those workflows, 62 reactions (issues/11109).
• Filtering traces by numeric score returns no traces or an incomplete set, 50 reactions (issues/11874).
• langfuse.langchain.CallbackHandler raises “Failed to detach context” repeatedly under async LangChain or LangGraph methods such as ainvoke, 62 reactions (issues/8780).

Two more if your stack matches. FastAPI StreamingResponse resets ContextVars after the first yielded chunk, recording one request as multiple traces (issues/3961). Importing langfuse in a Jest test throws a dynamic-import error without --experimental-vm-modules, 57 reactions (issues/5704).

Who should pick it: anyone who wants the closest runnable equivalent of LangSmith. The honest counter-case: if your application is deeply LangGraph-shaped, LangSmith’s native rendering of that structure is still better, a point Langfuse’s own comparison page concedes in different words.

2. Comet Opik, the licence-clean full platform

Apache-2.0 across the repository with no secondary licence detected. The self-hostable build is described as the full platform: backend, web application, tracing, datasets, experiments, evaluations, prompt management and online evaluation.

Evaluation depth is the differentiator against lighter tools. LLM-as-a-judge metrics for hallucination, relevance and moderation ship in the box rather than needing to be hand-written against your own rubric.

Where it does not: Opik sits inside Comet’s broader experiment-tracking platform, so parts of the framing assume an ML lifecycle you may not have. Comet sells an Enterprise tier carrying SSO and compliance certifications. Verify which security controls are in the OSS build rather than assuming Apache-2.0 means everything.

Note its absence. Opik is missing from most open-source LangSmith alternative roundups despite being one of the largest projects in the category. Absence from comparison posts is a marketing signal, not a quality signal. When nine of ten ranking pages are vendor-authored, the tools that do not pay for content marketing are the ones that go unmentioned.

Who should pick it: legal review is your tightest constraint, or you want serious eval tooling with no per-seat bill.

3. Arize Phoenix, uncapped self-hosting if ELv2 clears your bar

Free to self-host with no usage caps or feature gates. Runs fully air-gapped with nothing reported back to Arize AI. Prompt management is first-class: versioning, deployment, a playground, span replay, and SDKs to sync prompts back into code.

The licence is the decision, and it belongs here rather than in a footnote. Elastic License 2.0 is source-available, not OSI-approved.

Instrumentation uses OpenInference conventions, themselves Apache-2.0 and supported by several other backends. Portability is real but conditional, because choosing OpenInference is still choosing a convention rather than vanilla OpenTelemetry gen_ai.* semantic conventions.

Correcting the competitor framing: the dev.to post ranking fourth dismisses Phoenix for “poor langchain.js and TypeScript integrations,” in a page stamped accurate as of December 2024. That is a two-year-old assessment. Re-check it against current docs rather than repeating it.

Who should pick it: uncapped self-hosting with strong eval and prompt tooling, and ELv2 passes legal.

4. MLflow, foundation governance and the widest framework coverage

Apache-2.0 under the Linux Foundation. That is a different ownership story from every venture-backed tool on this list, and it is the one property no acquisition can revoke.

Architecture is the practical advantage over Langfuse-class tools: a server, one SQL database (PostgreSQL, MySQL, MSSQL or SQLite) and one object store (S3, R2, GCS, Azure Blob, HDFS or local). Far less to operate than ClickHouse plus Postgres plus Redis.

MLflow’s own page at mlflow.org/langsmith-alternative/ claims LangSmith lacks judge alignment and optimisation, judge versioning, multi-turn conversation evaluation, conversation simulation, automated prompt optimisation via GEPA and memAlign, and a built-in AI gateway. Those are vendor claims about a competitor, presented in checkmark tables with no docs citations and no check date. Treat them as unverified. Check each against LangSmith’s current documentation before repeating any of them. The same applies to MLflow’s “30 million monthly downloads” and “60%+ of the Fortune 500,” which are self-reported and unverifiable from the page.

Verifiable instead: 28,258 stars, 2,160 open issues, last push 2026-10-05, latest release v3.16.1 on 2026-09-17, and a 3.16.0 release note describing a redesigned trace explorer as the default experience, custom trace views generated from a plain-English prompt, and first-class span links for connecting spans across traces (mlflow.org/releases).

Where it does not: with no existing MLflow footprint it is heavier to adopt than a purpose-built LLM tool, and its centre of gravity remains the ML lifecycle rather than agent debugging.

Who should pick it: MLflow already runs in your organisation, or foundation governance outranks category focus.

5. Laminar, built for agent-shaped traces

The premise is structural. Agent traces are a different shape from prompt-and-completion logging: deeper, longer-running, far larger per interaction. Storage and UI assumptions follow from that shape rather than being retrofitted onto it.

Concrete advantages: billing on ingested data volume rather than seats or traces, raw SQL over trace data instead of a fixed query UI, and a debugger that records and replays runs against a cache. That last one matters when you are iterating on an agent loop and do not want to pay for the same twelve LLM calls forty times.

Where it does not: at roughly 3,100 stars it is the youngest project in the category, with a smaller ecosystem and fewer third-party integration guides. Prompt management is playground-style span replay rather than the versioning-and-deploy workflow Langfuse and Phoenix ship.

Run this page’s own project-health check on it before committing: last push, latest release tag and date, open issues against repo size. A 3k-star project can be perfectly healthy. The check is cheap, and the conclusion should come from the repo rather than from this paragraph.

Who should pick it: you run agents and per-seat or per-trace billing has stopped being predictable.

6. Agenta, playground-first open source

MIT-licensed functional features, self-hostable, combining a prompt playground with side-by-side prompt and model comparison, full version history, code-free deploys, LLM-as-a-judge and custom evaluators with full-trace scoring, and human annotation. The differentiator is non-engineer workflow. A product manager can compare two prompts across two models without opening a terminal.

Where it does not: no native CI/CD gating to block merges on eval regressions, production traces do not convert into regression datasets automatically, and the hosted free tier caps at 2 seats and 5,000 traces/month. Read the current pricing page directly before you budget, because the tiers are the thing competitor roundups get wrong most often.

Who should pick it: you want playground, prompt management, evals and observability in one self-hostable product, and can live without pipeline gating.

7. Traceloop and OpenLLMetry, instrument once and decide the backend later

What it is: a set of Apache-2.0 OpenTelemetry instrumentation libraries that patch the OpenAI, Anthropic, LangChain and LlamaIndex clients and emit standard gen_ai.* spans to any OTLP endpoint. What it is not: storage, a query layer, or an evaluation engine. It stores nothing and evaluates nothing.

It belongs on this list anyway, because separating instrumentation from storage is the only durable answer to lock-in. Instrument once, fan out to Langfuse, Phoenix or a general observability backend, and changing your mind later never touches application code. The same logic extends to LiteLLM, PortKey and other AI gateway layers that sit in front of model calls, and to SDK-native tracing in the Vercel AI SDK, DSPy, Pydantic AI, CrewAI, AutoGen, Semantic Kernel and Google’s Agent Development Kit.

The honest caveat: adopting it means you still have a backend to choose. Pair it with one of the platforms above rather than treating it as a replacement.

Who should pick it: you have not committed to a backend, or you are running a bake-off and want to dual-write to two candidates for a month.

8. General observability backends: OpenObserve, Grafana-style stacks

The argument is investigative. LLM spans land in the same columnar store as application traces, infrastructure logs and metrics. So “was that slow response the model or the vector database” is one query rather than a cross-tool reconstruction. OpenObserve is AGPL-3.0 and self-hosts as a single binary. It also lets you configure per-model input and output pricing, so cost tracking reflects your actual billing agreement rather than a bundled price table.

The disqualifier for many readers, stated plainly: no prompt management, no playground, no dataset management. The build-and-iterate half of LangSmith has no equivalent here, and evaluations are an enterprise feature and narrower than a dedicated eval platform.

The resolution teams commonly reach is two products: a development-focused eval tool alongside a general observability backend. That is a real answer. It is not a single-tool answer.

Disclosure: openobserve.ai’s roundup ranks its own product first and says so. Its licence-audit and data-portability framing is the best on the SERP and deserves credit. Its ~20,300-star figure and July 2026 check dates should be verified independently.

Prior art for the same idea: MyScale Telemetry, an open-source LangSmith alternative built on a SQL vector database with Grafana dashboards, positioned to reduce system complexity and improve data security (news.ycombinator.com/item?id=40506144).

9. The ones marketed as alternatives that are not open source

Six tools get sold as open-source LangSmith alternatives and do not qualify.

Braintrust. The platform is closed-source and self-hosting is Enterprise-only, by its own article’s admission. What is open is braintrust-proxy: MIT, 412 stars, 104 open issues, last push 2026-10-04. An MIT proxy repository is not an open-source platform. Its changelog does document one thing worth comparing across tools: span customizers that redact sensitive values before upload, in the TypeScript (v3.35.0+), Python (v0.43.0+), Go (v0.16.0+) and Java SDKs (braintrust.dev/changelog).

Confident AI. DeepEval the evaluation library is open source and widely used, alongside RAGAS and TruLens. The Confident AI platform is not self-hostable OSS. Its own FAQ answers “What is the best open-source alternative to LangSmith?” with “Langfuse is the best fully open-source alternative to LangSmith”. That concession is worth more than its product pitch. Its page also opens with a Gartner prediction carrying no report ID, date or link, and cites a “CHI 2025 study” with no title, authors or DOI. Both are unverifiable as printed.

Galileo and Fiddler AI. SaaS and SaaS/VPC respectively, with no OSS self-host path. Galileo’s Luna-2 models and Fiddler’s explainability tooling are useful if guardrails or regulated-industry explainability is the requirement. Out of scope for this keyword.

Helicone. Open source, roughly 4,400 stars, and in maintenance mode since the Mintlify acquisition announced 3 March 2026. Fine for existing users. A poor basis for new adoption. That current roundups still list it as a live recommendation is a maintenance failure in the competing content, not a judgement on Helicone.

Lunary. Open core. The split between the OSS core and the Enterprise tier is the thing to check here, and the only assessment of that split on this SERP is two years old. Read Lunary’s current self-hosting docs directly rather than any summary of them, including this one.

LangWatch sits in the adjacent set worth checking directly rather than through roundups, since its licence and self-host terms are the deciding facts and no page on this SERP audits them.

Where each tool actually breaks: a failure-mode catalogue from the issue trackers

Every open-source LangSmith alternative breaks somewhere. No page in the current top ten cites a single GitHub issue, changelog entry or repository fact. Every weakness claim across all ten results is vendor-sourced or unattributed. This table exists to fix that.

Tool	Failure mode	Affects	Reactions	Issue
Langfuse	Pydantic v1 dependency breaks on Python 3.14	Python 3.14 users	179	9618
Langfuse	Google ADK integration still a docs request	Google ADK stacks	64	6588
Langfuse	”Failed to detach context” repeats under async ainvoke	LangChain/LangGraph async	62	8780
Langfuse	Anthropic thinking blocks unparsed, breaking Experiments/Evaluators	Reasoning models	62	11109
Langfuse	No native organizationId; metadata unusable as dashboard dimension	Multi-tenant teams	56	12614
Langfuse	Jest import fails without --experimental-vm-modules	TS test suites	57	5704
Langfuse	No py.typed marker, so not PEP 561-compliant	Downstream mypy	51	2169
Langfuse	Numeric-score trace filters return incomplete results	LLM-as-judge triage	50	11874
Langfuse	LangfuseMedia images render as a button, not inline	Multimodal apps	41	4555
Langfuse	FastAPI StreamingResponse fragments one request into several traces	FastAPI streaming	—	3961
braintrust-proxy	Stale Fireworks DeepSeek V4 Flash pricing in bundled catalogue	Cost dashboards	—	1151
braintrust-proxy	Perplexity and Mistral models incorrectly mapped	Router integrations	—	115
braintrust-proxy	Gemini live-preview model re-removed by LiteLLM sync overwrite	Gemini preview users	—	1296
braintrust-proxy	Dangling Anthropic parent reference	Catalogue consumers	—	1253

Reports from public issue trackers, read on the verification date above. Reaction counts are a rough severity proxy, nothing more. Nothing in this table was reproduced; reproducing these against current releases requires a real deployment.

Three of those Langfuse rows deserve expansion, because they are not bugs in the ordinary sense. The missing py.typed marker means an SDK that is fully typed internally cannot be type-checked against by downstream mypy, open since issue #2169. The missing native organizationId field pushes multi-tenant teams to store tenant identity in trace metadata, and metadata fields cannot then be used as a breakdown dimension in dashboard widgets. That is a design constraint that compounds, with 56 reactions behind it. And the numeric-score filter returning incomplete sets silently undermines exactly the triage workflow that LLM-as-a-judge scoring exists to support.

The braintrust-proxy rows teach a structural lesson rather than a bug list. Its bundled model catalogue carried launch-day May 2025 Fireworks pricing for DeepSeek V4 Flash at $0.14/M input against a current official $0.22/M. A cost dashboard built on a bundled price table inherits that drift and reports a confidently wrong number. This generalises to every tool on this list that computes spend from a bundled catalogue, which is most of them. OpenObserve’s per-model price configuration is the structural answer.

Method, so this table stays useful as it ages. Search each candidate’s repository for your framework name plus context, streaming and async, and for your Python or Node version, before you commit a sprint to migration. The specific issues change. The categories of breakage do not.

Visual needed: Failure-mode catalogue with status-as-of column Visual brief: Failure-mode catalogue table with columns for tool, failure mode in one sentence, affected stack and version, reaction count, open or closed status, issue URL, and a “status as of” column so the table ages honestly. Re-open each cited issue on the publication date to confirm current title, status and reaction count.

What self-hosting actually costs (the bill nobody models)

Free to self-host is the headline claim for almost every open-source LangSmith alternative. The infrastructure bill behind it is never priced, even though cost is named as the number-one migration driver on nearly every page. Braintrust’s single most useful sentence is its Langfuse con: “requires PostgreSQL, ClickHouse, Redis and Kubernetes”. It never costs that either.

Infrastructure by architecture:

Tool	Required infrastructure	Operational weight
Langfuse (production)	ClickHouse + Postgres + Redis + object storage, typically on Kubernetes	Heaviest
Langfuse (evaluation)	Docker Compose	Light
MLflow	Server + one SQL DB + one object store	Moderate
Arize Phoenix	Container	Light
OpenObserve	Single binary	Lightest

The spread between a single binary and a four-component Kubernetes deployment is the real cost difference between these tools. Not the licence.

Visual needed: Total-cost-of-ownership curve by monthly trace volume Visual brief: Total-cost-of-ownership curve. Y-axis monthly cost, x-axis monthly trace volume from 10k to 10M, four lines: LangSmith Plus at 5 seats, Langfuse Cloud tiers, self-hosted Langfuse infrastructure, self-hosted MLflow infrastructure, with crossover points annotated. Inputs required beside the chart: published LangSmith and Langfuse Cloud list prices; managed ClickHouse, managed Postgres, managed Redis and object storage list prices taken from one named cloud provider’s own pricing page at stated instance sizes; a visible assumption for engineer time. Label it a list-price derivation, not a measured bill, and link every price page.

The managed columns, at published list prices:

Plan	Price	Includes
Langfuse Hobby	Free	50,000 units/month, 2 users
Langfuse Core	$29/month	Usage-metered, no seat fees
Langfuse Pro	$199/month	Usage-metered, no seat fees
Langfuse Enterprise	$2,499/month	—
LangSmith Developer	Free	5,000 base traces, 1 seat
LangSmith Plus	$39/seat/month	10,000 base traces + $0.005/base trace
LangSmith Enterprise	Custom	Self-hosting add-on

List prices as published by Langfuse’s comparison page. Verify both against each vendor’s own pricing page before budgeting.

Langfuse’s own worked example totals $621/month on Langfuse Pro against $3,895/month on LangSmith Plus at list prices. Its inputs: 500,000 traces/month, 10 spans per trace, 1 score per trace, 12-month retention, 5 users. That is a vendor-constructed comparison using inputs the vendor selected. It models neither self-hosting infrastructure nor on-call time, which is precisely the choice an open-source searcher is making. Re-derive the inputs before citing it.

Where self-hosting loses, stated plainly. At low volume a managed free or Core tier beats any self-host once you price an on-call engineer. A $29/month Core subscription costs less than two hours of engineer time per month, and a four-component ClickHouse deployment will consume more than two hours in some months.

The sensitivity input that cuts both ways comes from Langfuse itself: it bills every span while LangSmith bills the trace. Shallow traces favour Langfuse’s model, and the gap narrows as traces deepen. An agent workload with 40 spans per trace lands somewhere very different from a single-call summariser. Model your own span-per-trace ratio before trusting anyone’s worked example, including this one.

This model is a derivation from published list prices as of the publication date. It is not an observed invoice, and no migration is being claimed.

One question genuinely requires hands-on work and should be funded as such rather than guessed. What does it cost to run ClickHouse at trace volumes above a few million spans a month? Real ingest throughput, p95 query latency and the engineer-hours actually consumed cannot be answered from pricing pages. That takes a deployment, and this page does not have one.

Can your data leave? Instrumentation portability and export

Two lock-ins, and they are not equal. Leaving a storage engine is an export job with a defined end. Leaving a vendor SDK is a rewrite across every instrumented service. Instrumentation lock-in is the worse one, it is the axis on which open-source LangSmith alternatives really differ, and nobody prices it at adoption time.

Tool	Instrumentation portability	Export mechanism	Beyond spans?
Langfuse (self-hosted)	OTLP + native SDK	SQL on your own ClickHouse	Scores, datasets, prompts via API
MLflow	Native + autolog()	SQL on your own DB + object store	Artifacts, runs, experiments
Arize Phoenix	OpenInference conventions	Self-hosted store, API	Prompts, datasets
OpenObserve	Vanilla OTel gen_ai.*	SQL on your own store	Spans, logs, metrics
OpenLLMetry	Vanilla OTel gen_ai.*	N/A, no storage	N/A
LangSmith	Native SDK (@traceable, Run Tree) + OTLP	API pagination	Unaudited

On the instrumentation axis the ranking runs: vanilla OTel gen_ai.* semantic conventions (most portable), OpenInference conventions (portable across several backends, still a convention choice), vendor-native SDK with an OTel path alongside it, vendor-native SDK only (least portable).

On the export axis: SQL access to your own store when self-hosted beats documented bulk export to S3, GCS or Azure Blob, which beats API-only pagination, which beats enterprise-gated bulk export. Confirm which of those four you are buying by reading the vendor’s export docs, not a comparison table.

Three pre-commitment checks a reader can run in an afternoon:

1. Export one day of traces and try to re-ingest them into a second backend. Not read them. Re-ingest them.
2. Confirm that scores, datasets and prompts export too, not just spans. Prompt version history with commit hashes is the thing teams discover is stranded.
3. Confirm you can dual-write to two backends during a migration window.

An OTLP collector fanning out to two endpoints is the cheapest de-risking move available in this category, and it is the entire reason OpenLLMetry earns a slot on this list.

Visual needed: Instrumentation versus storage lock-in diagram Visual brief: Instrumentation-versus-storage lock-in diagram. Application code, then the instrumentation layer (vendor SDK, OpenInference, or vanilla OTel gen_ai.*), then an OTLP collector with fan-out, then backends. Annotate which arrows require a code rewrite to change and which require only a config change. Caption with a working collector fan-out config.

Migrating off LangSmith: a concrete sequence

Order the steps to minimise blast radius. Stand up the target self-hosted. Dual-write via an OTLP collector for a fixed window. Reconcile trace counts against your own request logs. Migrate datasets and prompts. Cut over, then decommission.

Reconciliation is not optional, and the reason is the orphaned-span expiry behaviour above. A partially instrumented service looks healthy while dropping data, because the ingestion endpoint already returned 200. Compare counts against your own request logs. Do not eyeball dashboards.

Scope these before you start, because they typically do not migrate cleanly: annotation-queue history, evaluator configurations, retention state, and prompt version history with its commit hashes.

The instrumentation swap has two very different risk profiles. Replacing LangChain environment variables with the target’s callback handler touches application code in every service. Repointing an existing OTel exporter touches config. If you are already on vanilla OTel, this is a one-line change and a redeploy. If you are on @traceable and Run Tree, it is a per-service code change with its own review cycle.

Per-framework sharp edges to check against the failure-mode table before you schedule the work: async ainvoke context propagation, FastAPI streaming responses, TypeScript and Jest test suites, and your Python version against the target SDK’s Pydantic dependency. The Python 3.14 issue alone can stall a migration that looked like a configuration change.

Vendor claims of a same-day switch are marketing. How long it really takes depends on service count, instrumentation style and how much annotation history matters to you. Scope it from those three variables rather than from anyone’s published estimate, including a range this page could invent.

Which one to pick, by your tightest constraint

No open-source LangSmith alternative wins on every axis, so pick on the constraint that actually binds you.

Your tightest constraint	Pick	Accept
Closest self-hosted swap for LangSmith	Langfuse	ee/ carve-out, the open SDK issues above
Strictest legal review	Comet Opik	Framing assumes an ML lifecycle
Foundation governance + existing ML practice	MLflow	Heavier adoption, ML-lifecycle centre of gravity
Uncapped self-hosting and air-gap	Arize Phoenix	ELv2 is not OSI-approved
Agent workloads, unpredictable seat/trace bills	Laminar	Smallest ecosystem, lighter prompt management
Playground for non-engineers	Agenta	No CI/CD eval gating
One backend for LLM spans + infra telemetry	OpenObserve or a Grafana-style stack	No prompt management, no datasets
Not yet decided	OpenLLMetry + dual-write	You still have a backend to choose

Staying on LangSmith is a legitimate outcome, and a comparison page that never says so is selling something. If you are all-in on LangGraph, comfortably under the retention ceiling and running a team of three, the migration cost exceeds the lock-in cost. Run the retention-upgrade triggers against your actual workflow, price twelve months at your current seat count, and if the number is smaller than two engineer-weeks, stay where you are.

Visual needed: Decision flow keyed to constraints, with stay-on-LangSmith as a terminal outcome Visual brief: Decision flow keyed to constraints, with “stay on LangSmith” as an explicit terminal outcome. Every branch must trace back to a cited row in the licence matrix or the cost model.

Frequently Asked Questions

Is LangSmith open source?

No. LangChain and LangGraph are MIT-licensed and the langsmith-sdk client is open source. The LangSmith platform is not: the backend, the UI and the storage layer are published nowhere. Self-hosting is an Enterprise add-on, so the open-source SDK does not give you a runnable platform.

Can you self-host LangSmith?

Only on Enterprise. LangChain’s docs describe self-hosted LangSmith as an add-on for its largest, most security-conscious customers, with Kubernetes as the documented install path and platform guides for AWS, GCP and Azure. Developer and Plus tiers are cloud-only, which turns a data-residency requirement into a procurement cycle.

What is the best open-source alternative to LangSmith?

Langfuse, for the closest like-for-like self-hostable swap: tracing, prompts, datasets and evals in one product, at 35,386 stars on the verification date above. The caveat is that it is MIT except its ee/ directories. Comet Opik wins if clean whole-repo Apache-2.0 is binding. MLflow wins if Linux Foundation governance matters more.

Is Langfuse open source?

Mostly. The README states the repository is MIT-licensed except for the ee folders, which is why GitHub reports NOASSERTION. The core genuinely runs at production scale, and self-hosted SSO and organisation-level RBAC ship in the free distribution. Project-level RBAC sits outside the MIT build. Check the features you need against the build you can run.

Does LangSmith require LangChain?

No. LangSmith accepts OpenTelemetry traces and instruments non-LangChain applications through the @traceable decorator and wrappers like wrap_openai. Its advantage is zero-config: one environment variable traces a LangChain or LangGraph app, while anything else needs explicit instrumentation. Framework-agnostic teams see less of the benefit they pay for.

How does LangSmith pricing compare to open-source alternatives?

LangSmith Plus is $39/seat/month with 10,000 base traces, then $0.005 per base trace and $0.0025 for the extended-retention upgrade. The free Developer tier allows one seat. Langfuse Cloud meters usage with no seat fees: Hobby free at 50,000 units, Core $29, Pro $199. Self-hosting is licence-free, not cost-free. Langfuse at production scale wants ClickHouse, Postgres, Redis and object storage, and that bill plus on-call time is the real comparison.

LangSmith vs Langfuse: which should I choose?

Choose LangSmith if you are committed to LangChain or LangGraph and want native Run Tree rendering, turnkey threshold alerting and annotation queues with no infrastructure to run. Choose Langfuse if you need self-hosting without a sales conversation, usage-based billing, or SQL access to your own trace store. Both vendors publish head-to-head pages about each other. Neither is neutral.

Which open-source LangSmith alternative has the most GitHub stars?

Langfuse, at 35,386 stars with 988 open issues, last pushed 2026-10-05, release v4.50.0 on 2026-10-02. MLflow is second at 28,258. Star counts proxy ecosystem size rather than quality, and every published table here is a dated snapshot: OpenObserve listed Langfuse at ~31.5k in July 2026 and ZenML at 17.9k in November 2025.

What do practitioners on Reddit and Hacker News actually recommend?

Langfuse’s Launch HN (YC W23) drew 276 points and its earlier Show HN 178, which is the traction behind its default-recommendation status. Two checkable themes recur. A local-first, SQLite-backed alternative built because “LangSmith needs a cloud account just to see my own traces” reported 800+ downloads in two days (item?id=48063206). And builders frame the category gap as diagnosis over detection: one describes existing tools as telling you which agent failed, while the gap is why it failed (item?id=49701608).

Is Helicone still a good LangSmith alternative?

Not for new adoption. Mintlify acquired Helicone and announced on 3 March 2026 that services remain live “in maintenance mode”, covering security updates, new models and bug fixes, with no new capability coming. Fair for existing users. A scheduled migration for anyone starting now. It still appears in current roundups as a live recommendation.

Does open source mean I can run every feature myself?

No, and that is the question this keyword should be asking. Three commitments hide behind one checkmark: clean permissive (Opik, MLflow, Laminar, OpenLLMetry), open core (Langfuse, MIT except ee/), and source-available (Phoenix, ELv2, not OSI-approved). Check three things: can I run the whole product, are SSO, RBAC and audit logs in that build, and what may I do with it afterwards.

Further reading

• Best open-source LLM observability tools, a category overview
• OpenTelemetry gen_ai conventions in practice
• Self-hosting Langfuse on Kubernetes: ClickHouse, Postgres and Redis sizing
• LangSmith pricing explained: seats, base traces, retention upgrades
• Langfuse vs Opik vs Phoenix: eval feature comparison
• Handling PII in telemetry: masking, redaction, span customizers
• Migrating off Helicone after the Mintlify acquisition
• Open-source licences for buyers: MIT, Apache-2.0, AGPL, ELv2
• Building LLM-as-a-judge evaluators on your own model keys
• CI/CD quality gates for LLM applications
• What the ClickHouse acquisition changed for Langfuse
• Why agent spans break prompt-completion tooling

---

Limitations of this page. Nothing here was deployed, benchmarked or measured. Two questions require hands-on work and are therefore unanswered: real ingest throughput and p95 query latency for each self-hosted backend at a few million spans per month, and reproduction of the SDK context-propagation failures in the catalogue above against current releases. Every licence, repo fact and price carries a check date and a URL so you can re-run the audit yourself. Where a claim existed only on a vendor page about a competitor, this page cut it rather than launder it into a finding.

Facts verified 5 October 2026. A changelog at each update will record which figures moved. Star counts, issue counts and prices in this langsmith alternative open-source audit are snapshots, and the audit method matters more than the numbers: open the LICENSE file at the commit you deploy, read last-push and archived status together, search the issue tracker for your framework and runtime version, and price the infrastructure before you believe the word “free”.