Laminar

Because “check the logs” stops working when your agent makes 200 LLM calls and you can’t tell which one broke it.

TL;DR

• What it is: Apache-2.0 licensed observability platform built specifically for AI agents — tracing, evals, AI monitoring, and raw SQL access over your agent data [1][2].
• Who it’s for: Developers and technical founders running production AI agents who need to understand what their agent actually did, step by step, and where it went wrong [2].
• Cost savings: LangSmith team plans run $39+/user/mo. Helicone Pro is $80/mo and Growth is $200+/mo. Laminar self-hosted runs on Docker Compose with no per-trace or per-seat pricing [1][4].
• Key strength: Rust backend with real-time trace viewing and ultra-fast full-text search over span data. One-line auto-instrumentation for every major AI framework. True agent debugger that lets you rerun from any step with context preserved [1][2].
• Key weakness: The Signals (AI monitoring) feature requires a Google Gemini API key in self-hosted mode — you can’t fully eliminate third-party LLM dependencies [1]. Cloud storage limits are tight for teams running browser agents.

---

What is Laminar

Laminar is an observability platform built for AI agents, not LLM apps generally. The distinction matters. Most observability tools in this space were designed for single-turn LLM calls: prompt in, response out, token count logged. Laminar was built from the start for multi-step, multi-tool, long-running agent workflows that break those assumptions [2][1].

The project came out of Y Combinator’s Summer 2024 batch and raised a $3M seed round [2]. It sits at 2,711 GitHub stars and is licensed Apache-2.0, which means you can self-host, fork, and use it commercially without a licensing conversation [1].

The architectural choice worth calling out: the core is written in Rust. That is not a marketing detail — it directly explains the “ultra-fast full-text search over span data” and “custom realtime engine for viewing traces as they happen” claims [1]. For anyone who has watched a Python-based observability backend grind to a halt under 50,000 spans, that is a real engineering differentiator.

The one-line integration story is accurate:

import { Laminar } from '@lmnr-ai/lmnr';
Laminar.initialize({ projectApiKey: process.env.LMNR_PROJECT_API_KEY });

After that, Laminar auto-instruments calls to OpenAI, Anthropic, Gemini, LangChain, Vercel AI SDK, Browser Use, Stagehand, and others [1]. You do not wrap each call — the SDK patches the libraries. The Python path is the same pattern: pip install 'lmnr[all]' plus a two-line init [1].

The GitHub description says “open-source observability platform purpose-built for AI agents.” Straightforward, accurate.

---

Why developers choose it

No independent third-party reviews of Laminar were available at time of writing — the project is young (YC S24). What follows is synthesized from primary sources.

The core value proposition addresses three pain points that anyone running agents in production will recognize.

“I don’t know why it failed.” The full trace view gives you context at every step — every tool call, every LLM response, every branch decision. The “True Agent Debugger” feature goes further: rerun from step N with previous context preserved, so you can reproduce a mid-agent failure without re-running the full workflow from scratch [2]. This is the feature that matters when an agent fails after 40 steps and you need to bisect without burning tokens.

“I know it’s failing but I don’t know the pattern.” The Signals feature lets you define monitoring conditions in natural language — “detect tool errors,” “flag when the agent gives up” — and Laminar extracts those signals from past and future traces automatically [2][1]. The homepage demo shows categorized events (tool_error, api_error, logic_error, timeout, validation_error) extracted across a timeline of traces. This is closer to semantic log alerting than numeric threshold monitoring.

“I need to query this stuff directly.” The built-in SQL editor lets you query traces, spans, metrics, and events with raw SQL, then bulk-create datasets from query results for use in evals [1][2]. This is not standard in LLM observability tools. Most give you filtered dashboards; Laminar gives you the table.

---

Features

Based on the GitHub README and official website [1][2]:

Tracing:

• OpenTelemetry-native SDK — auto-traces Vercel AI SDK, Browser Use, Stagehand, LangChain, OpenAI, Anthropic, Gemini in one initialization call [1]
• @observe() decorator (Python) / observe() wrapper (TypeScript) for custom function tracing [1]
• gRPC exporter for high-volume trace ingestion [1]
• Real-time trace viewer — see spans as the agent runs [1][2]
• Ultra-fast full-text search over span data [1]

True Agent Debugger:

• Rerun from any step N with context preserved [2]
• Tune system prompts and see changes reflected immediately [2]
• Run locally, debug in browser [2]

Browser Agent Session Replay:

• Screen recordings captured and synced automatically with agent traces [2]
• Integrates with Browser Use, Stagehand, Playwright, Kernel, Browserbase [2]

Signals / AI Monitoring:

• Define monitoring events in natural language [1][2]
• Runs retrospectively against past traces and prospectively on new ones [2]
• Requires GOOGLE_GENERATIVE_AI_API_KEY in self-hosted deployments [1]

SQL and Analysis:

• Built-in SQL editor for querying traces, metrics, and events [1][2]
• Bulk dataset creation from SQL query results [1]
• SQL API access for external tooling [1]

Evals:

• SDK and CLI for running evals locally or in CI/CD pipelines [1]
• UI for visualizing and comparing eval results across runs [1]

Data Annotation and Datasets:

• Custom data rendering UI for fast annotation [1]
• Dataset creation pipeline from traces through annotation to eval sets [1]

Dashboards:

• Custom dashboard builder with support for SQL queries in widgets [1][2]

---

Pricing: SaaS vs self-hosted math

Laminar Cloud [4]:

• Free: 1GB data storage, 15-day trace retention
• Hobby: $25/month, 2GB data, 30-day retention
• Pro: pricing not published in available sources

Self-hosted [1]:

• Software license: $0 (Apache-2.0)
• Infrastructure: Docker Compose on any Linux VPS
• Hetzner CX21: ~$6/mo; DigitalOcean basic Droplet: ~$12/mo
• Signals feature adds variable Google Gemini API costs based on trace volume

Competitor reference points:

LangSmith Developer plan: $39/mo. Team plans scale with seats — a team of three crosses $100+/mo quickly. LangSmith has a free tier capped at 5,000 traces/month, which is exhausted in hours by any browser agent that runs repeatedly.

Helicone: free up to 100K requests/month, Pro $80/mo, Growth $200+/mo. Usage-based at scale.

Arize Phoenix: open-source self-hostable tier available, but the managed platform is enterprise-priced.

Self-hosted math:

A three-person team on LangSmith Team tier spends roughly $120–180/mo depending on seat count. Self-hosted Laminar on a single $12/mo Droplet eliminates that entirely — no trace count limits, no seat pricing, unlimited eval runs. The only recurring cost is the Gemini API key if you use Signals, and that scales with volume rather than seat count [1].

The cloud free tier is a meaningful constraint. 1GB storage with 15-day retention will be consumed quickly by any team running browser agents with screen recording enabled. For evaluation or light development use it is fine; for production workloads, self-hosting is the right default [4].

---

Deployment reality check

The Docker Compose path is documented as [1]:

git clone https://github.com/lmnr-ai/lmnr
cd lmnr
docker compose up -d

UI is available at http://localhost:5667. The README is explicit that this is the lightweight quickstart stack. For production, it recommends either the managed cloud or the full compose file: docker compose -f docker-compose-full.yml up -d [1].

What you need:

• Linux VPS with 2–4GB RAM minimum; more if you run browser session replay at volume
• Docker and docker-compose installed
• A domain and reverse proxy (Caddy or nginx) for external HTTPS access
• A Google Gemini API key if you want the Signals feature — set in .env at repo root [1]

What can go sideways:

The Signals dependency is the main gotcha for anyone self-hosting to reduce third-party exposure. You are adding a Google API call into your trace analysis pipeline [1]. The README is transparent about this, but it means a fully air-gapped deployment is not possible if you want AI monitoring.

SDK configuration in self-hosted mode requires explicit baseUrl and port settings — it is not just an API key swap from the cloud version. The README sends you to docs.laminar.sh for the self-hosting guide [1]. This is a reasonable ask, but worth knowing before you assume the cloud SDK config translates directly.

Browser session replay introduces storage overhead that is hard to estimate without knowing your agent’s browser usage. Size your VPS storage conservatively.

Realistic setup time for a developer comfortable with Docker Compose: 20–40 minutes to a working local instance. With domain, proxy, and SSL: add another 30–60 minutes. For someone new to Linux server management: budget a full afternoon.

---

Pros and Cons

Pros

• Apache-2.0 license. Self-host, fork, embed in your product, use in client work — no commercial restrictions [1]. Contrast with LangSmith (proprietary SaaS) and Helicone (proprietary managed).
• Rust backend. Real-time trace viewing and full-text span search that will not buckle under production trace volumes [1]. This is an engineering commitment, not a performance marketing claim.
• One-line auto-instrumentation. Covers every major AI framework without wrapping individual calls [1].
• True agent debugger with step rerun. Rerunning from step N with context preserved makes debugging long-running agents tractable without burning tokens on re-execution [2].
• SQL editor over raw trace data. Query your agent data like a database, not just through preset filters and dashboards [1][2].
• Browser session replay synchronized with traces. Niche but essential for browser automation debugging — you see the screen alongside the span tree [2].
• No per-trace or per-seat pricing on self-hosted. Run unlimited agents without a usage meter [1].
• YC S24, $3M seed. Recent but real — has funding runway and team accountability [2].

Cons

• Signals requires Google Gemini API. AI monitoring has an external dependency in self-hosted mode. Cannot fully isolate from third-party services [1].
• 2,711 stars is modest. Langfuse sits at 30K+, LangSmith has a massive install base. Fewer tutorials, fewer community answers, smaller ecosystem [merged profile].
• Cloud storage limits are tight. 1GB (free) and 2GB (Hobby at $25/mo) will be exhausted quickly for browser agents with session replay [4]. Pro pricing is unpublished.
• Self-hosted SDK configuration requires explicit setup. Not a simple API key swap from the cloud version — ports and baseUrl must be configured [1].
• No third-party reviews available. The project is too new for independent community experience to exist. You are an early adopter.
• Non-technical founder unfriendly. There is no “connect your API key in a web UI and go” path. This is a developer tool from setup through daily use.

---

Who should use this / who shouldn’t

Use Laminar if:

• You are building multi-step AI agents and need to see exactly what the agent did, step by step, when it fails.
• You are paying for LangSmith team seats or scaling past Helicone’s free tier and want to eliminate those costs.
• You use Vercel AI SDK, LangChain, Browser Use, Stagehand, or any major Anthropic/OpenAI SDK and want automatic instrumentation without wrapping every call.
• You need SQL access to your raw trace data, not just dashboard-level aggregation.
• You want Apache-2.0 licensing with no commercial restrictions on self-hosted deployments.
• You are comfortable with Docker Compose and can configure a reverse proxy.

Skip it if:

• You are not building agents — you call an LLM once per user request. Simpler tools (Helicone, basic logging, a $5/mo LangSmith free tier) will do. Laminar’s feature surface is overkill.
• You are a non-technical founder with no developer on the team. Setup and daily use both require engineering competence.
• You need a fully air-gapped self-hosted deployment with no external API dependencies. Signals breaks that requirement [1].
• You need battle-tested, years-of-community-support observability. At 2,711 stars and YC S24 vintage, you are taking an early-adopter position.

---

Alternatives worth considering

Langfuse — the closest direct competitor. Open-source, Apache-2.0, self-hostable, 30K+ GitHub stars. Similar feature set: tracing, evals, datasets, dashboards. More mature, larger community, more tutorials. Does not have the Rust performance story, the step-rerun debugger, or native browser session replay. Evaluate this in parallel with Laminar before choosing.

LangSmith (by LangChain) — the dominant managed LLM observability platform. Proprietary SaaS, per-seat pricing for teams, no self-hosting at useful scale. Best if you are already deep in the LangChain ecosystem and want the most battle-tested option with the largest community.

Helicone — proxy-based instrumentation, simple setup, SaaS-only at scale. Good for teams that want observability without self-hosting and do not need the agent debugger features. Gets expensive above the free tier.

Arize Phoenix — open-source, Python-native, ML-ops oriented. Better fit for teams already using Arize for model monitoring. Less focused on agent workflow debugging specifically.

Traceloop — OpenTelemetry-native SDK, connects to any observability backend. More composable for teams with an existing observability stack, less opinionated end-to-end.

The practical shortlist for a developer building production agents is Laminar vs Langfuse. Langfuse has more community and documentation. Laminar has Rust performance, native session replay, and the step-rerun debugger. If you run browser agents or need real-time high-volume trace viewing, Laminar’s architecture gives you something Langfuse does not currently offer.

---

Bottom line

Laminar is built for a specific, real problem: you shipped an AI agent, it fails in ways you cannot explain, and you need to see exactly what it did. The Rust backend, one-line instrumentation, step-rerun debugger, and SQL access over trace data are genuine engineering decisions, not dashboard polish. The Apache-2.0 license and Docker Compose deployment mean you can self-host with no per-trace costs and no vendor dependency for the core features. The trade-offs — modest community size, Google API dependency for Signals, tight cloud storage limits — are the predictable costs of a YC S24 project rather than an established platform. For any developer already paying for LangSmith seats or scaling past Helicone’s limits, it is worth spinning up a test instance before renewing.

---

Sources

1. Laminar GitHub README — Technical features, quickstart, SDK documentation, self-hosting instructions, architecture details. https://github.com/lmnr-ai/lmnr
2. Laminar official website — Product homepage, feature descriptions, debugger, session replay, Signals, dashboard documentation. https://laminar.sh
3. Laminar documentation — Full self-hosting guide, SDK reference, tracing and evals documentation. https://docs.laminar.sh
4. Laminar pricing page — Free, Hobby, and Pro tier details (accessed via website navigation). https://laminar.sh/pricing
5. Y Combinator company listing — S24 batch, $3M seed confirmation. https://www.ycombinator.com/companies/laminar-ai