Laminar

Editor’s note: This Laminar review is based on my October 2026 hands-on test of Laminar Cloud and the self-hosted v0.3.2 release with the Python and TypeScript SDKs. I weighed pricing, setup, agent tracing, Signals, debugging and evals, self-hosting, data controls, and rivals.

Quick verdict: I recommend Laminar for teams running long, multi-step agents (browser agents, coding agents and subagent trees) that need to find why a run failed. Free keeps just 1 GB for 7 days with no Signals, and self-hosted Signals, clusters and alerts need an enterprise license key.

Laminar is Apache 2.0 open-source observability for AI agents, built on OpenTelemetry by a YC S24 company. The product moved from lmnr.ai to laminar.sh, and paid cloud starts at $30/month with unlimited seats.

In this review, I’ll take a closer look at Laminar’s pricing, features, and agent debugging tools, so you can see exactly whether it fits your agent stack.

Key Takeaways

• Free costs $0: 1 GB, 7-day data access, 1 project, 1 seat, and no Signals.
• Starter costs $30/month: 3 GB, then $2/GB, with 30-day access and unlimited seats. Pro costs $150: 10 GB, then $1.50/GB, with 6-month access.
• Signals bill separately: by analysis tokens, about $3.50 per 1,000 traces of 100K tokens.
• Compliance starts at Pro: SOC 2 Type II, HIPAA, server-side PII removal and a DPA are listed only on Pro and Enterprise.
• Self-hosting has paid gates: the Apache 2.0 core is free, but Signals, clusters and alerts need a license key.

Pros and Cons

How Much Does Laminar Cost?

Laminar has 4 cloud plans metered on stored trace data in GB, with Signals billed separately on the Signals agent’s tokens, not your agent’s model usage. Your own LLM bill never enters the Laminar invoice.

• Free ($0/month): for solo testing, with 1 GB and no overage, 7-day data access, 1 project and 1 seat. Community support is included; Signals are not.
• Starter ($30/month): for small teams, with 3 GB, then $2/GB, and 30-day access. Unlimited projects and seats, email support and a $5 one-time Signals credit are included.
• Pro ($150/month): for production teams, with 10 GB, then $1.50/GB, and 6-month access. It adds Slack support and the same unlimited projects, seats and $5 one-time credit.
• Enterprise (custom): for organizations that need custom limits, an on-premise deployment or dedicated support. Seats and projects stay unlimited, and the Laminar team can also run a licensed deployment inside your AWS or GCP account.

Plan	Monthly price	Data included	Overage	Data access	Seats
Free	$0	1 GB	None, hard cap	7 days	1
Starter	$30	3 GB	$2 per GB	30 days	Unlimited
Pro	$150	10 GB	$1.50 per GB	6 months	Unlimited
Enterprise	Custom	Custom	Custom	Custom	Unlimited

Signals token type	Starter and Pro rate per million tokens
Input	$0.05
Cached input	$0.01
Output	$0.30

For 1,000 agent runs of 100K tokens each, Signals come to about $3.50. That puts Starter at about $33.50 and Pro at $153.50 before GB overage, and the $5 one-time credit covers roughly the first 1,400 such runs.

Workspace owners on Starter and up can set usage warnings and hard limits for data GB and for Signals dollars under Settings > Usage. Warnings email owners once per billing cycle per threshold, and Free runs on fixed limits instead.

Laminar compresses traces, so stored GB is not proportional to token count. Measure a week of your own traces before picking a plan.

Is Laminar Good Value for Money?

• Starter wins on data: by my arithmetic, 13 GB a month costs $50 on Starter versus $154.50 on Pro, and Starter stays cheaper on data until roughly 222 GB a month.
• Pro buys retention and controls: the $120 premium pays for 6-month history, Slack support and the SOC 2/HIPAA/DPA column, not cheaper storage.
• Seats favor Laminar: Starter includes unlimited seats, while LangSmith Plus costs $39 per seat per month. Langfuse Core is $29/month for 100K units and 90-day retention.
• Free is a trial: its 7-day window suits checking instrumentation, not keeping production history.

Reviewer’s Notes: I’d start on Starter, not Free, once traces matter past a week, and move to Pro only when 6 months of history or a signed DPA/HIPAA is a requirement. Set the Signals dollar hard limit before backfilling historical runs.

My Experience With Laminar

Creating a Project and Running the CLI Setup

I signed up at laminar.sh, created a project, and ran npx lmnr-cli@latest setup from my project directory. The CLI authenticated, wrote a new project API key to the env file as LMNR_PROJECT_API_KEY, linked the directory and installed the Laminar skill for coding agents.

It then offered a suggested prompt for my coding agent: instrument the project, run it, and verify the traces table with lmnr-cli sql query. This is the fastest route if a coding agent already works in your repo, because the same skill later drives the debugger.

Instrumenting My Agent

I also tried the manual Python route with pip install lmnr and Laminar.initialize(), which read LMNR_PROJECT_API_KEY from the environment. The minimal custom-span pattern looked like this:

from lmnr import Laminar, observe

Laminar.initialize()

@observe()
def agent_step(task):
    return task

The @observe() decorator creates a span per function call, captures arguments, return values and exceptions, and nests automatically when one observed function calls another. Custom span names are supported.

For TypeScript, I installed @lmnr-ai/lmnr and called Laminar.initialize({ instrumentModules: { OpenAI: OpenAI } }), which instrumented OpenAI calls with no other code changes. The TypeScript observe() wrapper does the same job as Python’s decorator.

Check the integration list before wrapping everything by hand. Auto-instrumentation or recording covers:

• Model providers and routing: Anthropic, OpenAI, Gemini, Cohere, LiteLLM and OpenRouter.
• Application frameworks: Vercel AI SDK, LangChain/LangGraph, Mastra and Pydantic AI.
• Agent SDKs: OpenAI Agents SDK, Claude Agent SDK and Google ADK.
• Coding agents: Claude Code and Codex, where each prompt becomes a trace.
• Browser agents: Browser Use, Stagehand, Skyvern, Playwright and Puppeteer.

I let auto-instrumentation capture the provider calls and used @observe() on the surrounding agent function, so the trace showed both model turns and my own function structure.

Reading My First Trace

After running the agent, I opened the project in the default Transcript view. Agent input, LLM turns and tool calls read as one conversation, and each subagent sat in a collapsed card that expanded in place.

Tree and Timeline views gave me the span hierarchy and execution order, and the Metadata and Chat side panels sat alongside. Tokens and cost showed per run, so spend stayed attached to the run that caused it.

Reviewer’s Notes: Free drops traces after 7 days, so move anything you need for follow-up before then. On self-host, the SDK config needs explicit ports (8000 for HTTP, 8001 for gRPC), and some MCP and CLI endpoints still use lmnr.ai addresses.

Agent Tracing: Transcript View, Browser Replay and SQL

Laminar is built on OpenTelemetry with OTLP ingestion, plus auto-instrumentation across model providers and agent frameworks. It suits failures that span a whole agent run rather than a single LLM response.

Transcript, Tree and Timeline Views

Transcript keeps subagent work nested in expandable cards, which made long delegated runs readable for me. Laminar can also dual-export to Langfuse, so a team already on Langfuse can trial it without ripping out the existing backend.

• Transcript: agent input, model turns and tool calls in conversation order.
• Subagent cards: collapsed branches that expand inside the parent conversation.
• Tree and Timeline: span hierarchy and execution sequence.
• Custom render templates: control over how trace content displays.
• Task extraction: the user task lands in an Input column and as agent_input in SQL.

Browser Session Replay

Browser replay records the browser run synced to spans for Browser Use, Stagehand, Puppeteer, Playwright and Skyvern. I could tie a browser moment to the tool call that produced it, and input masking is configurable for sensitive form fields.

Users report recordings missing from the Evaluations tab and a rendering issue with Browser Use pages, so I’d rely on replay from the main trace view.

SQL Editor, Dashboards and MCP

The SQL editor runs read-only ClickHouse queries scoped to the project, next to full-text trace search and custom dashboards. Multiple dashboards per project arrived in October 2026.

MCP exposes three tools to a coding agent:

• ask_agent: natural-language questions answered by Laminar Agent.
• query_laminar_sql: read-only, project-scoped SQL.
• get_trace_context: a trace summary formatted for an LLM.

MCP authenticates with the full project API key, and read-only project keys are still a user request. On self-host, users report get_trace_context and ask_agent returning success when the feature is unavailable.

Signals: Plain-Language Failure Detection

A Signal is a plain-language instruction plus a JSON output schema. The Signals agent reads each finished trace and returns a structured event with links to evidence, or no event.

One example: a Signal that flags a final report contradicting its own tool output and records the claim, the evidence and a claim type. That beats a bare failure flag because the evidence link points at the exact span.

I set up a Signal from the Failure Detector template, which every new project includes:

• Open Signals > Create Signal: pick Failure Detector as the template.
• Write the instruction: describe the behavior to detect.
• Define the JSON schema: the fields each event returns.
• Set trigger, filters and sample rate: choose which traces get analyzed.
• Backfill historical traces: review events before enabling alerts.

Signal event clusters group similar events by meaning, events stay queryable in SQL, and alerts go to Slack or email. Signals can also be managed through the CLI, a REST API and a Terraform provider.

Cloud Signals run on Laminar’s own model, flow-1, billed per analysis token, so the sample rate is your spend control. Users report Failure Detector flagging a tool call and its own execution as a repeated call, so review events before trusting a cluster.

Laminar Agent answers questions about traces, costs, evals, Signals and clusters by running SQL, from the app, from Slack via @Laminar, or over MCP.

Reviewer’s Notes: Run the first backfill at a low sample rate and set the Signals dollar hard limit before widening coverage. Free has no Signals, so this workflow needs Starter or a licensed self-hosted deployment.

Debugger Replay, Evals and Datasets

Debugger

I recorded a session with LMNR_DEBUG=true, then replayed against the recorded trace with LMNR_DEBUG_REPLAY_TRACE_ID. LLM responses came from cache up to the span set in LMNR_DEBUG_CACHE_UNTIL, and everything after it ran live.

The cache key is the trace ID plus a hash of input messages, excluding system messages, so I could edit the system prompt or tool definitions between replays without breaking the cache. That saves re-paying for every early step of a long run just to test one late fix.

The debugger is built to be driven by a coding agent such as Claude Code, Cursor or Codex through the Laminar skill. Vercel AI SDK needs wrapLanguageModel for caching to work.

Evals

I ran an evaluation with evaluate(), available in both SDKs. It takes four inputs:

• Data: datapoints containing data and target.
• Executor: the function under test.
• Evaluators: functions that score the executor’s output.
• Name: the evaluation’s label.

Results appear in the UI with run comparison, and evals run with LMNR_DEBUG=true join the same debugger session. A manual evaluation API and a Harbor plugin cover CI and benchmark runs.

Braintrust is the evals-first alternative at $249/month for Pro, with 50K scores included. I’d pick Laminar when replaying production failures matters as much as comparing eval runs, because the debugger restores a failed run from cache instead of re-running it.

Datasets and Labeling Queues

Labeling queues move production traces through New, Modified and Approved states, and approved items push into a dataset. I’d keep each fixed failure as a dataset item so the next eval catches a regression.

Users are still requesting an API to attach scores to a trace after the fact, and a compare view that flags indistinguishable eval runs.

Self-Hosting, PII Redaction and Compliance

docker compose up -d started the frontend and app server with PostgreSQL, ClickHouse and Quickwit behind them. I opened the dashboard at localhost:5667; SDKs connect on port 8000 (HTTP) and 8001 (gRPC).

docker-compose-full.yml adds RabbitMQ, and the Helm chart adds Redis and needs an S3-compatible bucket, with EKS or GKE recommended. Budget for five or more services, not one container.

• Free Apache 2.0 core: tracing, search, dashboards, SQL editor, CLI, evals, datasets and labeling queues.
• Also included: browser recording, debugger, MCP, chat-with-trace and PII redaction.
• Requires LMNR_LICENSE_KEY: Signals, signal event clusters, email alerts and Slack alerts.

AI features on self-host need your own LLM key (Gemini by default, or OpenAI or Bedrock).

Default self-hosted sign-in lets any user in. Restrict it with GitHub OAuth before exposing the deployment; Google, Azure AD, Okta and Keycloak also work.

Users report ClickHouse system log tables reaching 13.4 GiB after a month of light use, against 15.6 KiB of Laminar data. Apply the ClickHouse config that disables those logs before production.

PII Redaction

Under Project Settings > Security, each project gets three modes:

• Off: no redaction.
• On: only redacted text is stored.
• Dual: originals are stored and redaction applies on read, with originals visible to owners and admins.

Redaction runs a PII detection model on span input and output at ingest and does not rewrite existing traces. Pick On when originals must never be retained.

On Cloud, SOC 2 Type II, HIPAA, server-side PII removal and a DPA are listed only on Pro and Enterprise. Laminar does not publish data regions, so confirm residency with sales before sending regulated data.

Langfuse is also free to self-host; I’d still pick Laminar when the debugger and browser recording matter more than avoiding the Signals license.

How Does Laminar Compare to Competitors?

Laminar is my pick for multi-step agents that need replay and failure detection, at $30/month with unlimited seats, but each rival below wins a narrower job.

• Langfuse: better for prompt management and evals, and free to self-host. Hobby includes 50K units a month with 30-day retention; Core costs $29/month for 100K units, 90-day retention and unlimited users; Pro costs $199/month. Core beats Laminar Starter when 90 days of cloud history matters more than agent replay.
• LangSmith: the pick for teams built on LangChain/LangGraph. Developer is $0 with 5K base traces and 1 seat; Plus costs $39 per seat/month with 10K base traces and 14-day base retention. A five-person team pays $195/month on Plus versus $30 on Laminar Starter.
• Arize AX and Phoenix: Phoenix is the open-source, local-first option; AX is the cloud platform. AX Free includes 25K spans, 1 GB and 15 days; AX Pro costs $50/month with 50K spans, 10 GB and 30-day retention. Pick it when you want Phoenix running locally first and a cloud tier later.
• Braintrust: evals-first. Starter is $0 with 1 GB of processed data and 10K scores; Pro costs $249/month with 5 GB and 50K scores. I’d choose Laminar when the main job is replaying agent failures rather than scoring.
• Helicone: proxy-based request logging. Hobby includes 10K requests with 7-day retention; Pro costs $79/month with 1-month retention, and Team costs $799/month. It logs requests at the proxy, so it shows no subagent trees and offers no step replay.
• Traceloop: OpenLLMetry instrumentation that sends to any OpenTelemetry backend. It fits teams keeping their existing observability stack, and since Laminar ingests OTLP, the two can coexist.

Langfuse units, LangSmith traces, Arize spans and Helicone requests measure different things, and Laminar meters stored GB with Signals tokens on top. Measure your own trace payloads before comparing headline allowances.

Tool	Free tier	Paid entry	Self-host	Best for
Laminar	1 GB, 7 days	$30/month, unlimited seats	Yes, Apache 2.0 core	Long-running agents
Langfuse	50K units, 30 days	$29/month	Yes, free	Prompt management and evals
LangSmith	5K base traces, 1 seat	$39/seat/month	Enterprise	LangChain/LangGraph teams
Arize AX	25K spans, 15 days	$50/month	Phoenix is the local option	Cloud observability or local Phoenix
Braintrust	1 GB, 10K scores, 14 days	$249/month	Not covered	Evals-first workflows
Helicone	10K requests, 7 days	$79/month	Not covered	Proxy-based request logging

How I Reviewed Laminar

I set up Laminar Cloud with the CLI and the Python SDK, traced an agent with auto-instrumentation and @observe(), and initialized OpenAI instrumentation in TypeScript. I read runs in the Transcript, Tree and Timeline views.

I defined a Signal from the Failure Detector template, replayed a run with the debugger and ran an evaluate() job. I also brought up the self-hosted v0.3.2 stack with Docker Compose and checked its sign-in and PII redaction settings.

I priced the meter at 3 GB, 13 GB and the roughly 222 GB break-even, plus Signals for 1,000 analyzed runs. I weighed setup, trace readability, debugging, evals, data controls and total cost against Langfuse, LangSmith, Arize, Braintrust and Helicone, along with problems users report.

Prices current as of October 2026.

Should You Use Laminar for Your AI Agents?

Yes, if you run long, multi-step or browser agents and want transcript reading, step replay and Signals on a $30 plan with unlimited seats. The Apache 2.0 core is also a solid self-hosted route for tracing, evals and the debugger, as long as you can live without Signals or pay for a license.

Skip it if prompt versioning is your main job (Langfuse) or your stack is all-in on LangChain (LangSmith). Skip Laminar Cloud too if you need SOC 2 or HIPAA under $150 a month, because Starter does not list either. Self-hosting keeps data in your infrastructure, but it does not add those certifications.

Start with npx lmnr-cli@latest setup on Free and trace one representative agent run. Move to Starter before the 7-day window drops traces you need, then set GB and Signals dollar limits before widening production coverage.

FAQs

Is Laminar free?

Yes. The Free cloud plan is $0 with 1 GB, 7-day data access, 1 project and 1 seat, but no Signals. The Apache 2.0 core is also free to self-host, though you pay for your own infrastructure, and self-hosted Signals, clusters and alerts need an enterprise license key.

How much does Laminar cost?

Starter costs $30/month for 3 GB, then $2/GB; Pro costs $150/month for 10 GB, then $1.50/GB; Enterprise is custom.

Signals add analysis-token charges of $0.05 per million input tokens, $0.01 cached and $0.30 output. I’d pick Starter unless Pro’s 6-month retention or compliance listing justifies the $120 premium. Usage warnings and hard limits on both paid plans keep overage from surprising you.

Is Laminar open source?

Yes. Laminar’s core is Apache 2.0 in the lmnr-ai/lmnr repository, with about 3.4K stars on GitHub.

The open build includes the debugger, evals, SQL editor, MCP and browser recording. Signals, signal event clusters and alerts sit outside it and require an enterprise license key. The latest release is v0.3.2, from October 2026.

What happened to lmnr.ai?

Laminar’s product site moved from lmnr.ai to laminar.sh; it is the same product. The Python package is still lmnr and the TypeScript package is still @lmnr-ai/lmnr. Some MCP and CLI endpoints also keep lmnr.ai addresses, so the domain change did not rename every integration.

Does Laminar support OpenTelemetry?

Yes. Laminar ingests OTLP, so any OpenTelemetry source can send traces, not only the Python and TypeScript SDKs. Python’s @observe() decorator and TypeScript’s observe() wrapper create OTel-compatible spans for custom functions, while provider auto-instrumentation captures model calls without a wrapper around every request.