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, with every pricing input and assumption disclosed below.
Trusted by teams building production software and AI
| Feature | Logfire | LangSmith |
|---|---|---|
| Observability scope | Full-stack (AI + database + APIs + infra) | LLM and agent-focused |
| Standards | OpenTelemetry native - instrumentation fully portable | Proprietary-first; OTel supported but some features require LangSmith's own SDK |
| Query interface | PostgreSQL-compatible SQL and MCP | Trace filters and product views |
| 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 |
In the worked agent-run scenarios below, Logfire costs ~99.5% less while retaining telemetry for 30 days instead of LangSmith's 14-day base tier. The difference comes from record-based pricing rather than separate per-trace and per-seat fees.
Logfire keeps model calls in the same trace as database queries, API requests, background jobs, and the services that execute them. Follow a failed run past the model boundary without opening a second observability product.
Logfire uses PostgreSQL-compatible SQL across production telemetry. Queries can live in a script or pull request, power a dashboard or alert, and run through Logfire's MCP server so a coding agent can investigate production behavior from the same interface.
Logfire is built on OpenTelemetry and follows current GenAI semantic conventions. Its instrumentation emits portable OTel telemetry, and Pydantic AI can export to compatible observability backends rather than tying application code to Logfire's storage or query layer.
We migrated from LangSmith to Logfire and the time it took to query our agent traces went down by 96.2%.
Start free with 10 million spans, logs, and metrics each month. No credit card required.
| Workload | LangSmith | Logfire | Savings |
|---|---|---|---|
| 500K runs/mo (≈5M records) | ~$2,475 | ~$49 | ~98.0% less |
| 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.
$49 $49 (5M − 10M included) ÷ 1M × $2 $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; at one million or more traces it invites customers to contact sales for volume pricing.
“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.
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 do not have to be a bundle. Logfire can instrument LangChain applications through OpenTelemetry, so teams can send the same application to Logfire without rewriting the framework layer and compare both products before moving workflows.
LangSmith renders LangGraph graph state directly. Logfire provides full execution traces across frameworks and code-first Mermaid diagrams for Pydantic Graph. Teams deeply committed to LangGraph may value its specialized graph-state UI; teams using multiple frameworks keep a consistent investigation workflow in Logfire.
Get started with 10 million free spans, logs, and metrics per month. No credit card required.