How to Migrate from LangSmith to Zespan (2026 Guide)

LangSmith is the natural first stop for teams building on LangChain. It is tightly integrated, it works, and if you live entirely inside LangChain it is a reasonable default.

Teams move to Zespan for two recurring reasons: the tracing model is oriented around chains rather than agents, and per-seat pricing gets expensive precisely when the tool becomes useful to more of the team.

Before you start: is migrating worth it for you?

Stay on LangSmith if you are a small team, entirely inside LangChain, and happy with the chain-centric view. It is well built for that.

The reasons teams move:

• Per-seat pricing punishes visibility. Plus is $39 per seat per month. Every engineer, PM, or support lead who needs to look at a trace is another $39, and there is no cheaper read-only tier. The moment observability becomes genuinely useful across a team, the bill scales linearly with that usefulness.
• The centre of gravity is the chain. LangSmith models runs as nested chain executions. That is a good fit for LangChain, and an awkward one for agents that plan, delegate to sub-agents, and choose tools dynamically.
• Trace overage on top of seats. Beyond the included allowance, base traces run $2.50 per 1k and extended-retention traces $5.00 per 1k, on top of per-seat cost.
• Framework coupling. The deeper the LangSmith integration goes, the more your observability is tied to one framework's abstractions.

Step 1: Instrument alongside, keep LangChain

You do not need to touch your chains or graphs. Add Zespan next to your existing setup:

import { zespan } from "@zespan/sdk";

zespan.init({
  apiKey: process.env.ZESPAN_API_KEY
});

Zespan auto-patches providers and registers a LangChain/LangGraph handler, so your existing code keeps working unchanged. Leave LANGCHAIN_TRACING_V2 and your LangSmith environment variables in place for now — the goal of this step is overlap, not replacement.

Step 2: Understand what changes in the data model

LangSmith concept	Zespan equivalent	What is different
Run (chain / llm / tool)	Span	Zespan types spans by agent semantics rather than chain node type
Nested run tree	Trace	Comparable, but delegation is modelled explicitly
Project	Project	Broadly equivalent
Dataset	Dataset	Zespan builds these from real production failures automatically
Evaluator	Evaluation	12 LLM-as-judge templates run automatically with no configuration
—	Agent	Registered as a first-class entity on first run
—	Handoff / delegation	An explicit event with its own cost and outcome
—	Issue	Recurring failures cluster into one tracked object

The practical shift: in LangSmith you read a tree of chain executions. In Zespan you read what each agent decided, what it delegated, what that cost, and whether the output was actually correct.

Step 3: Rebuild datasets from real failures, not exports

You can export LangSmith datasets, but consider whether you should. Zespan turns captured production failures into regression test cases directly, so instead of migrating a static dataset you can let the real failures of the next two weeks build it for you.

Port only the curated cases you genuinely rely on in CI.

Step 4: Run parallel for a full release cycle

Keep both tracers live and compare:

• Run and trace counts per service. Divergence usually means an entry point only one of them wraps.
• Cost attribution against your actual provider invoice.
• Latency percentiles, which should closely agree.

Step 5: Cut over

Once the numbers agree:

1. Remove LANGCHAIN_TRACING_V2 and the LangSmith environment variables.
2. Drop the LangSmith callback handler if you registered one explicitly.
3. Reconcile seats. This is where the cost change shows up — you no longer pay per person to look at a dashboard.

Keep the LangSmith account until its retention window covers whatever you still need to reference.

What you should expect to gain

• Flat pricing. $39 a month rather than $39 per seat per month, so adding viewers costs nothing.
• Delegation, tool choice, and agent identity as native concepts rather than chain nodes you interpret.
• Evaluations running automatically on every trace instead of evaluator code you maintain.
• Framework independence. If you later move part of your stack off LangChain, your observability does not move with it.

What you should expect to give up

• The tightest possible LangChain integration. LangSmith is built by the LangChain team. If you use deep LangChain-specific features and want the vendor's own first-party view of them, that is a real advantage you are trading away.
• A larger library of published evaluator recipes. LangSmith ships more evaluator templates (30+) than Zespan's 12. Zespan's run automatically without configuration; LangSmith's give you more off-the-shelf variety. Which matters more depends on whether you want breadth or zero-setup.

Next steps

• Read the Zespan vs LangSmith comparison for a capability-by-capability breakdown.
• See Monitor LangChain agents in production for the instrumentation detail.
• Start free with 10,000 traces a month, no card required.