Laminar: open-source observability for long-running AI agents

Laminar is an open-source observability platform built for agents that run for minutes, call dozens of tools and spawn subagents. It records the whole run, reads every trace for failures you describe in plain English, and turns those failures into evals. The platform's v0.3.1 release shipped on 13 October 2026, two days after v0.3.0 brought breaking changes to self-hosted installs; the Python SDK (lmnr) is at 0.7.67 and the TypeScript SDK (@lmnr-ai/lmnr) at 0.8.51.

Laminar groups its features around the agent-debugging loop:

• Tracing. An OpenTelemetry-native SDK that auto-instruments model SDKs (OpenAI, Anthropic, Gemini, LiteLLM and more), agent frameworks (the Claude Agent SDK, the OpenAI Agents SDK, LangChain and LangGraph, the Vercel AI SDK, Pydantic AI, Mastra) and browser automation (Browser Use, Stagehand, Playwright, Puppeteer, Skyvern). A run reads as a transcript: inputs, every model turn, every tool call, subagents nested under the turn that spawned them, with tokens and cost.
• Session replay for browser agents. A recording of the browser, synced with the spans, so you can scrub to the moment the agent clicked the wrong button and see the model call that chose it.
• Signals. You describe a behavior ("the agent claimed it finished but its own tool output shows a failure") with a JSON schema for what to record. Laminar's trace-analysis agent reads each run and emits a structured event when it finds a match, groups similar events into clusters, and alerts in Slack or by email.
• Evals and datasets. An SDK-first evaluate() function and an lmnr eval CLI for local runs and CI, with charts that track scores across runs.
• Built for coding agents. A debugger that reruns an agent from cached steps, an MCP server, a CLI with SQL access to all traces, and a skill that teaches Claude Code, Cursor or Codex to instrument and investigate.

In the stack it sits in agent operations: observability shaped around agent runs rather than single requests.

Laminar is a Y Combinator S24 company, and the whole repository is Apache-2.0 with no separate enterprise directory. The site moved from lmnr.ai to laminar.sh (the cloud ingestion endpoint is still api.lmnr.ai). It runs as a managed cloud or self-hosted with Docker Compose or a Helm chart, and the company states HIPAA and SOC 2 Type II compliance for its cloud.

Pick Laminar when:

• Your agents are long and branchy. A transcript view with collapsed subagents is easier to read than a flat span list once a run has 50 steps.
• You build browser agents. Seeing the page next to the decision beats reconstructing it from logs.
• Failures are silent. Tool calls succeed, latency is normal, and the answer is still wrong. Signals look for the behavior itself, on every trace, not only on a sample.
• Your team debugs with coding agents. The MCP server, SQL CLI and cached reruns let Claude Code or Codex investigate traces and verify a fix themselves.

Look elsewhere when:

• You need prompt management with deployment labels, or a broad evaluation platform for many teams. Langfuse covers prompts, datasets and LLM-as-a-judge in one place.
• You need a gateway with keys, budgets and failover. Use LiteLLM and trace through it.
• Policy forbids sending trace content to an LLM. Signals and the AI features read your traces with a model: Laminar's own on the cloud, or the provider you configure when self-hosting.
• You want the most mature, most widely deployed option. Laminar is younger than Langfuse or Phoenix; check that the integrations you need are listed.

The nearest alternatives are Langfuse (MIT, broader platform), Arize Phoenix (ELv2, free self-hosting, OpenInference), Traceloop (commercial, now part of ServiceNow) and AgentOps (MIT SDK).

Initialize once. Laminar.initialize() reads LMNR_PROJECT_API_KEY, sets up an OpenTelemetry tracer provider and auto-instruments every supported library it finds. The cloud endpoint is https://api.lmnr.ai with gRPC on port 8443 (the default) or HTTP on 443; a self-hosted backend listens on 8001 for gRPC and 8000 for HTTP. Restrict auto-instrumentation with instruments= or disabled_instruments=.

Add structure where auto-instrumentation stops. @observe() (Python) or observe() (TypeScript) turns your own functions into spans. Inside a span, Laminar.set_trace_session_id(), set_trace_user_id() and set_trace_metadata() attach a conversation ID, a user and key-value context to the whole trace. Set them at the entry point so every downstream span inherits them; a call made outside a span context has no trace to attach to.

Anything that speaks OTLP can send traces. Laminar's backend accepts OTLP over gRPC (recommended), HTTP with protobuf, and HTTP with JSON, with a Bearer project API key. For gRPC the key goes in metadata named authorization with a lowercase a; the OpenTelemetry Python gRPC exporter rejects a capitalized key. It reads gen_ai.* attributes plus its own lmnr.* ones, and estimates cost from provider and token counts when a span does not carry it.

Signals run a model over your traces. A Signal is a prompt plus a JSON schema. Triggers and filters decide which traces it reads, a backfill covers history, and every event's fields are queryable in SQL. On the cloud, Signals run on flow-1, Laminar's model trained for trace analysis, which the company says matches a frontier model on its own benchmark at a fraction of the cost.

Evals are code. An evaluation is datapoints (data, optional target), an executor that produces an output, evaluators that return numbers, and a group name that ties runs together. Each datapoint becomes a trace with an EVALUATION root span, an EXECUTOR child and one EVALUATOR child per score.

Storage is Postgres for metadata, ClickHouse for spans, and Quickwit for full-text search; the full deployment adds RabbitMQ for queued span processing and Valkey as a cache.