Laminar

Laminar

Laminar (lmnr.ai) · Coding · Other

Laminar is an open-source observability platform that traces, debugs, and evaluates AI agents. It records every LLM call, tool call, and sub-agent, then turns that data into readable answers.

Interface preview of Laminar

About Laminar

What Is Laminar

Laminar is an observability and debugging platform built for AI agents, from the team at Laminar (lmnr.ai), a Y Combinator S24 company. It watches what your agent actually does during a run: the inputs, the LLM turns, the tool calls, and the sub-agents it spawns. The goal is simple. When an agent breaks after thirty minutes and three hundred decisions, you need to know where and why, fast.

The platform is OpenTelemetry-native, so it speaks the standard tracing protocol instead of a walled-garden format. You can run it two ways: as Laminar Cloud, the managed service, or self-hosted on your own infrastructure with Docker Compose or a Kubernetes Helm chart. The core is open source, which matters if your traces carry customer data you would rather not ship to a third party.

Two limits are worth stating up front. Signals, the plain-language outcome detector, is not part of the open-source build; you get it on Cloud or with an enterprise license key. And Laminar is a developer tool. There is no drag-and-drop app here, just SDKs, integrations, and a dashboard you read like a transcript.

Getting Started

  1. Create an account at laminar.sh or spin up the self-hosted stack with Docker Compose.
  2. Grab a project API key from the dashboard.
  3. Install the SDK and set the key, then initialize tracing in one or two lines of code.
  4. Run your agent. Traces appear live, and you can open any one of them to read the full run.

Product Information

A quick look at Laminar's pricing, supported platforms, and performance.

Free PlanYes
Paid Plans$0 - $150/mo
PlatformWeb, Docker, Kubernetes (SDKs for Python, TypeScript)
DeveloperLaminar (lmnr.ai)
CategoryCoding · Other
Release DateOct 2024
Latest UpdatedOct 2025
Website VisitsN/A
Website Global RankN/A
API AvailabilityYes

Best for

The users, tasks, and scenarios where this tool fits best.

Users

  • AI engineers building agents in production
  • Startup teams shipping LLM apps fast
  • Platform teams under data rules
  • Evaluation and QA engineers

Tasks

  • Debugging an agent that fails intermittently
  • Catching a release regression
  • Monitoring agent outcomes at scale
  • Comparing prompt or model changes

Scenarios

  • A browser agent that misbehaves on certain sites
  • A support bot that gives confident but wrong answers
  • A multi-step research agent that runs too long

Key features

Agent tracing and transcript view

Laminar records every LLM call, tool call, and custom function in a run. Instead of a tree of span names, it lays the run out as a transcript: inputs, LLM turns, tool calls, and sub-agents collapsed into cards. That format is the difference between reading one screen and holding a dozen spans in your head. It supports AI SDK, Claude Agent SDK, LangChain, and Browser Use out of the box, and it traces Claude Agent SDK sub-agents, which many tools skip.

Debugger with cache replay

The debugger records a run, then replays it with everything before your change served from cache. Each iteration takes seconds instead of a full live run, and you prove the fix with an eval rather than hoping. It is built to be driven by a coding agent, so the whole loop can run without you clicking through a UI.

Signals for production outcomes

Signals let you describe an outcome or failure in plain language, then extract structured events from every trace. Each Signal reads the entire run, including retries, exhausted tools, and workarounds the agent quietly made, not just the final answer. You get a stream of events you can query in SQL, cluster by type, and alert on through Slack or email.

Evaluations and datasets

You run evals against datasets locally or in CI, which catches regressions before they reach users. Datasets come straight from production traces, so your tests reflect real runs. A fixed error cluster can become an eval dataset automatically, closing the loop between a bug report and a test.

OpenTelemetry-native and self-hosting

Laminar ingests traces over OTLP, the standard OpenTelemetry protocol, so it fits stacks that already speak it. You can run the OSS images with Docker Compose for a single node, or the Kubernetes Helm chart for production, which adds RabbitMQ, Redis, and a dedicated consumer. Traces, dashboards, evaluations, and the debugger behave the same across Cloud and self-hosted.

CLI and MCP access

The CLI and MCP server give your coding agent full SQL access to Laminar. It can investigate traces, build evals, and verify fixes without a person copying data between tools. Combined with the SQL editor and custom dashboards, that covers the platform side of the product.

Pros and cons

Pros

  • Open source with a self-hosting path, so traces and customer data can stay on your own infrastructure.
  • OpenTelemetry-native, which means it slots into stacks already using OTLP instead of locking you in.
  • The transcript-style trace view is easier to read than the span trees most tools show.
  • Evaluations, datasets, and the debugger live in one place, so the debug loop stays in a single tool.
  • Free plan includes 1 GB of data and 7-day retention, which is enough to try the platform end to end.

Cons

  • Signals and alerts are not in the open-source build; you need Cloud or an enterprise license key, so the strongest production feature has a paywall.
  • The Free plan keeps only 7 days of traces and 1 project, which is tight for a long-lived production agent.
  • Data overage on Starter and Pro is billed by the gigabyte, so a chatty agent can add to the monthly total.
  • It is aimed at developers rather than casual users; AI agent observability here means SDKs, a CLI, and a web dashboard, not a one-click app.

Frequently asked questions

Laminar traces, debugs, and evaluates AI agents. It records every LLM call, tool call, and sub-agent in a run so you can find why an agent failed and confirm the fix with an eval.