Laminar Review (2026)

What Laminar actually is

Laminar is an open-source, OpenTelemetry-native observability and eval platform built specifically for AI agents. It traces every LLM call, tool call and sub-agent, and it’s written in Rust for low overhead. On top of tracing it adds evals, datasets built from production traces, a time-travel-style debugger that records a run and replays it from cache, and a feature called Signals.

The category framing: this is a tracing-and-eval tool, not a gateway and not a closed enterprise platform. Its two real distinguishing bets are performance (Rust) and a deep focus on browser agents and other long-running agents. If you’re building an agent that clicks around a browser, or a multi-step agent where you need to see the whole execution tree, Laminar is aimed at you.

It’s the newest company in this set. Laminar was founded in 2024 by Robert Kim, Din Mailibay and Temirlan Myrzakhmetov, went through Y Combinator’s S24 batch, and raised a $3M seed. The credibility signal that stands out: OpenTelemetry co-creator Ben Sigelman is an angel investor, and Supabase’s CTO Ant Wilson is on the cap table too. For an OTel-native tool, having OTel’s co-creator backing it is not nothing.

The distinctive part: self-host the whole thing, plus browser agents

Two things make Laminar stand out.

First, it’s the only platform in this set you can self-host in full. Not a gateway, not a hobbled core - the whole stack is open source and documented for self-hosting. Maxim and Galileo gate self-host to Enterprise. Portkey open-sources only the gateway, not its observability. Laminar open-sources everything. If data residency is your top constraint, this is the shortlist of one alongside Langfuse.

Second, browser-agent observability. Laminar auto-captures browser session recordings synced with agent execution steps on a shared timeline. Browser Use, one of the most popular open-source browser agents, documents Laminar as its observability integration. One line - Laminar.initialize() at the top of your project - and it auto-captures traces, and for browser agents both the agent steps and the browser session recordings together. There’s first-class instrumentation for Vercel AI SDK, the Claude Agent SDK, LangChain, Stagehand, OpenAI, Anthropic and Gemini. LlamaIndex isn’t explicitly listed in the sources we checked.

The gotcha: a billing unit you can’t easily forecast

Here’s the thing to understand before you sign up. Laminar bills on two axes, and one of them is weird.

Tier	Price	Data	Signals	Retention
Free	$0	1 GB	$5	7 days
Starter	$30/mo	3 GB, then $2/GB	$15, then usage-based	30 days
Pro	$150/mo	10 GB, then $1.50/GB	$50, then usage-based	6 months
Enterprise	Custom	custom	custom	-

Data by the GB is normal. Signals are not. Signals are billed by the tokens spent reading your traces - not the tokens your agent spends. Signals is the feature where you describe an outcome or failure in plain language and Laminar extracts structured events across your traces. That extraction costs tokens, and those tokens are the meter. Laminar says it compresses traces to roughly 10% of their original size to keep the cost down.

The practical effect: your bill depends on how much you interrogate your own data and on a vendor compression claim, which makes a monthly forecast genuinely hard. It’s the least predictable pricing model in this category. The escape hatch is self-hosting, which removes the usage billing entirely and leaves you paying only for infrastructure and ops time.

Self-hosting: what you actually get

You can run the whole platform yourself, and that’s the strongest self-host story here after Langfuse. The honest caveat: the exact feature delta between self-host and cloud isn’t clearly enumerated in the docs we reviewed. Managed retention tiers and Signals billing are cloud constructs, so self-hosting clearly removes the usage bill, but whether every cloud feature is present in the self-hosted build is unverified. Confirm the specifics for your must-have features before you commit a production stack to it.

Laminar versus Langfuse

Both are open-source and self-hostable, so the comparison is about focus and maturity. Langfuse is the broader, more mature, more battle-tested default - four services to run, but a huge install base. Laminar is younger, Rust-based, OTel-native from day one, and sharper on browser agents and long-running agents. If you want the safe open-source default, Langfuse. If your workload is specifically browser agents or you value the OTel-native, Rust-performance angle and don’t mind the maturity gap, Laminar is the more targeted pick.

Should you use it?

Use Laminar if you’re building AI agents - especially browser agents - want OpenTelemetry-native tracing you can self-host completely, and you either self-host to sidestep the billing puzzle or you’re fine modelling the Signals meter.

Don’t use Laminar if you need a mature, high-install-base platform for a conservative multi-year bet, or you want pricing you can forecast to the dollar on the managed tier.

Bottom line: the most self-hostable and arguably the best browser-agent observability tool in this set, with real technical credibility behind it. The reservations are maturity and a hard-to-forecast bill - and self-hosting happens to answer the second one, if you’re willing to run the infrastructure.

---

Pricing and features verified against laminar.sh on 23 July 2026. This category ships breaking changes monthly - we re-verify every 30 days.