You built an agent, not a chatbot. It plans, calls three tools, retries one, reads a page, and answers. It works in the demo. Then in production it quietly burns forty seconds looping between the same two tool calls, and your logs show a tidy 200 OK for each one. Nothing is broken. It's just wrong, and you can't see why.
Generic LLM observability was built for a simpler shape — one prompt, one completion, log it, grade it. An agent is a tree: nested calls, tool results, retries, sub-agents. Laminar (the lmnr project) is an open-source observability platform built for exactly that shape, and it adds two things a plain LLM tracer doesn't have.
What it is: an open-source (Apache-2.0, per its repository), Rust-built platform for tracing, evals, and monitoring AI agents, built on OpenTelemetry. It captures the full run — every model call, tool call, retrieval, and retry as a tree of spans with inputs, outputs, latency, and cost — and layers agent-specific tooling on top. It's made by a Y Combinator (S24) company.
What it does#
Four jobs, one agent-shaped workflow:
- Tracing / observability. One line of setup auto-instruments the stacks you already use — the OpenAI, Anthropic, and Gemini SDKs, LangChain, the Vercel AI SDK, and browser agents like Browser Use and Stagehand — because it's OpenTelemetry-native. You get the whole run as a span tree, not a pile of disconnected completions. This is the trace-is-the-new-log idea, applied to agents.
- Signals. Describe bad behavior in plain English — "the agent is stuck in a loop," "it called the same tool five times" — and Laminar watches for it and pings you (e.g. in Slack) when it happens. That's the difference between finding the looping agent because a user complained and finding it because a rule you wrote in a sentence fired.
- SQL over your traces. Query traces, spans, metrics, and events with SQL, from the CLI or through an MCP server — so a coding agent can investigate a production incident by writing queries against your telemetry instead of you clicking through a dashboard. If you've been tracing MCP tool calls without sessions, this is the read side of that same instinct.
- Evals. An unopinionated SDK and CLI for running evals locally or in CI, with a visualization UI — so "did this change help?" becomes a number you can gate a deploy on.
Who it's for#
Founders and small teams whose product is an agent — something that loops, calls tools, and makes decisions — rather than a single LLM call wrapped in a UI. It's especially worth a look if:
- Your failures are behavioral (loops, wrong tool, silent retries), not just wrong text, and a completion-level tracer keeps missing them.
- You want alerting you can write in a sentence, not a metrics query you have to design first.
- You like the idea of your coding agent debugging production by querying traces over MCP — Laminar is built for that.
- You care about a permissive license: Apache-2.0 self-hosting means no
ee/-folder carve-outs.
How to start#
Install the SDK — TypeScript (@lmnr-ai/lmnr on npm) or Python (lmnr on PyPI) — and initialize once. Instrumentation is automatic from there:
from lmnr import Laminar
Laminar.initialize(project_api_key="...") # one call — your OpenAI/Anthropic/LangChain calls now traceTo self-host, clone the repo and bring it up with Docker Compose; because it speaks OpenTelemetry, you can point existing OTel instrumentation at your own instance without rewriting anything. The managed cloud at laminar.sh is the zero-ops path.
What it costs#
As listed on laminar.sh (July 2026): a free tier, then paid plans that scale on data volume rather than per seat — which is the founder-friendly part, because adding a teammate doesn't add to the bill. Self-hosting is free under Apache-2.0. Confirm the current numbers on the pricing page before you commit; pricing in this category moves quarterly.
The honest catch#
Laminar is the newest tool in a crowded room. Its ecosystem, docs, and integration surface are younger than Langfuse's — the incumbent open-source pick, now ClickHouse-backed — and younger than LangSmith's LangChain-native tooling. You're trading maturity for an agent-first design, a permissive license, and two features (plain-English signals and SQL-over-traces via MCP) that the older tools don't frame the same way.
If your product is a single LLM feature, the mature generalist is probably the safer default. If your product is an agent — and you keep getting burned by failures that live between the calls, not inside them — Laminar is built for your shape of problem. For the full head-to-head, read Laminar vs Langfuse.
