Both provide observability for AI applications, but Logfire covers your entire stack: LLM calls alongside database queries, API requests, and background jobs, while LangSmith focuses on the AI layer. In our worked 5-million-run scenario, Logfire is ~99.5% less using LangSmith's cheaper 14-day base traces. The Pydantic stack brings type safety, validation, structured outputs, and observability that sees your entire application.
| Feature | Logfire | LangSmith |
|---|---|---|
| Observability scope | Full-stack (AI + database + APIs + infra) | LLM and agent-focused |
| Foundation | Pydantic (560M+ downloads/month), type-safe | LangChain, flexible/dynamic |
| Structured Outputs | Schema-validated responses | String parsing, partial validation |
| Standards | OpenTelemetry native - instrumentation fully portable | Proprietary-first; OTel supported but some features require LangSmith's own SDK |
| Query interface | SQL (Postgres-compatible) | Proprietary DSL + UI filters |
| Framework support | Python, JS/TS, Rust + any OTel language | Built for LangChain and LangGraph. Support for OpenLLMetry semantics |
| Free tier | 10M logs, spans, and metrics (1 user) | 5,000 traces/month (1 user) |
| Pricing model | Personal: 10M records free; Team: $49/month + $2/M over 10M | $39/seat + $5/1K base traces |
| Data retention | 30 days default; 90 days for Growth plan | 14-day base; 400-day upgrade adds $2.50/1K traces |
| Human annotations & queues | Annotations on production runs + annotation queues | Annotations on production runs + annotation queues |
| Graph state visibility | Code-first Mermaid diagrams (Pydantic Graph) + full execution traces | UI graph rendering for LangGraph runs |
| Workload | LangSmith | Logfire | Savings |
|---|---|---|---|
| 500K runs/mo (≈5M records) | ~$2,475 | $0 (Personal) | ~$2,475/mo |
| 5M runs/mo (≈50M records) | ~$25,145 | ~$129 | ~99.5% less |
| 50M runs/mo (≈500M records) | ~$250,730 | ~$1,229 | ~99.5% less |
Calculation scope
A conservative 14-day base-trace model for LangSmith compared with 30-day Logfire retention. The table compares agent runs, not spans, because LangSmith bills one trace per run while Logfire bills each telemetry record.
Basis: USD; public monthly list price. Prices checked .
500K LangSmith base traces are compared with 5M Logfire records at 10 records per run.
5M records are within the 10M Personal allowance $0 1 × $0 $0 (500K − 5K included) × 0.005 LSU × $1/LSU $2,475 5M LangSmith base traces are compared with 50M Logfire records at 10 records per run.
$49 $49 (50M − 10M included) ÷ 1M × $2 $80 5 × $39 $195 (5M − 10K included) × 0.005 LSU × $1/LSU $24,950 50M LangSmith base traces are compared with 500M Logfire records at 10 records per run.
$249 $249 (500M − 10M included) ÷ 1M × $2 $980 20 × $39 $780 (50M − 10K included) × 0.005 LSU × $1/LSU $249,950 “Covers 10 million logs, spans, and metrics every month.”
The official calculator shows 20 million records and no extra seats totaling $69/month on Team.
“Add unlimited seats $39 per seat/month”
The official calculator prices one LSU at $1 and each additional base trace at 0.005 LSU.
“LangSmith charges less for traces that have low data retention.”
The retention table lists 14 days for base traces and 400 days for extended traces; the pricing page lists a 0.0025 LSU upgrade.
In the worked agent-run scenarios below, Logfire is ~99.5% less while retaining telemetry for 30 days instead of LangSmith's 14-day base tier. This is not about being the budget option; it is about a record-based architecture that passes savings to you.
LangSmith shows you what your LLM did. Logfire shows you what your LLM did AND what happened in your databases, APIs, and services. When your AI agent fails, was it the model, the data pipeline, or the downstream API? You need the complete picture in one trace.
Logfire uses standard (PostgreSQL) SQL throughout. SQL is one of the things AI coding assistants do best. Point your agent at your Logfire data via our MCP server and it can answer arbitrary questions about production behavior that no proprietary query language could support.
Logfire is built on OpenTelemetry with 100% GenAI semantic convention alignment. Your instrumentation is portable. Pydantic AI itself works with ANY observability backend that supports OTel, so you're not locked into Logfire.
We migrated from LangSmith to Logfire and the time it took to query our agent traces went down by 96.2%.
For 5 million agent runs a month with 5 users, assuming 10 Logfire records per run, Logfire lists at $129 versus $25,145 for LangSmith's 14-day base traces—~99.5% less. At 50 million runs with 20 users, the same model is $1,229 in Logfire versus $250,730 in LangSmith, or ~99.5% less. The methodology below exposes every input and assumption.
Yes. Logfire works with any AI framework including LangChain, Pydantic AI, Vercel AI SDK, LlamaIndex, and plain OpenAI. Logfire is framework-agnostic — your choice of AI framework doesn't lock you into a specific observability tool.
Both Logfire and LangSmith support annotations on production runs and annotation queues. In Logfire, annotations can capture a verdict, expected output, comment, and tags, then feed into your eval workflow. Logfire also supports hosted datasets and Pydantic Evals for code-first evaluation.
LangChain and LangSmith don't have to be a bundle. Many teams run Logfire alongside LangChain. The concepts transfer — both support OTel at their core. The migration path is instrumentation changes, not a full rewrite. And many teams have already moved off LangChain entirely once they hit its complexity ceiling.
Yes. LangSmith shows full graph state by default for LangGraph pipelines — that's a genuine advantage if deep LangGraph debugging is a day-one requirement. Worth considering how much of your stack actually depends on LangGraph vs other approaches.
Get started with 10 million free spans, logs, and metrics per month. No credit card required.