Lmnr
Open-source agent observability that auto-captures every LLM and tool call and flags failures you never wrote a detector for.
Laminar's pitch is that you can't enumerate your agent's failure modes in advance, so it should watch every run and cluster what breaks. That's a genuine departure from Langfuse or Helicone, where the detectors are yours to write. flow-1 is what makes the bet affordable — frontier-level trace analysis at roughly 1/20th the cost — but budget for two meters, storage plus Signals tokens ($0.05/input Mtok, $0.30/output Mtok on Starter and Pro). Free at 1 GB with 7-day retention is a fair trial of
Verified 4d ago · liveness 79/100 · cite: rightaichoice.com/tools/lmnr
- Teams shipping multi-tool and sub-agent AI products where failures are emergent
- Developers using Claude Code or Codex CLI who want each turn traced and queryable
- Agent engineers who want SQL-level access alongside a prebuilt transcript view
- Platform teams turning real production failures into regression eval datasets
- Single-prompt LLM chat apps with no tool calls or multi-step behavior
- Teams whose monitoring need is host-level APM rather than agent run analysis
- Non-developers wanting a point-and-click monitoring dashboard with no SQL
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Laminar if you want a no-code monitoring dashboard, your product is a single-prompt chat app with no tool calls, or you need on-premise deployment without moving to an Enterprise contract.
Signals are billed by the tokens flow-1 consumes analyzing your traces, on top of storage, so heavy agent traffic means watching two cost lines rather than one.
Free at $0 covers 1 GB, 7-day retention, 1 project, and 1 seat — enough for a solo developer to evaluate the Signals approach. Starter at $30/mo with 3 GB and 30-day retention fits a small team in early production; Pro at $150/mo with 10 GB, 6-month retention, unlimited seats, and Slack support fits a scaling platform team. Langfuse's self-hosted free tier is cheaper if you would rather run the infrastructure yourself; Helicone's entry pricing undercuts Starter for pure request logging, but
In short
Lmnr — Open-source agent observability that auto-captures every LLM and tool call and flags failures you never wrote a detector for. Best for Teams shipping multi-tool and sub-agent AI products where failures are emergent, Developers using Claude Code or Codex CLI who want each turn traced and queryable, Agent engineers who want SQL-level access alongside a prebuilt transcript view. Free to start; paid plans from $30/mo.
What's new in Lmnr
Checked 3 days agoAcross the latest 9 updates: 6 feature updates, 1 launch and 2 community discussions.
flow-1: Frontier trace intelligence at 1/20th of the cost
Laminar released flow-1, a trace intelligence model priced at 1/20th of comparable frontier models. Also available as an LLM profile for self-hosted Signals.
Self-hosted Signals can run on the Laminar Cloud model
Self-hosted deployments can run Signals on flow-1, the Laminar Cloud Signals model, via a Custom (OpenAI-compatible) LLM profile. Traces stay on the deployment; only model requests go to Cloud, billed as Cloud Signals usage.
Microsoft Agent Framework instrumentation in Python
Laminar traces Microsoft Agent Framework agents in Python when agent-framework-core is installed, capturing agent runs and chat turns with prompts.
OpenAI Decisions API tracing in TypeScript and Python
Laminar traces OpenAI Decisions calls: experimental_decide in Vercel AI SDK v7 (@lmnr-ai/lmnr 0.8.50) and client.decisions.create in the OpenAI SDK (lmnr 0.7.65). Each call becomes an LLM span with questions, answers and token counts.
Harbor plugin turns jobs into Laminar evaluations
Run Harbor with --plugin laminar: each job becomes a Laminar evaluation, each trial a datapoint scored with verifier rewards, grouped by dataset. Ships in the Python SDK and covers agents in any language.
Usage warnings and hard limits for paid workspaces
Paid-plan owners can set email warnings and hard limits on data ingestion (GB) and Signals usage (USD) in Settings > Usage. Hard limits reject new ingestion or Signal runs until the cycle resets.
Google ADK auto-instrumentation in Python
Laminar.initialize() auto-instruments Google ADK in Python; agent, call_llm and tool spans traced with session and user IDs. Ships in lmnr 0.7.62; google-adk 2.10+ needs lmnr 0.7.67 for prompt/response capture.
Extracting Tasks from Millions of Agent Runs
Engineering post on extracting tasks from large volumes of agent runs at Laminar.
How we built SQL interface for agents
Engineering post on Laminar's SQL interface for querying agent traces.
What people actually say about Lmnr — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
51 mentions across 5 sources (Hacker News, YouTube, Bluesky, GitHub, Lemmy) · researched Jul 15, 2026.
Average across the 5 sources that answered — each source counts once, not each post.
- +Open-source with Rust core for high performance.
- +Natural-language Signals for easy failure detection.
- +Agent-specific observability catches infinite loops and tool errors.
- +Free tier available for small-scale usage.
- +Full-text search and SQL editor for deep data queries.
- −Limited community and support channels outside GitHub.
- −Setup requires understanding of OTLP and agent architecture.
- −Dashboard customization can be complex for beginners.
- −Some integrations are still in development or incomplete.
- −Pricing for enterprise features is not transparent.
- • API usage above free tier may incur additional charges.
Viability Score
How well maintained and how widely used is Lmnr? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Automatic capture of LLM calls, tool calls, sub-agents, costs and tokens
- Transcript view with cost heatmap instead of a raw span tree
- Signals: surfaces agent failure modes with no pre-defined detectors
- flow-1 model for trace analysis, fine-tuned and RL post-trained
- Signal event clusters with failure distribution and trend counts
- Clusters auto-resolve when a failure stops and reopen if it recurs
- Eval datasets generated automatically from fixed failure clusters
- Laminar Agent in Slack answers questions about your traces
- Agent debugger with MCP and CLI full SQL access to traces
- Replay a recorded run from cache up to the point under test
- Custom dashboards and SQL editor over raw trace data
- Automatic agent input extraction from every run
- Labeling queues to build datasets from traces or SQL results
- Browser session recording alongside traces
- Server-side PII removal and OTLP trace ingestion
About Lmnr
Laminar is an open-source observability platform built for teams shipping AI agents, not single-prompt chatbots. Add it in a couple of lines and it captures LLM calls, tool calls, sub-agents, token counts and costs over OTLP, then renders them as a readable transcript with a cost heatmap instead of a raw span tree. Auto-instrumented integrations cover the Vercel AI SDK, Claude Agent SDK, OpenAI Agents SDK, LangChain, DeepAgents, OpenCode SDK, LiteLLM, Mastra, Pydantic AI, OpenHands SDK, plus browser stacks like Browser Use, Stagehand and Playwright. The differentiator is Signals. Rather than hand-writing detectors, Signals reads every run with Laminar's own fine-tuned, RL post-trained model, flow-1, which the vendor benchmarks at frontier-level trace-analysis intelligence while analyzing about 20x more traces per dollar. Failures land in event clusters with counts and distribution — the docs' example is an agent hitting web_search three times for the same question, walking past a 404 without retrying, then reporting unverified results. Clusters auto-resolve when a failure stops and reopen if it returns. Around that: an Evaluations UI with side-by-side run deltas, automatic input extraction that turns production traces into e2e eval datasets, custom dashboards on raw SQL, labeling queues, browser session recording, server-side PII removal, and Slack or email alerts. The Laminar Agent in Slack answers questions about your traces, and the CLI plus MCP hand your coding agent full SQL access so it can investigate a trace, build an eval, and verify the fix. Suits multi-tool and sub-agent products where failures are emergent rather than enumerated. Poor fit for single-prompt chat apps, for infra-level APM needs, and for anyone who wants a point-and-click dashboard with no SQL.
Behind the Verdict
Pick Laminar when your agent has grown past the point where you can name its failure modes. If you're shipping a product with sub-agents, browser tools and multiple model providers, the transcript view plus Signals clusters will surface things like repeated searches or unverified answers that no one on your team thought to alert on. It's also the rare observability tool that treats your coding agent as a first-class user. The CLI and MCP give Claude Code or Codex SQL against your traces, so you can ask it to replay a cached run to the failing step, patch, and re-verify rather than eyeballing a dashboard at 11pm. Where it bites: Signals billing is separate from storage and scales with trace size, so a high-volume agent sees two line items. The pricing calculator's own example — 100M tokens a month, all runs analyzed — pushes Starter to roughly $33.50/mo, not $30. Free caps at 1 GB, 7 days, one seat and one project; that's a taste, not a production tier. Starter's 3 GB goes fast once you're storing full trace payloads, though the vendor claims up to 20x compression. Pass if your product is a single-prompt chat wrapper. There's nothing here for you that a basic logging setup doesn't cover. Pass too if your monitoring need is host-level APM — CPU, memory, latency on the app server — because Laminar is aimed at agent run analysis, not infrastructure. The honest comparison is Langfuse. Langfuse is the more established open-source option with a wider feature surface and a self-host path many teams already trust. Laminar's counter is automation: you don't write the detectors, and the eval-dataset-from-fixed-cluster loop closes the regression gap. If your team already has a mature Langfuse deployment and working detectors, the switching cost is real and Signals has to earn
Researching Lmnr? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Lmnr actually fits — and what changes day-one when you adopt it.
Instruments the stack with @lmnr-ai/lmnr over OTLP, repoints the Browser Use and Playwright instrumentation at Laminar, and leaves Signals on the default configuration.
Outcome: Signal clusters surface repeated 404 handling failures within the first day; the developer turns the fixed cluster into an eval dataset and catches the regression before the next release.
On Pro with 10 GB included and 6-month retention, connects Terraform to manage Signals and LLM profiles as code, and wires Slack alerts to the on-call channel.
Outcome: Failures page the on-call engineer with a trace link and similar-event count, and the team stops discovering regressions from customer reports.
Installs the one-command Claude Code plugin so each turn is traced per conversation, then has the coding agent use the Debugger over MCP with full SQL access.
Outcome: The agent records a failing run, replays it from cache to the failing point, proposes a prompt or tool fix, and verifies it with an eval — without the engineer leaving the terminal.
Use Cases
- Catch infinite loops and failed tool calls in production agents using natural-language Signals instead of hand-written detectors.
- Find failure modes you never anticipated and see their distribution across runs via Signal clusters.
- Replay a traced run from cache with a different prompt or model and compare outputs side by side.
- Turn every fixed error cluster into an eval dataset and run it after each release to catch regressions.
- Let Claude Code or Codex query traces over MCP and verify a fix without leaving the terminal.
- Ask plain-English questions about your traces in Slack through the Laminar Agent.
- Compress agent trace storage by up to 20x to keep observability costs down.
- Build custom dashboards and ad-hoc analyses on raw SQL over your spans.
Models Under the Hood
as of 2026-10-18
Limitations
- The Free tier is capped at 1 GB of data with no overage, 7-day retention, 1 project and 1 seat, and excludes Signals beyond a one-time $5 credit, making it an evaluation tier rather than a production choice.
- Paid plans carry two meters: included data plus overage ($2/GB on Starter, $1.50/GB on Pro) and Signals usage billed on the tokens flow-1 consumes analyzing your traces ($0.05/input Mtok, $0.01/cached Mtok, $0.30/output Mtok), not on your agent's own token use.
- On-premise deployment and custom limits are Enterprise-only.
- Pricing notes that storage costs are not proportional to token count due to trace compression, and stated totals are estimates only.
as of 2026-10-07
Verification history
We have re-verified Lmnr 9 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 9 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Lmnr tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Free
$0/mo
Ideal for
A solo developer or small team evaluating whether Signals-style automatic failure detection fits their agent stack.
What this tier adds
Starting tier at $0/mo: 1 GB data with no overage, a one-time $5 Signals credit, 7-day retention, 1 project, and 1 seat.
Starter
$30/mo
Ideal for
A small team putting an agent into early production and needing a month of trace history plus email support.
What this tier adds
Adds 3 GB included data ($2/GB after), 30-day retention, unlimited projects, and unlimited seats for $30/mo.
Pro
$150/mo
Ideal for
A scaling platform team running many agents who need 6-month retention, Slack support, and Terraform-managed configuration.
What this tier adds
Raises included data to 10 GB ($1.50/GB after), extends retention to 6 months, and adds Slack support for $150/mo.
Enterprise
Custom
Ideal for
Regulated or security-constrained organizations that need on-premise deployment, custom limits, and a dedicated support channel.
What this tier adds
Custom limits, on-premise deployment, and dedicated support, priced by contract.
Where the pricing makes sense
The company stage and team size where Lmnr's pricing actually pencils out — and where peers do it cheaper.
Free at $0 covers 1 GB, 7-day retention, 1 project, and 1 seat — enough for a solo developer to evaluate the Signals approach. Starter at $30/mo with 3 GB and 30-day retention fits a small team in early production; Pro at $150/mo with 10 GB, 6-month retention, unlimited seats, and Slack support fits a scaling platform team. Langfuse's self-hosted free tier is cheaper if you would rather run the infrastructure yourself; Helicone's entry pricing undercuts Starter for pure request logging, but
Setup time & first value
How long it actually takes to get something useful out of Lmnr — broken out by persona, not the marketing-page minute.
Trace ingestion is a few minutes: install the SDK, add your project API key, and send spans over OTLP — the vendor describes setup as spanning two lines for supported frameworks. Signals work from the first trace with the default configuration, so plain-language failure detection is live on day one. Full value from the Debugger, MCP, and Terraform workflow is realistically a half-day for a
Switching to or from Lmnr
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From Langfuse: repoint your instrumentation to send OTLP spans to Laminar and rebuild dashboards on the SQL editor using your existing span attributes.
- →From Helicone: swap the proxy or SDK layer for @lmnr-ai/lmnr, keep your prompts in place, and enable Signals instead of re-authoring saved filters as detectors.
- →From LangSmith: export datasets via the API, import them into Laminar Datasets, and recreate evaluation runs locally or in CI.
- →From raw OpenTelemetry tracing: keep the collector and add a Laminar OTLP exporter — you gain the transcript view and Signals without changing your span schema.
- →From ad-hoc logs: instrument the frameworks you already use (AI SDK, LangChain, Claude Agent SDK) and backfill eval cases from the first week of real traces.
- ↗To Langfuse: export traces and datasets via the API, keep your OTLP collector, and reimplement Signals as manual detectors or dashboard filters.
- ↗To Helicone: move instrumentation to the proxy or SDK, accept the loss of transcript-view clustering, and rebuild eval datasets from your Laminar Datasets exports.
- ↗To LangSmith: re-instrument with the LangChain-native SDK, port eval datasets, and replace Slack alerting with the provider's own notification hooks.
- ↗To a self-hosted stack: run Laminar's open-source deployment on your own infrastructure rather than rewriting against a different vendor.
- ↗To a broader APM: forward the same OTLP spans to Datadog or Grafana for infra-level metrics while keeping Laminar for agent-run analysis.
Integrations
Resources & Guides
- Documentationlaminar.sh
Docs · Lmnr
Full product docs from laminar.sh
- Documentationlaminar.sh
Llms · Lmnr
Full product docs from laminar.sh
- Documentationlaminar.sh
Introduction · Lmnr
Full product docs from laminar.sh
- Quickstartlaminar.sh
Quickstart · Lmnr
Get up and running fast from laminar.sh
- Documentationlaminar.sh
Setup · Lmnr
Full product docs from laminar.sh
- Quickstartlaminar.sh
Quickstart · Lmnr
Get up and running fast from laminar.sh
- Documentationlaminar.sh
Introduction · Lmnr
Full product docs from laminar.sh
- Documentationlaminar.sh
Self Hosting · Lmnr
Full product docs from laminar.sh
- Documentationlaminar.sh
Api Reference · Lmnr
Full product docs from laminar.sh
- Documentationlaminar.sh
Changelog · Lmnr
Full product docs from laminar.sh
Tutorials & Learning
YouTube returned 6 videos for “Lmnr”, and we withheld 6: 6 could not be judged, because “Lmnr” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Lmnr.
Official links
Tools that pair well with Lmnr
Common stack mates teams adopt alongside Lmnr, with the specific reason each pairing earns its keep.
Arize Phoenix
Arize Phoenix is open-source LLM observability: trace agent steps, run evals, and self-host your traces.
Phoenix
Open-source LLM observability and agent evaluation you can trace, evaluate, and self-host for free.
Langfuse
Open-source LLM observability and agent evals: trace, evaluate, and improve production AI agents with MIT-licensed tooling.
Featured Head-to-Head Comparisons
Lmnr vs Spider Cloud
Choose Lmnr if your pain point is debugging agent loops, tool errors, or sub-agent misbehavior — its Signal-based failure detection and Agent Debugger are uniquely built for that. Choose Spider Cloud if what you need is fast, cheap, and reliable web scraping with AI extraction, especially to feed data into RAG pipelines or LLMs. They solve very different problems; the right pick depends on whether you're building agents or feeding them data.
Lmnr vs Temporal Ai
Choose Lmnr if you need deep visibility into agent failures like loops and tool errors, with natural-language signals and auto-resolution. Choose Temporal AI if your priority is ensuring multi-step workflows survive infrastructure crashes and require complex retry/Saga patterns. They complement each other – many teams use both.
Lmnr vs Presto Voice
Lmnr and Presto Voice serve entirely different domains: Lmnr is for developers building and debugging AI agents, while Presto Voice is for QSR chains automating drive-thru ordering. Pick Lmnr if you need open-source observability with agent-specific failure detection and trace compression; choose Presto Voice if you run a multi-location restaurant and want voice AI that up-sells and integrates with your POS.
Alternatives to Lmnr
View all
Arize Phoenix
Arize Phoenix is open-source LLM observability: trace agent steps, run evals, and self-host your traces.
Frequently Asked Questions
Used Lmnr? Help shape our editorial sentiment research.