traceroot vs. LangSmith
An open-source LangSmith alternative with unlimited seats: tracing, git context, production judges, root cause analysis and pricing compared.
On this page
Your agent gave a customer a wrong answer, and every span in the trace is green. Both traceroot and LangSmith will show you that trace. This post compares what each one does next, what it runs on, and what it costs.
TL;DR
About six times cheaper in our example. For three engineers and an agent that runs 1,000 times a day with 10 spans per run, every run judged in production, traceroot Starter is $46 a month (traceroot pricing). LangSmith Plus is $292 a month, because every trace an online evaluator scores is kept 180 days by default (usage and billing); $217 if you turn that off. Judge model tokens are left out on both sides, and Engine runs are billed on top at about 7 to 45 LSU ($7 to $45) each (LangSmith pricing).
Open source and self-hostable. traceroot's full source is on GitHub and runs on Docker Compose, from the SDKs to the detector worker and the root cause analysis agent. LangSmith's SDKs and CLI are public; the platform is LangChain's cloud, and self-hosted LangSmith is an add-on to the Enterprise plan installed on Kubernetes.
The same ClickHouse foundation, simpler to run yourself. traceroot stores raw batches in object storage first, then a worker writes them to ClickHouse. Self-hosted LangSmith also keeps traces in ClickHouse, or SmithDB on new installs, so both are built for high trace volume. Both run ClickHouse, PostgreSQL, Redis and object storage. traceroot comes up with one Docker Compose command (docker-compose.prod.yml); self-hosted LangSmith is a Helm chart on Kubernetes and needs an Enterprise license (Kubernetes guide).
Full GitHub context on every trace. The traceroot SDK records the repository and Git ref on every span, and the file, line and function for instrumented functions. The LangSmith SDK records a revision_id in run metadata, from an environment variable you set or from git describe.
Root cause analysis at the recorded commit, included in the plan. traceroot's agent clones your repository at the commit on the trace and returns the root cause with its code location, with 100 runs a month on Starter. LangSmith Engine reads the branch you connect and can match a trace to its commit when revision_id is set; on Cloud it scans every 6 hours and is metered per run.
Choose traceroot if you want to keep improving agents in production for about a sixth of LangSmith's cost in our example, with unlimited seats: per-trace judges, Signals with full GitHub context, root cause analysis at the commit that ran and an optional pull request, on an open-source stack you can self-host on Docker Compose, with a CLI your coding agent can drive.
Choose LangSmith if your agents are built on LangChain or LangGraph and you want tracing, evaluation and managed agent deployment from the same vendor on a hosted platform, and per-seat, per-trace pricing fits your budget.
At a glance
| LangSmith | traceroot | |
|---|---|---|
| Open source | — SDKs and CLI | ✓ |
| Self-hosting | ✓ Enterprise add-on | ✓ |
| Step-by-step agent tracing | ✓ | ✓ |
| OpenTelemetry ingestion | ✓ | ✓ |
| Python and TypeScript SDKs | ✓ | ✓ |
| Framework integrations | ✓ | ✓ |
| CLI | ✓ | ✓ |
| Cost and token tracking | ✓ | ✓ |
| Dashboards and Slack alerts | ✓ | ✓ |
| Datasets and experiments | ✓ | ✓ |
| LLM judge on production traces | ✓ Online evaluators | ✓ Detectors |
| Built-in agent | ✓ Engine | ✓ Root cause analysis agent |
| Recurring failures tracked with a status | ✓ Engine issues | ✓ Signals |
| Repository and Git context on traces | Commit via revision_id | ✓ SDK Git context |
| Reads your code at the traced commit | ✓ If revision_id set | ✓ |
| Opens a pull request | ✓ | ✓ Optional |
| Paid plans from | $39 a seat a month | $30 a month |
Open source and self-hosting
Traces hold your prompts, your customers' words and every tool call your agent made, so where they live matters.
traceroot is open source and self-hostable. make prod in the repository brings up the full stack with Docker Compose: the web app, the API, the ingest worker, the detector worker, the root cause analysis agent and the databases (docker-compose.prod.yml). The code you self-host is the code behind traceroot Cloud. The SDKs and the CLI live in their own repositories (traceroot-py, traceroot-ts, traceroot-cli).
LangSmith's public code is its client side: the Python and TypeScript SDKs in langsmith-sdk and the Go CLI in langsmith-cli. The platform itself runs on LangChain's cloud in the US or EU. On the pricing page, Developer and Plus are cloud only, and Enterprise lists "Cloud, Hybrid, or Self-Hosted". The self-hosting docs describe self-hosted LangSmith as "an add-on to the Enterprise plan", installed on Kubernetes with a license key. So LangSmith comes in two editions: LangSmith Cloud (Developer, Plus and Enterprise) and self-hosted LangSmith (Enterprise only), and we label which one each point covers.
Architecture, from SDK to storage
Both products take OpenTelemetry spans and both keep traces in ClickHouse, a columnar database built for this kind of volume. What differs is how much of the path you can read and how much you have to run.
traceroot buffers OTLP batches in object storage, a worker writes spans to ClickHouse, a detector worker judges finished traces, and flagged traces become Signals that the root cause analysis agent investigates. LangSmith receives runs from its SDK or OTLP, queues them in Redis, stores them in ClickHouse or SmithDB, runs online evaluators on matching runs, and Engine scans projects for recurring issues.
traceroot is split into services. The public traces endpoint stores each OTLP request body in S3 or MinIO exactly as received, then queues a task with a pointer to it (traces.py). A Celery worker decodes the batch and writes it to ClickHouse (ingest_tasks.py). Because the raw body is stored first, a batch that fails every attempt is moved aside where it can be inspected or replayed (ingest_quarantine.py). This is the queued ingestion design Langfuse documents for its own scale: "All incoming tracing and evaluation events are persisted in S3/Blob Storage first." Spans live in a ClickHouse ReplacingMergeTree table ordered by project, trace and start time, with first-class git_source_file, git_source_line and git_source_function columns (005_rebuild_spans_trace_id_order.sql).
LangSmith's server code is not public, but its self-hosting docs list the services of the self-hosted edition. The platform backend handles run ingestion, and a queue and an ingest queue persist runs and feedback asynchronously, with retries on database errors, backed by Redis. LangSmith "uses ClickHouse as the primary data store for traces and feedback", and from LangSmith 0.17 a new installation can use SmithDB, a columnar store "built for agent trace data", instead. PostgreSQL holds operational data and blob storage holds large trace artifacts. The install is a Helm chart on Kubernetes (Kubernetes guide). Any OpenTelemetry app can send to the /otel endpoint under your LangSmith API URL (OpenTelemetry).
| Dimension | LangSmith | traceroot |
|---|---|---|
| Ingest endpoint | SDK run ingestion, or OTLP at /otel |
OTLP protobuf, stored raw before processing |
| Span store | Self-hosted: ClickHouse or SmithDB | ClickHouse, readable in the repository |
| Deployment | Self-hosted: Kubernetes with Helm, Enterprise license | Docker Compose |
| Retention | Self-hosted: configurable TTL, 14 and 400 days by default | Per-project trace TTL, set with projects update --trace-ttl-days |
Tracing and git context
Both tools trace an agent step by step, and both cover the common agent frameworks.
traceroot's Python SDK depends on the OpenInference instrumentors for OpenAI, Anthropic, LangChain, LlamaIndex, CrewAI, the OpenAI Agents SDK, Google GenAI and more (pyproject.toml), and the TypeScript SDK uses the @arizeai/openinference-* packages (package.json). LangChain and LangGraph agents are traced through the same instrumentors, so you do not have to change frameworks to use traceroot.
What traceroot adds on top is full GitHub context. When the client starts, it resolves the repository and Git ref from explicit settings first, then TRACEROOT_GIT_REPO and TRACEROOT_GIT_REF, then CI variables, then files written at build time, then the local .git directory (client.py). The span processor stamps traceroot.git.repo and traceroot.git.ref on every recording span (span_processor.py), and the observe decorator records the caller's file, line and function (git_context.py). For images without a .git directory, the repository and commit can be injected at build time.

LangSmith traces LangChain and LangGraph natively and lists integrations for other frameworks, model providers and coding agents. You give your own functions spans with the @traceable decorator (custom instrumentation). For code version, the SDK writes a revision_id key into run metadata. It reads LANGSMITH_REVISION_ID, and the docs suggest setting it from git rev-parse HEAD at build time. When the variable is unset, the Python SDK falls back to git describe --tags --always --dirty (_runtime_env.py). The repository URL is recorded with experiments (_runner.py). Run metadata carries revision_id and runtime details such as SDK and Python versions, not a source file or line (_runtime_env.py).
| Dimension | LangSmith | traceroot |
|---|---|---|
| Instrumentation | LangChain and LangGraph natively, @traceable, OpenTelemetry |
OpenInference, wrapped by the traceroot SDKs |
| Repository and Git ref | revision_id from an environment variable or git describe |
Resolved by the SDK and stamped on every span |
| File, line and function | — | Recorded for instrumented functions, stored as columns |
| Trace export with git context | langsmith traces export |
traceroot traces export writes git_context.json next to the spans |
Judging production traffic: detectors and online evaluators
traceroot is built for one job: helping you keep improving your agents in production. A detector is a plain-language description of one behavior you want to catch, such as a wrong answer or an unfinished task, that a judge model checks traces against.
The trigger path is in the open-source backend. The ingest batch that carries a trace's root span takes a Redis lock, checks the detector's filters and a deterministic sample, and enqueues one delayed job. The worker then waits until the trace has been quiet for 60 seconds before judging it (detector_tasks.py). The judge reads every span of the trace, rendered as text with each span kept in its place (judge-input.ts), and each sampled trace gets one verdict.
When a detector says yes, the trace is flagged and grouped into a Signal. For most detectors, traceroot embeds the judge's summary, shortlists the nearest existing Signals, and lets a model decide whether the trace joins one or starts a new one. A Signal is Open, Resolved or Dismissed, and a Resolved Signal reopens by itself when a trace that started after the fix shows the problem again.
LangSmith judges production traffic in two places. Online evaluators run an LLM-as-a-judge prompt, code, or a decision model on runs that match a filter, with a sampling rate to control cost, and record the result as feedback. Multi-turn online evaluators judge a whole thread once it has been idle for a set time (multi-turn evaluators). When an online evaluator scores a run, LangSmith upgrades the whole trace to extended retention unless you turn that off (usage and billing). Engine then "scans each connected tracing project on a dynamic schedule", clusters what it finds into issues ranked by severity, and reopens an issue when the same problem comes back. Alerts fire on thresholds for errors, latency, feedback scores and cost.
| Dimension | LangSmith | traceroot |
|---|---|---|
| Unit that is judged | A run matching the filter, or a whole thread once idle | The whole trace, after it has been quiet for 60 seconds |
| Sampling and filters | Filter and sampling rate per evaluator | Per detector, with deterministic sampling per trace |
| Recurring failures | Engine issues from scheduled scans: open, closed, reopened when they recur | Grouped into Signals: Open, Resolved or Dismissed, reopened automatically on regression |
| Alerts | Metric threshold alerts | Email and Slack digests for new and reopened Signals |
| Plan | Online evaluators; Engine on Cloud Plus and above | Detectors on every plan, 100 runs a month on Free |
From a flagged trace to a fix
With automatic root cause analysis on, a new or reopened Signal starts an investigation. You can also run one by hand.

A root cause is only as good as the context behind it. traceroot's agent is a coding agent, powered by pi-mono, that runs in an isolated sandbox. It clones your repository at the commit recorded on the trace, reads the traces behind the Signal and the file and line on the failing span, and returns a root cause, the code location and a recommended fix. The sandbox can read trace data and source code, but not your production databases or APIs. In docker-compose.prod.yml, the agent is its own service, with Docker or Daytona as the sandbox provider, and it can run on your own model key.

A pull request is optional. If you ask for one, the agent writes the fix and opens a pull request on a new branch through the GitHub App, linked to the trace, for an engineer to review. It never pushes to main.
LangSmith Engine diagnoses an issue "against your traces and connected source code" and proposes a fix as a pull request (Engine). It reads the GitHub repositories or GitLab projects you connect, on the branch you choose, or the default branch when you leave it blank (Connect Engine to your repository). If your traces carry a revision_id, Engine can "match each trace to the commit that produced it" (Set up Engine). Fixes go to new branches, and in self-hosted LangSmith 0.17 pull requests open as drafts (Connect Engine to your repository). On LangSmith Cloud, enabling Engine means trace data "will be processed using LangChain-managed LLM keys" (Set up Engine); on self-hosted LangSmith, Engine needs a license with the Engine entitlement and can run on your own model providers (Engine on self-hosted). On Cloud, Engine is metered in LSUs: the pricing page estimates "~7-45 LSUs" per run, where 1 LSU is $1, and says Engine "is scheduled to run once every 6 hours".
| Dimension | LangSmith | traceroot |
|---|---|---|
| Started by | A scheduled scan of the project | A new or reopened Signal, or by hand |
| Code it reads | The connected branch; commit matched through revision_id |
A clone of your repository at the commit on the trace |
| Model | LangChain-managed on Cloud; your providers on self-hosted | traceroot's hosted model, or your own key on every plan |
| GitHub | Pull request from an Engine fix branch | Optional pull request on a new branch |
| Plan | Cloud Plus and above, about 7 to 45 LSU a run | Included: 30 runs a month on Free, 100 on Starter |
A CLI your coding agent can use
Both tools ship a CLI that a coding agent can call.
traceroot setup signs you in, writes a project API key into your env file, has Claude Code or Codex add the SDK, and waits for the first trace. After that, the CLI is built around the improvement loop. An agent can list flagged traces, read one with its root cause analysis, and export a trace with its git context into the repository it is editing. It can run project-scoped, read-only SQL over spans and traces, and create, update and delete detectors, alerts, dashboards and projects. Every command takes --json, and exit codes are documented.
The LangSmith CLI, langsmith, lists and reads projects, traces, runs and threads, exports traces, and manages datasets, evaluators and experiments, with --format json for scripts. It can search traces in natural language with --ai-search, and langsmith projects issues list lists a project's Engine issues.
| Dimension | LangSmith | traceroot |
|---|---|---|
| Sign-in | langsmith auth login in the browser, or an API key |
Browser, or a project API key for CI |
| Judged traces | langsmith projects issues list |
traceroot findings list and findings get, with root cause analysis |
| Trace export | langsmith traces export |
traceroot traces export, with git_context.json |
| Read-only queries | Filters and --ai-search |
traceroot sql, SQL over spans and traces |
Evaluation as the verify step
A fix is done when it is checked. Both tools run offline evaluations over datasets.
traceroot evaluations run your system over a dataset, and each case runs as a trace, so the cost and span views you use in production work for the eval too. Scorers can be code or an LLM judge. Label a run with the pull request's commit, compare it with the current version on the same immutable dataset version, and merge when it holds. traceroot evals runs get shows the pinned dataset version and per-scorer means from the terminal.
LangSmith's evaluation runs experiments over datasets with code or LLM-as-a-judge evaluators, and the Python SDK records the repository, commit and branch on each experiment (_runner.py).
Pricing and retention
LangSmith Plus charges $39 per seat plus a fee per trace, and bills Engine runs separately. traceroot charges per workspace, with unlimited seats on paid plans. The worked example below shows the monthly total at one team's usage.
LangSmith Cloud's Developer plan is $0 for one seat with 5k base traces a month. Plus is $39 a seat a month with 10k base traces, then 0.005 LSU per base trace, where 1 LSU is $1 (pricing page). A base trace is kept 14 days; upgrading it to an extended trace, kept 180 days, costs 0.0025 LSU more. traceroot Cloud counts events, where a trace and each of its spans count as one event (event count), and bills overage in whole blocks of 50k at $4 a block (block billing, plans and usage). Its retention is a query window: it limits how far back the product shows data and does not delete it. Plan details are from the traceroot pricing page.
| Dimension | LangSmith | traceroot |
|---|---|---|
| Free | Developer, $0: 1 seat, 5k base traces | $0: 2 seats, 50k events, 15-day query window |
| First paid plan | Plus, $39 a seat: 10k base traces | Starter, $30 a month: unlimited seats, 150k events |
| Next plan | Enterprise, custom | Pro, $200 a month: 90-day query window |
| Usage beyond the plan | $0.005 a base trace | $4 per 50k events |
| Retention | 14 days base; 180 days for $0.0025 more a trace, on by default for online evaluators | 30-day query window on Starter, 90 on Pro |
| Agent that looks for causes | Engine, about $7 to $45 a run | 100 root cause analysis runs included on Starter |
| Self-hosting | Enterprise add-on | ✓ |
A worked example at the same usage: a team of three engineers, an agent that runs 1,000 times a day with 10 spans per run, and every run judged in production, by an online evaluator on LangSmith and a detector on traceroot. Over 30 days that is 30,000 traces and 330,000 events. With your own model keys, judge model tokens go to your model provider on both, so they are left out (LangSmith evaluators, traceroot BYOK).
| Dimension | LangSmith | traceroot |
|---|---|---|
| Seats | 3 × $39 = $117 | Unlimited, included |
| Trace volume | 20,000 traces over 10k: $100 | 180,000 events over 150k: $16 |
| Retention | 180 days by default for evaluated traces: $75 | 30-day query window, included |
| Production judges | Online evaluators; model tokens to your provider | Unlimited detector runs; model tokens to your provider |
| Monthly total | $292, or $217 with retention extension off | $46 |
In this example that is $46 against $292 a month, about six times less, before any Engine runs. If you turn Engine on, its 6-hourly scans add roughly $840 to $5,400 a month on Cloud, at LangChain's estimate of 7 to 45 LSU per run. traceroot includes 100 root cause analysis runs a month, each investigating one Signal, in the $30 plan. The seat difference holds at any volume: every engineer you add costs $39 a month on LangSmith Plus and nothing on traceroot Starter.
Which should you choose
Choose traceroot if you want to keep improving agents in production for about a sixth of LangSmith's cost in the example above, $46 against $292 a month, with unlimited seats and root cause analysis included instead of metered per run. Detectors read every span of a trace, flagged traces become Signals with full GitHub context, the root cause analysis agent reads your repository at the recorded commit, and a pull request is one optional step away. Both keep traces in ClickHouse, but traceroot stores every raw OTLP batch in object storage before processing, so a failed batch can be replayed (ingest_quarantine.py), and the whole stack comes up with one Docker Compose command, where self-hosted LangSmith needs Kubernetes and an Enterprise license (self-hosting docs). It comes with a CLI your coding agent can drive.
Choose LangSmith if your agents are built on LangChain or LangGraph and you want tracing, evaluation and managed agent deployment from the same vendor on a hosted platform, and per-seat, per-trace pricing fits your budget.
Both speak OpenTelemetry, so the easiest way to decide is to send one agent's traces to traceroot next to what you run today.
Switching from LangSmith
You do not have to switch in one step.
- Run
npx -y traceroot-cli@latest setupin the repository of one agent. It adds the traceroot SDK and checks that the first trace arrives. - Keep LangSmith running while you compare. LangSmith documents fanout through an OpenTelemetry Collector, so the same spans can reach both.
- Write a detector for one failure you already score with an online evaluator, and connect the GitHub App so root cause analysis can read your code at the recorded commit.
- Compare what each tool tells you about the same failures for a week or two, then move your datasets when you are ready.
Get started
Install the CLI and run traceroot setup in the repository of one agent. Pick one failure you have already worked through by hand, so you know what a correct diagnosis looks like, then write a detector that describes it in plain language and connect the GitHub App. The code is on GitHub.
FAQ
Is traceroot a LangSmith alternative? Yes, and an open-source one: you can self-host it with Docker Compose. It judges production traces with detectors, groups flagged traces into Signals, investigates them against your repository at the recorded commit, and can optionally open a pull request for review.
Is LangSmith open source? LangSmith's SDKs and CLI are public on GitHub, in langsmith-sdk and langsmith-cli. The platform is hosted by LangChain, and self-hosted LangSmith is an add-on to the Enterprise plan.
How much does LangSmith cost? On LangSmith Cloud, Developer is $0 for one seat and 5k base traces a month. Plus is $39 a seat a month with 10k base traces, then $0.005 per base trace and $0.0025 per extended retention upgrade, and Engine is metered at about 7 to 45 LSU per run. Enterprise, which includes the self-hosted option, is custom (pricing page).
Is traceroot cheaper than LangSmith? Yes, at the usage in our example: three engineers and 1,000 agent runs a day with 10 spans each cost $46 a month on traceroot Starter and $292 on LangSmith Plus, with evaluated traces kept 180 days by default, before Engine runs (traceroot pricing, LangSmith pricing).
Do I need LangChain to use traceroot? No. traceroot traces LangChain and LangGraph agents through OpenInference, and also the OpenAI Agents SDK, CrewAI, LlamaIndex and plain OpenTelemetry.
How does LangSmith compare with Langfuse? Langfuse is open source and self-hostable, and LangSmith is hosted, with self-hosting on Enterprise. We compare traceroot with Langfuse in traceroot vs. Langfuse.
Do I need to give traceroot access to my repository? Only for root cause analysis and pull requests. Tracing works without it.
LangSmith facts in this post were checked against LangSmith's public docs, its pricing page and the langsmith-sdk and langsmith-cli repositories, and traceroot facts against its source code, on November 19, 2026.