Respan vs LangSmith

Disclosure: I run developer relations at Respan, so I am not neutral. LangSmith ships from the LangChain team, which means they have the tightest possible integration with LangChain and LangGraph and a decade of context on how those frameworks are used in production. If your stack is LangChain-heavy, LangSmith is genuinely the path of least resistance.

This article is the honest comparison, including where Respan does not win. We see roughly 80 million LLM requests per day flow through Respan from customer workloads, including many teams that run LangChain alongside other frameworks (LlamaIndex, custom agent loops, OpenAI Agents SDK, Anthropic's Computer Use). That mixed exposure is the lens I am writing from.

TL;DR: when to pick each

If you want one sentence: LangSmith is the LangChain-native observability and eval product that wins for LangChain-heavy teams; Respan is the framework-agnostic unified platform that wins when you want one tool regardless of framework. The fork is mostly about how much of your stack lives inside LangChain.

The two companies, briefly

LangChain (the company) ships the LangChain framework, the LangGraph framework, and the LangSmith observability + evals + prompt product. Founded in 2022 by Harrison Chase, raised significantly from Sequoia and Benchmark. The framework is the most-used LLM application framework in the world by GitHub stars and downloads. LangSmith was built explicitly to be the observability product for teams using LangChain and LangGraph; it has since expanded to support arbitrary frameworks via OpenTelemetry, but the LangChain path remains the primary one.

Respan was founded in 2023 by Andy Li, Raymond Huang, and Hendrix Liu, YC W24. The product is a unified platform: LLM observability, evals, prompt management, and an LLM gateway, all in one. We are framework-agnostic by design. Customers run us with LangChain, with LlamaIndex, with custom agent loops, with the OpenAI Agents SDK, with Vercel AI SDK. The platform was originally Keywords AI and rebranded to Respan in early 2026.

The cultural difference: LangSmith is the operations product for teams that adopted LangChain's worldview. Respan is the operations product for teams that did not commit to any single framework's worldview. Both are valid; the right pick depends on your stack.

Quick comparison

Framework integration: the central question

This is the cleanest distinction between the two products.

LangSmith is LangChain-native. If you wrap your code in LangChain or LangGraph, traces appear in LangSmith automatically with rich structure: chain steps, tool calls, retriever invocations, LangGraph node transitions all show up labeled and typed. The integration is built and maintained by the same team that ships the framework, which means edge cases (callbacks, custom tools, custom retrievers) are handled. For LangChain-heavy code, the trace fidelity is the best in the category.

Respan is framework-agnostic. We support LangChain through OpenInference / OpenTelemetry instrumentation, but LangChain is not the primary path. The primary path is OpenTelemetry, which gives you good trace fidelity for any framework that emits OTel spans (LlamaIndex, OpenAI Agents SDK, Vercel AI SDK, custom code), plus our SDK and our gateway as alternative instrumentation modes.

The honest read: if 80%+ of your stack is LangChain or LangGraph, LangSmith will be the lower-friction path. The auto-instrumentation is just smoother and the LangGraph node visualizations are first-class. If your stack is mixed, or if you intentionally avoided LangChain in favor of lighter abstractions, Respan's framework-agnostic posture is the better fit and you will get more useful traces.

For background, see LLM tracing and what is LLM tracing.

OpenTelemetry support: primary path vs supported path

Both products support OpenTelemetry. The difference is in how central OTel is to the architecture.

LangSmith added OTel support because customers asked for it and because it became table-stakes. Their primary path is LangChain auto-instrumentation, with OTel as a secondary surface for non-LangChain users. The OTel integration works, but you get richer trace structure through the LangChain integration than through raw OTel.

Respan was built OTel-first. The wire format is OpenTelemetry; the SDK is a thin wrapper over OpenInference + OTel; the gateway exports OTel spans by default. There is no "richer path" for some framework over others; OTel is the path, and any framework that emits clean OTel spans gets first-class trace fidelity.

If you are betting on OpenTelemetry as the long-term standard for AI observability (which I think is the right bet), Respan is the more architecturally aligned product. If you do not care about that bet and you are committed to LangChain, LangSmith's tight integration is more valuable than OTel purity.

Evals: both are strong

LangSmith's eval workflow is genuinely good. They ship Prompt Hub, Playground, and Canvas (an iteration surface for prompts and chains), plus annotation queues for human feedback, online evals via SDK hooks, and offline experiments. The integration with LangChain means you can run evals over chain runs without writing glue code. For LangChain-heavy teams, the eval loop is tight.

Respan's eval workflow is online-first. Every trace can be scored by LLM-judges or rule-based checks the moment it lands in production. Offline evals exist (datasets, experiments, comparisons), but the differentiator is continuous online quality measurement on live traffic. A/B testing across prompt versions is wired into the eval scores.

Honest caveats:

• Braintrust still leads on rigorous offline eval depth. Neither LangSmith nor Respan matches Braintrust's scoring functions library or dataset versioning.
• LangSmith's Prompt Hub + Canvas is a tight loop for LangChain-shaped iteration. If you live inside LangChain, it is the most native experience.
• Respan's online eval automation on live traffic is the strongest differentiator for production AI monitoring.

For background, see LLM evals, how to evaluate an LLM, and what is prompt evaluation.

Prompt management

Both products treat prompts as first-class objects.

LangSmith's Prompt Hub has versioning, sharing, public prompt discovery, and a playground for iteration. Canvas extends this with a chain-and-prompt iteration surface. It is well integrated with LangChain so chain construction can reference Prompt Hub entries directly.

Respan has prompt versioning, A/B testing on live traffic, rollback, and a tight loop with the online eval system. You can route 10% of traffic to a new prompt version and watch online eval scores diverge in real time.

For LangChain-heavy teams, LangSmith's Prompt Hub is the tighter loop. For teams that want production A/B testing wired to eval scores, Respan is the tighter loop. See best prompt management tools and what is prompt versioning.

LangGraph deployment: a real LangSmith differentiator

LangSmith ships LangGraph deployment as part of the product. Development deployments at $0.0007/min, production deployments at $0.0036/min, Fleet agent runs with their own pricing. If you build agents on LangGraph and want a managed runtime in the same product as your observability, LangSmith is a real one-stop shop.

Respan does not deploy LangGraph or any framework runtime. We are observability + evals + prompts + gateway, not a compute platform. If you want managed LangGraph runtime, LangSmith is the answer.

This is a real LangSmith advantage and I am not going to pretend otherwise. The trade-off is platform lock-in: LangGraph + LangSmith Cloud is a tightly coupled stack, and if you change your mind later you are migrating both compute and observability at once.

Gateway: the other structural difference

LangSmith does not ship an LLM gateway. They focus on observability, evals, prompts, and (for LangChain users) the LangGraph deployment runtime. If you want provider fallback, model routing across providers, key management, or rate limiting across providers, you operate that separately.

Respan ships a built-in LLM gateway. 500+ models behind a single OpenAI-compatible endpoint, provider fallback, key management, caching, rate limiting, load balancing. The gateway and observability share the same data plane.

For LangChain users, the LangChain framework itself abstracts over providers, so the gateway argument is weaker. You can swap providers in LangChain code without a separate gateway. The gateway argument is strongest for teams that are not abstracted via LangChain, or teams that want centralized key management and routing policy independent of application code. See what is an LLM gateway and best LLM gateways.

Pricing: this is where scale matters

Verified against the LangChain pricing page today.

LangSmith:

• Developer: free, 1 seat, 5k base traces/month
• Plus: $39/seat/month, unlimited seats, 10k base traces/month included, then $2.50/1k base traces ($5/1k extended traces)
• LangGraph deployments: dev at $0.0007/min, production at $0.0036/min
• Fleet agent runs: 50/mo on Developer, 500/mo on Plus, then $0.05/run
• Enterprise: custom (Cloud, Hybrid, or Self-Hosted)

Respan:

• Free tier exists with generous traces and evals for most production starts
• Pro: usage-based, includes the full platform (observability + evals + prompts + gateway) without per-feature unbundling
• Enterprise: custom, includes self-host

Honest math: LangSmith's per-seat plus per-trace pricing escalates fast at scale. A 10-person team running 1 million traces per month on Plus is paying $390/month for seats plus roughly $2,475/month for trace overage ($2.50/1k * 990k traces) plus deployment time plus Fleet runs. That math gets to $3-5k/month quickly. For LangChain-heavy teams where the value is high, it can be worth it; for teams trying to predict cost as they scale, it is a real consideration.

Respan's bundled pricing tends to be more predictable at scale because there is no per-seat charge stacking and trace volume is metered in a unified way alongside the gateway.

Self-host

Both products restrict self-hosting to Enterprise tiers.

LangSmith Enterprise supports Cloud, Hybrid (control plane managed, data plane in your VPC), or fully Self-Hosted. The hybrid option is genuinely well done and is the right pick for many regulated industries.

Respan Enterprise supports self-host as a Kubernetes deployment of the full platform (gateway, observability, evals, prompts).

If self-host is non-negotiable below Enterprise, neither product is the answer; Langfuse is the right pick for free self-host.

How to choose

A decision framework that holds up across teams I have talked to:

Pick LangSmith if:

• Your stack is deep on LangChain or LangGraph (80%+ of your code)
• You want the best possible trace fidelity for LangChain chains and LangGraph node transitions
• You use or want LangGraph Cloud for managed agent runtime
• You are willing to pay per-seat plus per-trace pricing
• You don't need an LLM gateway in the same product

Pick Respan if:

• You run mixed frameworks, or no framework at all, or you want to keep that option open
• You want OpenTelemetry as the primary instrumentation path
• You want one product for observability, evals, prompts, and an LLM gateway
• You want continuous online evals on production traffic
• You want predictable bundled pricing that scales linearly with traffic, not with seats + traces stacked

Pick neither if:

• You need free self-host below Enterprise scale (use Langfuse)
• Your only problem is rigorous offline eval depth (use Braintrust)

Frank's take

If I were building a LangGraph agent today and wanted everything in one place, I would seriously consider LangSmith. The framework integration is tight, the LangGraph deployment runtime is convenient, and the Prompt Hub is well done. The lock-in is real, but if you have decided that LangGraph is the right framework, lock-in is implicit in that decision anyway.

If I were building anything else (custom Python agent, OpenAI Agents SDK, LlamaIndex, Vercel AI SDK, mixed stack), I would default to Respan. The framework-agnostic OTel-native posture means I am not paying a tax for not adopting LangChain, and the gateway alone saves an operational product I would otherwise glue in.

The pattern I see in conversations: teams that committed to LangChain early often stay on LangSmith because the migration cost is real. Teams that did not commit to LangChain almost never adopt LangSmith because the value proposition is weakest when you are not LangChain-heavy. Teams that are mid-migration or starting fresh in 2026 tend to evaluate both and most pick the framework-agnostic option because they do not want to recommit to a single framework's worldview.

FAQ

Is LangSmith only for LangChain users? No, but the value is concentrated there. LangSmith works for any framework via OpenTelemetry, but the rich trace fidelity, auto-instrumentation, and Prompt Hub integration are tightest with LangChain and LangGraph. For non-LangChain users, framework-agnostic alternatives are usually a better fit.

Does Respan integrate with LangChain? Yes, through OpenInference and OpenTelemetry. The integration is good but it is not as deep as LangSmith's native integration with its own framework. If your stack is heavily LangChain, LangSmith will give you slightly better trace fidelity out of the box.

Does Respan support LangGraph? Yes, via OTel. We do not deploy LangGraph runtime; if you want managed LangGraph compute in the same product, LangSmith is the answer.

Is LangSmith expensive? It depends on scale. At small volume (one or two seats, low traces), the $39/seat tier is reasonable. At scale (10+ seats, millions of traces, multiple deployments), the per-seat + per-trace + per-deployment-minute math stacks fast. Teams operating at scale often re-evaluate.

Does LangSmith ship an LLM gateway? No. LangChain (the framework) abstracts over providers in your application code, but there is no managed gateway product. If you want a managed gateway with provider fallback, you would use a separate product. Respan ships one.

Which is better for production observability? Both are good. LangSmith is best for LangChain-heavy production. Respan is best for framework-agnostic production or when you want the gateway and unified platform in the same product.

Can I migrate from LangSmith to Respan? Yes, with engineering effort. The SDK changes are minor if you instrument via OTel. Migrating historical traces and re-creating prompts is the heavier lift. We see this migration most often when teams move away from LangChain to lighter frameworks.

Related

• LLM Observability: The Complete Guide
• LLM Tracing: How to Trace Multi-Step Agent Pipelines
• LLM Gateway: One API for Every Model
• Best LLM Observability Tools
• Best Prompt Management Tools