Lore and LangSmith get compared because both live near the words "AI" and "observability." They are not substitutes. LangSmith observes and evaluates the LLM agents that run inside the product you ship. Lore captures the AI coding sessions your engineers run to build that product. Most teams need one. LLM-first product companies often need both, for different jobs.
This guide separates them in about five minutes, with a fair account of each and a simple decision rule.
The one-sentence difference
LangSmith watches the agents inside your product. Lore captures the AI your team uses to build the product.
If your application runs an LLM agent at runtime and you need to know whether it is behaving, that is LangSmith. If your engineers spend their day inside Claude Code, Codex, or Cursor and that reasoning is vanishing into closed terminals, that is Lore. The unit LangSmith tracks is one trace (an agent run, often many model calls). The unit Lore tracks is one coding session.
At a glance
|
Lore |
LangSmith |
| Category |
AI coding session capture and sharing |
LLM and agent observability and evals |
| What it tracks |
Coding-agent sessions (Claude Code, Codex, Cursor, Cowork) |
Agent traces, evals, and prompts inside your app |
| Primary user |
The whole engineering team and its managers |
The engineer or ML team who owns an agent |
| Core unit |
One session |
One trace or eval run |
| Main question answered |
"How was this actually built, and can the team reuse it?" |
"Is the agent in our product behaving, fast, and cheap?" |
| Where it sits |
Next to your coding agent |
Inside your application's runtime |
| Output |
A searchable, shareable URL for each session |
Traces, dashboards, eval scores, and alerts |
| Free tier |
Yes ($0) |
Yes (Developer, 1 seat) |
| Paid entry |
Team $20/seat/mo (min 2 seats) |
Plus $39/user/mo |
What LangSmith is
LangSmith is an agent observability and evaluation platform from the team behind LangChain. Its pitch is "know what your agents are really doing," and it is framework-agnostic: it traces agents built with LangGraph, the OpenAI SDK, the Anthropic SDK, LlamaIndex, or custom code, with SDKs for Python, TypeScript, Go, and Java. Teams at companies like Klarna, Rippling, Lyft, and Coinbase use it.
In practice, LangSmith does four things:
- Tracing. It records step-by-step execution traces of every agent run: model calls, tool calls, retrieval steps, latency, token usage, cost, and errors.
- Evaluation. It scores output quality with LLM-as-judge evaluators, heuristic checks, human annotation queues, and pairwise comparisons, both offline and online.
- Monitoring. Dashboards track token usage, latency (P50/P99), cost breakdowns, error rates, and feedback scores, with configurable alerts.
- Analysis and deployment. It clusters traces to surface failure modes, and offers tooling to ship and manage agents in production.
Pricing is trace-based: a free Developer tier (1 seat, 5,000 traces/month), Plus at $39/user/month (10,000 traces), and custom Enterprise, with cloud, bring-your-own-cloud, and self-hosted options. If you build a product with an LLM agent inside it, this is the category you want.
What Lore is
Lore is the home for your team's AI coding sessions: it turns every Claude Code, Codex, Cursor, and Cowork session into a searchable, shareable URL the whole team can read. Think GitHub, but for the AI sessions behind your code rather than the code itself.
The workflow is one command. Run /share inside a Claude Code or Cowork session, or /share-codex inside a Codex session, and you get a URL. The full thread renders in any browser: prompts, tool calls, diffs, and the moment a hard problem finally clicked. From there it is searchable across your workspace, linkable from a PR, open to block-level comments, and forkable so a teammate can pick up where you left off.
Lore exists because the AI era split engineering work into two surfaces. The first is the agent calls a product makes at runtime. The second is the AI sessions an engineer runs to write the code that ships. LangSmith owns the first surface. Lore owns the second.
The distinction that actually matters
Ask where the AI lives.
Is the AI inside your product, or inside your team? If your application runs an agent as part of what users experience, you have a product-runtime problem, and you want LangSmith. If your engineers use an AI agent to author the code that ships, you have a team-knowledge problem, and you want Lore.
What is the unit you want to capture? If you are tracking agent traces and their cost, latency, and quality, that is LangSmith. If you are tracking multi-hour coding sessions and the reasoning inside them, that is Lore.
These rarely overlap. The two tools can run side by side without knowing the other exists, because there is nothing to integrate: one lives inside your application, the other lives next to your coding agent.
Feature comparison
| Capability |
Lore |
LangSmith |
| Capture coding-agent sessions |
Yes, via CLI |
No |
| Share a session as a URL |
Yes |
No |
| Team-wide search over sessions |
Yes |
No |
| Block-level comments and review |
Yes |
No |
| Fork a session to continue the work |
Yes |
No |
| Agent and LLM trace logging |
No |
Yes |
| Evals (LLM-as-judge, human, heuristic) |
No |
Yes |
| Cost and latency dashboards |
No |
Yes |
| Trace clustering and failure analysis |
No |
Yes |
| SDKs for app instrumentation |
No |
Yes (Python, TS, Go, Java) |
The columns are mostly opposites on purpose. These products do not compete on features; they cover different parts of the AI engineering stack.
When to use LangSmith
Choose LangSmith if any of these are true:
- You ship a product or feature that runs an LLM agent at runtime.
- You need to debug why an agent run failed by inspecting its trace.
- You want to score agent quality with evals before and after deploy.
- You want dashboards and alerts on agent cost, latency, and errors.
When to use Lore
Choose Lore if any of these are true:
- Your team writes code with Claude Code, Codex, Cursor, or Cowork every day.
- The reasoning behind your codebase keeps disappearing into individual agent sessions nobody else sees.
- You want to send a teammate the whole session behind a change, not a cropped screenshot.
- You want new hires to learn from how your team actually works with AI tools.
Frequently asked questions
Is Lore a LangSmith alternative?
Not directly. LangSmith observes and evaluates the LLM agents inside the product you ship. Lore captures and shares the AI coding sessions your engineers run to build software. They solve different problems, so for most teams one does not replace the other.
Can Lore and LangSmith be used together?
Yes. They cover different layers of the AI engineering stack and never touch the same data. You can run LangSmith on your product's agent runtime and Lore on your engineers' coding sessions at the same time, with nothing to integrate.
Does Lore do agent evals or trace logging?
No. Lore does not trace agent runs, score outputs, or track API cost and latency. If you need those, use an observability platform like LangSmith. Lore captures coding-agent sessions and makes them searchable, shareable, and forkable across your team.
Does LangSmith capture Claude Code or Cursor sessions?
No. LangSmith instruments the agent and LLM calls your application makes at runtime. It is not built to capture, share, or search the coding-agent sessions your engineers run while writing code. That is what Lore does.
How much do Lore and LangSmith cost?
Lore is free to start, with shared links that expire after 3 days on the free tier; its Team plan is $20/seat per month (minimum 2 seats) and adds workspace-wide sharing and permanent links. LangSmith has a free Developer tier (5,000 traces/month), Plus at $39/user per month, and custom Enterprise pricing. Pricing is current as of June 2026.
The short version
Both tools matter in an AI-first engineering org, for different reasons. LangSmith answers "is the agent in our product behaving well enough to ship?" Lore answers "how was this actually built, and can the rest of the team learn from it?" Match the tool to the surface: LangSmith for the AI inside your product, Lore for the AI your team uses to build it.