Laminar - open-source observability for AI agents

TL;DR

TL;DR: Laminar is an open-source Rust-based observability platform that traces AI agent executions, runs evaluations in CI, and detects logical errors — self-hostable via Docker in one line.

Source and Accuracy Notes

⚠️ This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: laminar.sh — verified live
• Source repository: github.com/lmnr-ai/lmnr — MIT licensed, verified
• License: MIT (verified via GitHub API license.spdx_id)
• HN launch thread: news.ycombinator.com/item?id=41451698 — “Show HN: Laminar – Open-Source DataDog + PostHog for LLM Apps, Built in Rust”
• YC-backed: Y Combinator S24 (verified via README badge)

What Is Laminar?

Laminar is an open-source observability platform purpose-built for AI agents. Built in Rust, it claims high performance with a custom real-time engine for viewing traces as they happen and ultra-fast full-text search over span data.

The platform covers three pillars:

• Tracing — OpenTelemetry-native, one-line integration with Vercel AI SDK, Browser Use, Stagehand, LangChain, OpenAI, Anthropic, Gemini, and more.
• Evaluations — SDK and CLI for running evals locally or in CI/CD pipelines. Includes a UI for comparing results across runs.
• AI monitoring — Define events with natural language descriptions to track logical errors, custom agent behavior, and issues that structured logging misses.

Laminar also ships with a SQL editor for querying traces and metrics, a dashboard builder with custom SQL support, and a data annotation UI for creating eval datasets.

Setup Workflow

Step 1: Start with Docker (self-hosted)

The fastest path to a local instance is Docker Compose:

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

Access the UI at http://localhost:5667.

For production, use the full compose file:

docker compose -f docker-compose-full.yml up -d

Step 2: Install the SDK

npm add @lmnr-ai/lmnr

Step 3: Initialize tracing

# Generate a project API key at https://laminar.sh/projects
# Then initialize in your code:
import { laminar } from "@lmnr-ai/lmnr";

laminar.start({ apiKey: process.env.LAMINAR_API_KEY });

Step 4: Configure LLM provider (optional)

Laminar’s built-in AI features (chat-with-trace, SQL-with-AI) need an LLM provider. Add to your .env:

# Option A: OpenAI-compatible
LLM_PROVIDER=openai
LLM_API_KEY=sk-...

# Option B: Gemini
LLM_PROVIDER=gemini
LLM_API_KEY=...

Step 5: Run an eval

# Install the CLI
npm install -g @lmnr-ai/eval

# Run evaluations locally
lmnr-eval run --config ./evals.config.ts

Deeper Analysis

Positioning vs. alternatives

Laminar fills the gap between basic LLM logging (Langfuse, Agenta) and full-stack closed platforms (LangSmith, Braintrust, Phoenix). The Rust foundation is architecturally different — most competitors run Python stacks that can struggle at high trace volumes.

Key differentiators from the README:

• Custom realtime engine for live trace viewing
• gRPC exporter for high-throughput trace ingestion
• SQL-native data access (queryable via API)
• Self-hostable with full feature parity to the managed cloud
• HIPAA and SOC 2 Type II compliance documentation (for enterprise)

What runs locally

The Docker Compose setup spins up a complete stack including the UI, app server, and a PostgreSQL backend. The compose file also provisions the schema automatically.

Scope

Laminar is not a runtime guardrail tool — it does not intercept or block agent actions. It observes and records. For guardrails, pair it with something like Bunt or Harmon.

Practical Evaluation Checklist

• One-line SDK integration for popular frameworks: YES
• Docker Compose for local dev: YES
• No credit card required for self-hosted: YES (fully local)
• CI/CD eval runner: YES (CLI + SDK)
• SQL access to traces: YES (built-in editor)
• HIPAA/SOC 2 docs: YES (compliance landing page)
• OpenTelemetry-native: YES
• Real-time trace viewing: YES (custom Rust engine)
• Multi-model support (OpenAI, Anthropic, Gemini, etc.): YES

Security Notes

• Self-hosted deployments collect anonymized usage telemetry. Opt out with LAMINAR_TELEMETRY_DISABLED=true.
• API keys are project-scoped, not global.
• PII redaction at scale is documented at laminar.sh/docs/platform/pii-redaction.
• SOC 2 Type II and HIPAA compliance paths are documented for enterprise self-hosting.

FAQ

Q: Is Laminar free? A: Yes, the self-hosted version is fully open-source under the MIT license. The managed cloud has a free tier; paid plans start at laminar.sh/pricing.

Q: How does it compare to LangSmith? A: LangSmith is closed-source and tied to the LangChain ecosystem. Laminar is open-source, framework-agnostic, and self-hostable with a Rust-based backend that claims better performance at scale.

Q: Does it require a specific framework? A: No. While it has first-class integrations for Vercel AI SDK, LangChain, Browser Use, and others, the OpenTelemetry SDK works with any LLM call regardless of framework.

Q: What language is the SDK in? A: TypeScript/JavaScript via @lmnr-ai/lmnr. The backend is Rust.

Q: Can I self-host on a small VPS? A: The full docker-compose-full.yml is designed for production-scale deployment. The lightweight compose is suitable for local development. A minimal production self-host would need PostgreSQL, the app server, and the UI — comfortably on a 2 vCPU / 4 GB instance for low-to-medium traffic.

Conclusion

Laminar is a well-architected open-source observability platform for teams shipping AI agents in production. Its Rust backend, OpenTelemetry-native tracing, and built-in eval framework make it a credible self-hosted alternative to closed platforms — especially for teams with data residency requirements or HIPAA compliance needs.

If you are running AI agents in production and want visibility into what your agents are actually doing, Laminar’s one-line SDK integration and Docker-based self-hosting make it worth evaluating alongside LangSmith and Phoenix.