LangSmith

Where LangSmith sits

LangSmith is LangChain's observability and evaluation platform, and it has grown well beyond the "debug your chains" tool it started as. In 2026 the product spans five surfaces: Observability (tracing, monitoring, dashboards, alerts), Evaluation (offline experiments, online evaluators, annotation queues, human feedback), Deployment (managed agent hosting with versioning, rollbacks and native A2A/MCP/Agent Protocol support), Fleet (no-code agents for non-technical teams), and Engine (automated root-cause analysis that reads your traces and proposes fixes). The through-line is the argument LangChain makes in its docs: you cannot plan for every input and LLMs decide outputs at runtime, so traces — not code — are the only record of what your agent did and why. For any team running LLM applications in production, that record is the difference between improving a system and guessing at it.

The pricing is where readers should slow down, because LangSmith's true cost is driven by trace volume and retention class, not seats. At time of writing, langchain.com/pricing lists three plans: Developer at $0 per seat (one seat, 5,000 base traces per month included, community support), Plus at $39 per seat per month (10,000 base traces per month shared across the organisation, unlimited seats, one free small serverless deployment, access to Engine, Fleet and Tuned Evaluators), and Enterprise at custom pricing (self-hosted or hybrid deployment, custom SSO with ABAC and RBAC, SLA support). The per-trace rates live in a tooltip rather than the visible page: 0.005 LSU per base trace and 0.0025 LSU per extended-trace upgrade, where one LangChain Storage Unit is $1.00. That is $5.00 per 1,000 additional base traces and $7.50 per 1,000 for traces upgraded to extended retention.

What it actually does

Instrumentation is the entry point. LangSmith works with LangChain and LangGraph first, but the integration list reaches OpenAI, Anthropic, CrewAI, Vercel AI SDK, Pydantic AI and more, and any application can be traced via SDK or environment variables. A trace is one execution of your application — an agent run, an evaluator run, a playground session — and can contain any number of child runs (LLM calls, tool calls, retriever steps). This definition matters financially: a 40-step agent execution is billed as one trace, not forty spans. Base traces retain for 14 days; extended traces retain for 180 days (a cap that changed on 14 September 2026 from an earlier 400 days for new SaaS traces).

On top of traces sits the improvement machinery. Datasets and experiments let you evaluate changes against real production data; annotation queues route outputs to human reviewers; Prompt Hub and Playground version prompts; automations and rules trigger actions on trace patterns; dashboards and alerts track cost, latency and quality metrics; and Tuned Evaluators — including the Perceived Error evaluator at 0.015 LSU per evaluation run — score outputs with learned graders aligned to human judgment. Engine reads the trace corpus, detects recurring issues, diagnoses root causes and proposes resolutions. Fleet extends the same platform to non-technical users who describe an agent in plain language (daily briefings, competitor tracking) and get one built with permission gates before sensitive actions.

My testing notes

My first observation came from instrumenting a LangGraph agent I already had running. Setup was two environment variables and an SDK install; the trace tree that came back was the clearest I have seen in this category — the full call graph with per-step latency and token cost, filterable and shareable. The billing definition held: a long agent run with roughly forty nested steps showed up as a single trace. For agent-heavy teams this is the friendly part of the pricing model, and it is why I recommend LangSmith over span-priced alternatives when your executions are deep.

The second observation is the retention behaviour, which is the sharpest edge in the product. Base traces cost $5.00 per 1,000 and extended traces $7.50 per 1,000 — but the upgrade is not always something you choose. LangSmith's own usage documentation says retention extension is enabled by default for new online evaluators and automation rules, that a matching rule upgrades the entire trace, and that experiments are created at extended retention by default. In my evaluation-heavy project, feedback-rich traces quietly moved into the extended class at roughly 50% above the base rate. The controls exist (you can opt out per evaluator or rule), but the default is set where your bill grows.

Third, I worked the arithmetic against published rates before writing this. One Plus seat with 10,000 traces is $39 a month; the same seat running 100,000 traces lands near $489 at the published $5.00 per 1,000 overage, and 500,000 traces pushes the trace component past $2,400. Trace volume, not seats, is the budget line. I recommend setting the per-workspace spend limit on day one — LangSmith converts it into base and extended trace limits, and traces bill in arrears, so a traffic spike surfaces on the next invoice rather than in real time.

Where it falls short

The pricing surface is the limitation. The per-trace rates are published only in an information tooltip, which is why secondary sources quote figures ranging from $0.50 to $5.00 per 1,000 traces — I verified the tooltip constants directly (0.005 LSU base, 0.0025 LSU upgrade, 1 LSU = $1) and used those, but the fact that a $39 product needs a pricing investigation is a design failure. Retention upgrades firing by default compound it: the better your evaluation hygiene, the more you pay per trace, which is exactly backwards from how quality work should be rewarded.

Second, while LangSmith is no longer LangChain-only, it is still LangChain-shaped. Teams on other stacks get excellent tracing but will feel the product's centre of gravity in Deployment and Fleet, which are built around LangChain's own agent runtimes. Self-hosting — often a compliance requirement — is an Enterprise-only conversation, as are SAML/OIDC SSO beyond Google/GitHub, ABAC and RBAC. And the newer surfaces (Engine, Fleet, Tuned Evaluators) are young; Tuned Evaluators are explicitly in public beta for Plus and US Cloud Enterprise plans.

One operational detail I checked because it decides migration planning: the data layer matters. LangChain moved US Cloud ingestion onto SmithDB, a Rust-based store launched in May 2026, and reports trace trees loading at a 50th percentile of 92 milliseconds. That figure is LangChain's own measurement and I treat it as a vendor claim, but in my sessions the trace explorer felt fast even on projects with months of history, and the improvement over earlier versions of the viewer was noticeable. For teams already invested, the platform's direction of travel — deeper agent semantics like threads, sub-agent delegation and memory as first-class concepts throughout the product — is coherent rather than scattered, which is not something I can say for every observability vendor bolting agents onto a logging tool.

Verdict

LangSmith is the most complete agent observability and evaluation stack I have used, priced in a way that rewards calm trace volumes and punishes noisy ones. Rated 4.0 on the rubric: depth of core functionality 4.4 (tracing, evals, datasets, annotations, deployment, automated root-cause — few competitors span all of it), value 3.4 (free tier is real and generous for one seat, but trace overage and default retention upgrades make bills volatile), usability 4.2 (fast instrumentation and a trace viewer that makes agent behaviour legible), support and ecosystem 4.2 (framework integrations, active docs, self-host option for enterprise), reliability signals 3.9 (LangChain's position and the SmithDB Rust data layer behind US Cloud ingestion; the reported 92ms P50 trace loading is a vendor figure). Buy it with a spend limit configured before your first production trace.

Sources

• https://langchain.com/pricing
• https://docs.langchain.com/langsmith/observability
• https://docs.langchain.com/langsmith/observability-stack
• https://www.langsmith.com/docs
• https://benchclaw.io/langsmith-pricing
• https://zenml.io/blog/langsmith-pricing
• https://panoply.io/tools/langsmith
• https://agentsapis.com/langchain/langsmith-pricing
• https://docs.langchain.com/langsmith/usage-and-billing
• https://smith.langchain.com
• https://docs.langchain.com/langsmith/integrations