Laminar is an open-source observability platform designed specifically for AI agents, enabling developers to trace, evaluate, and monitor LLM-powered applications in real time. Built with Rust for high performance and developed by Y Combinator S24, it addresses the unique challenges of debugging and optimizing AI workflows that traditional observability tools can’t handle. It’s ideal for teams building complex agent systems using frameworks like LangChain, OpenAI, Anthropic, or Gemini who need visibility into prompts, responses, latency, and logical errors without vendor lock-in.
Whether you’re running lightweight local experiments or scaling production AI pipelines, Laminar provides a unified interface for tracing function calls, running evaluations in CI/CD, creating annotated datasets, and querying all your AI data with SQL. Its self-hostable architecture gives teams full control over their data while offering a managed cloud option for ease of use.
What You Get
- OpenTelemetry-native tracing - Automatically trace LLM calls from Vercel AI SDK, LangChain, OpenAI, Anthropic, Gemini, and more with a single line of code. No manual instrumentation needed for supported libraries.
- Unopinionated evals SDK and CLI - Run custom evaluations locally or in CI/CD pipelines with extensible evaluators. Visualize and compare results via the built-in UI to track model performance over time.
- Semantic event tracking - Define events using natural language (e.g., “user asked for financial advice”) to detect logical errors, edge cases, or unwanted behaviors in AI agents without writing complex code.
- Built-in SQL editor - Query traces, metrics, and events directly with SQL. Create datasets from queries for evaluation or analysis, all accessible via API for automation.
- Custom dashboards - Build visual dashboards using traces, metrics, and custom SQL queries to monitor key AI performance indicators like latency, error rates, or prompt effectiveness.
- Data annotation & dataset creation - Use the UI to manually annotate trace data (e.g., label incorrect responses) and export annotated datasets for training or evals, streamlining feedback loops.
- High-performance Rust backend - Engine built in Rust with real-time trace streaming, ultra-fast full-text search over span data, and gRPC export for scalable ingestion in production environments.
Common Use Cases
- Building a multi-tenant SaaS dashboard with LLMs - Teams track user prompts, response quality, and latency across tenants using semantic events and custom dashboards to ensure consistent SLAs.
- Creating a mobile-first e-commerce assistant with 10k+ SKUs - Engineers use Laminar to evaluate response accuracy against product catalogs and flag hallucinations using custom evals in CI/CD.
- Problem: LLM responses are inconsistent → Solution: Use semantic events to detect when agents give conflicting answers, then run evals on flagged traces to improve prompt engineering.
- DevOps teams managing AI agents across cloud providers - Self-host Laminar to centralize observability without relying on proprietary tools, using SQL queries to correlate traces with infrastructure metrics.
Under The Hood
The project is a full-stack observability and experimentation platform that integrates real-time analytics, A/B testing, and log tracing into a unified developer-centric system. It combines modern frontend frameworks with high-performance backend services, emphasizing extensibility and modular design.
Architecture
The system adopts a layered architecture with clear separation between UI, API, and data processing components.
- The codebase is structured using a modular approach with well-defined interfaces for communication between services
- Middleware and strategy patterns are applied to handle diverse data processing and query execution paths
- Component interactions are managed through standardized protocols, supporting decoupled frontend-backend integration
Tech Stack
The project leverages a modern tech stack with React and Rust, integrating cloud-native tools and services.
- The frontend is built with TypeScript and React using Next.js, while the backend is implemented in Rust for performance
- A rich ecosystem of libraries and tools is utilized, including Zustand, SWR, Recharts, D3, and Drizzle ORM
- Development workflows are supported by Turbopack, Tailwind CSS, Husky, and Sentry for enhanced developer experience
- Testing and linting practices are enforced through TypeScript-based utilities, ESLint, and Prettier
Code Quality
Code quality varies with strengths in testing and error handling, though some technical debt remains.
- The codebase includes comprehensive test coverage and consistent use of error handling mechanisms across modules
- Automated validation is enforced via linting, formatting, and CI/CD pipelines to maintain consistency
- Type safety is ensured through TypeScript usage, supporting robust development practices
What Makes It Unique
The platform distinguishes itself through its modular architecture and integration of multiple observability tools.
- A multi-layered design enables clean separation between telemetry ingestion, evaluation logic, and API handling
- Strong typing and gRPC integration provide cross-language compatibility and service consistency
- Extensive ecosystem support includes OpenTelemetry, ClickHouse, and Slack for seamless observability workflows
- Developer-focused features such as local development tools and flexible configuration options enable rapid iteration