Skip to main content
New releases and improvements.

​
October 2026

  • Self-hosted Signals on the Laminar Cloud model - A self-hosted deployment can run its Signals on flow-1, the model Laminar Cloud Signals use. Add a Custom (OpenAI-compatible) LLM profile with base URL https://api.lmnr.ai/v1 and a project API key from a Pro workspace on Laminar Cloud, then pick that profile on your Signals. Traces, runs, and events stay on your deployment; only the Signal’s model requests go to Cloud, billed as Signals usage of the Cloud workspace. See Run self-hosted Signals on the Laminar Cloud model.
  • Usage warnings and hard limits - Workspace owners on paid plans can set email warnings and hard limits for data ingestion (GB) and Signals usage (USD) in Settings > Usage. Warnings email every owner once per billing cycle when total usage reaches a threshold, and hard limits reject new ingestion or Signal runs until the cycle resets or the limit changes. See Usage limits.
  • Harbor plugin - Run Harbor jobs with --plugin laminar and each job becomes a Laminar evaluation, each trial a datapoint scored with the verifier’s rewards, grouped by dataset so runs on Terminal-Bench and other datasets chart together. Every trial gets a trace with the setup, agent, and verifier phases, and the agent’s ATIF trajectory is replayed as LLM and tool spans with tokens and cost, subagents included. The plugin ships in the Python SDK (lmnr) and covers agents in any language, including TypeScript agents like Claude Code and Gemini CLI.
  • Google ADK instrumentation - Laminar.initialize() now auto-instruments Google ADK (Agent Development Kit) in Python. Each run shows up as an agent span with call_llm spans for model turns and a span per tool call with its arguments and return value, and the ADK session ID and user ID become Laminar’s session and user ID. When google-adk is installed, the Google Gen AI SDK instrumentation is left out by default so model turns are not traced twice. Ships in lmnr 0.7.62; google-adk 2.10 and later need lmnr 0.7.67 for prompt and response capture.
  • OpenAI Decisions API tracing - Laminar now traces OpenAI Decisions calls in TypeScript and Python. In TypeScript, experimental_decide from the Vercel AI SDK v7 is traced through LaminarAiSdkTelemetry (@lmnr-ai/lmnr 0.8.50). In Python, client.decisions.create in the OpenAI SDK is auto-instrumented, sync and async (lmnr 0.7.65, openai 3.26.0 or later). Every call becomes an LLM span with the input, the typed questions (choice, boolean or predicate, score), the answers with their probabilities, and token counts, so routing and guardrail decisions show up in the trace next to the LLM calls they gate.
  • Microsoft Agent Framework instrumentation - Laminar now traces Microsoft Agent Framework agents in Python as soon as agent-framework-core is installed. Agent runs, chat turns with prompts, responses, tool definitions, tokens, and cost, tool calls with arguments and results, sub-agents, workflows, and MCP tools land in one trace, with @observe spans and session IDs carried through. The provider SDK call under each chat span is no longer traced twice. Ships in lmnr 0.7.66.

​
September 2026

  • Terraform provider - Manage Signals and LLM profiles as code with the Laminar Terraform provider, lmnr-ai/lmnr on the Terraform Registry. Resources cover the Signal prompt, output schema, trigger, filters, sampling, and mode, plus profile credentials and models. Data sources look up existing Signals and profiles, and anything created in the UI can be imported. It works with Laminar Cloud, self-hosted deployments, and OpenTofu.
  • Responses API for custom LLM gateways - Custom LLM profiles can now use either OpenAI Chat Completions or the Responses API. Pick the API shape in the profile form and Laminar sends requests to /chat/completions or /responses on your gateway while keeping the same API key and custom headers.
  • AI SDK v7 metadata from runtimeContext - On Vercel AI SDK v7, attach metadata, a session ID, a user ID, and tags to a call by passing them in runtimeContext and opting each key in with telemetry.includeRuntimeContext. userId, sessionId, and tags map to Laminar’s user ID, session ID, and tags, every other key becomes trace metadata, and keys you don’t opt in never leave your app. See Attach metadata, sessions, user IDs, and tags. Ships in @lmnr-ai/lmnr 0.8.49.
  • Dual PII redaction mode - PII redaction is now a three-way setting under Project Settings → Security. On keeps redacting at ingest for everyone, and the new Dual mode stores the original span text once, with detected PII marked, and redacts it per reader: workspace owners and admins see the original, members see [REDACTED_<LABEL>] placeholders, and project API keys and CLI sessions always see the redacted version regardless of who created them, so a coding agent can work against a project without seeing sensitive data. Spans ingested before switching to Dual are hidden from restricted readers rather than shown unredacted. Available on Pro and Enterprise on Laminar Cloud; self-hosted from release 0.1.790 with the PII redactor service enabled.
  • TypeSafe AI Jev instrumentation - Laminar now auto-instruments the TypeSafe AI SDK in both TypeScript and Python, so every Jev System One call becomes an LLM span with the state, the typed questions (Noul, Choice, Score), the answers, and token counts. Routing, guardrail, and scoring decisions show up in the trace next to the LLM calls they gate. Python picks it up as soon as the typesafe-sdk package is installed; TypeScript needs Laminar.initialize({ instrumentModules: { typesafe: TypeSafeClient } }). Ships in lmnr 0.7.64 and @lmnr-ai/lmnr 0.8.48.
  • OpenRouter SDK instrumentation - Laminar now auto-instruments the OpenRouter SDK in both TypeScript and Python, not just OpenRouter traffic sent through the OpenAI SDK. chat.send, responses.send, and embeddings.generate become LLM spans with the model, messages, response, token counts, and cost, streaming included. Python picks it up as soon as the openrouter package is installed; TypeScript needs Laminar.initialize({ instrumentModules: { openrouter: OpenRouter } }) because @openrouter/sdk is an ES module.
  • Signal events and clusters on the traces table - traces now carries the Signal events that fired on a trace and the named clusters those events landed in, names and counts already resolved. ARRAY JOIN either column and signal data sits next to trace cost and duration, so which runs are in this failure cluster and what did they cost is one query instead of two joins. On the event side, signal_events gains leaf_clusters and cluster_details, which resolve cluster names and levels without a join, plus signal_version to tell events extracted under an older Signal definition from current ones. See SQL editor.
  • LLM profiles - Bring your own provider credentials. An LLM profile is a workspace-level entry holding a provider, its API keys, and the exact list of models you want to expose: OpenAI, Anthropic, Google Gemini, Groq, Mistral, AWS Bedrock, Azure AI Foundry, or any OpenAI-compatible gateway including a model you host yourself. The playground model picker is built from your profiles, and on self-hosted deployments each Signal runs on a profile and one of its models instead of the server’s LLM_PROVIDER environment configuration. Secrets are write-only and encrypted at rest, and Test connection checks every model in the profile before you save.
  • CLI: LLM profiles, Signal history, and dataset CRUD - lmnr-cli llm-profile list / get / create / update / delete provisions LLM profiles from your terminal, with per-provider credential flags and write-only secrets. On self-hosted deployments, signal create and signal update take --llm-profile-id with --model to run a Signal on one of those profiles, and signal versions <signal> prints a Signal’s definition history oldest first, so you can see what the judge was asked when an old event was extracted. dataset get, dataset update -n <name>, and dataset delete finish off dataset management. Ships in lmnr-cli 0.5.1.

​
August 2026

  • Flush span batches by payload size - Both SDKs can now export a batch when its payload would cross a byte limit, alongside the existing span-count and scheduled-delay triggers. Turn it on with Laminar.initialize({ flushBySize: true }) in TypeScript or Laminar.initialize(flush_by_size=True) in Python, and set maxExportBatchSizeBytes / max_export_batch_size_bytes if 32 MiB is not the right ceiling. Useful for agents whose spans carry whole conversation histories, where a few spans are enough to build an export the backend rejects. See Batching.
  • Manage Signals from the CLI - lmnr-cli signal create / list / get / update / delete puts the whole Signal definition in your terminal, so a prompt and output schema can live in your repo and ship from CI. A Signal’s firing configuration is three independent flags: --trigger picks when it is evaluated (root-span-finished or span-name), repeatable --filter decides whether it runs, and --mode selects batch or realtime processing. update is a partial patch, so changing one leaves the other two alone. See Signals CLI.

​
July 2026

  • Claude Code and Codex plugins - Trace Claude Code and OpenAI Codex CLI sessions in Laminar with a one-command install: npx lmnr-cli@latest plugin add claude-code (or codex) logs you in, picks a project, mints a key, and installs the plugin. Each turn becomes a trace with LLM calls, tool executions, and (for Claude Code) subagents, grouped into one session per conversation.
  • Generate render templates in the editor - The render template editor now generates the JSX for you: name the template, describe the view you want, click Generate, and iterate with Request changes. For trace templates, generation also writes the span filter from an outline of the trace’s real spans and refreshes the sample data against it. No more copying a prompt to an external AI tool, though the Copy prompt fallback remains in the Code tab.
  • Enable or disable Signals and alerts - Pause a Signal with the Active switch in its settings: new traces stop being evaluated while existing events and clusters are kept, and paused Signals are grouped under a Disabled section on the Signals list. Alerts get the same treatment, with an on/off switch directly on each alert card to silence notifications without losing the alert’s configuration.
  • Evaluations UI refresh - The evaluations page now has a groups sidebar with run counts, a combined progression chart with one line per score dimension (legend toggles, per-run eye icons to exclude runs), and an aggregation picker (Average, Sum, Min, Max, Median, p90/p95/p99). The run detail page is a split view with the datapoint table next to an always-open trace panel, and side-by-side comparison shows old → new deltas on the score card and on every row.
  • Trace render templates - Render templates can now render a whole trace, not just one span’s input or output. A SQL WHERE filter picks which spans the template receives, so one view can combine data across spans, like diffing an eval executor’s output against the evaluator’s target. Available from the view dropdown on any trace, next to Tree and Transcript.
  • Evals in the debugger - Run an evaluation with LMNR_DEBUG=true and it joins the current debug session automatically, rendered as a card with per-score averages and their change against the previous eval in the session. A session is now one timeline of runs, evals, and notes; lmnr-cli debug session add-note attaches markdown notes to it, and lmnr-cli debug session summary prints the whole timeline for a coding agent to re-orient from.

​
June 2026

  • Laminar Agent - Ask an AI agent about your project’s data in plain language and get answers grounded in real traces. The agent runs read-only SQL and reads trace context for you, and it runs in three places: the MCP server (ask_agent tool), the CLI (lmnr-cli ask), and Slack (mention @Laminar in a connected channel). See Laminar Agent.
  • Signal settings, backfill, and refreshed clusters - Every Signal now has a Settings tab with four sections: General (definition and triggers), Alerts, Backfill, and Activity. Run a Signal across historical traces from Backfill, watch each run’s status in Activity, and configure a Signal’s alerts in place, including output schema filters that fire only when an event’s extracted output matches. The clusters view is rebuilt as a two-panel cluster list and stacked frequency chart below the events table.
  • AI SDK v7 support - The Vercel AI SDK integration now covers AI SDK v7. Register Laminar once with registerTelemetry(new LaminarAiSdkTelemetry()) and every generateText / streamText call is traced, with no per-call configuration. The v5 and v6 experimental_telemetry + getTracer() style is still documented, and the page includes a step-by-step migration guide.
  • Debugger session continuation - Debug runs now group into a session automatically. The first LMNR_DEBUG=true run writes .lmnr/debug-session.json, and every later run in the same directory rejoins it with no LMNR_DEBUG_SESSION_ID to copy around. New lmnr-cli debug session new mints a clean session on demand, and session names are editable inline in the session view. See Debugger.
  • One-command CLI onboarding - lmnr-cli setup logs you in, picks or creates a project, writes a fresh LMNR_PROJECT_API_KEY to ./.env, links the directory, and installs the Laminar agent skill. lmnr-cli login adds OAuth device-flow auth so sql, dataset, and project run as the signed-in user against the directory-linked project (.lmnr/project.json), no project API key needed. See CLI.

​
May 2026

  • Table views - Save filters, search, sort, columns, and custom SQL columns as a named table view per project and per resource (traces, spans, sessions, evaluations, datasets, queues, debugger sessions, playgrounds, signal events). Views are shared across the project so a teammate can open the same dropdown and pick the same preset.
  • Render templates - Every input/output viewer now has a CUSTOM mode that renders the underlying value through a JSX template you write. Templates live per project, can be selected per pane (Laminar remembers your pick), and are managed from Project Settings → Render Templates. The template editor copies a Laminar-styled prompt to your clipboard so you can hand it to any AI tool with a sample payload and paste the result back. See Render templates.
  • Push metadata to finished traces - New client.traces.pushMetadata(traceId, metadata) (TypeScript) and client.traces.push_metadata(trace_id, metadata) (Python, sync and async) attach metadata to a trace that has already ended. Capture the trace id while the trace is running, store it alongside whatever produces the signal (a database row, a queue message, a session id), then push scores, reviewer notes, or edit counts back to the trace once you have them. See Metadata.
  • PII redaction - New project-level toggle in Settings → Security. When on, every span’s input and output is run through Laminar’s PII redactor before storage; names, emails, phone numbers, and other detected entities are replaced with labelled placeholders. Available on Pro and Enterprise plans, and as a self-hostable gRPC service. See PII redaction.
  • OTLP/HTTP+JSON ingest - /v1/traces now accepts JSON-encoded OTLP in addition to gRPC and HTTP+protobuf. Useful for browser SDKs and other runtimes without a protobuf encoder. See OpenTelemetry.

​
April 2026

  • Evaluations docs rewrite - Evaluations is restructured end to end. New Concepts page covers the datapoint / executor / evaluator / group model; new Compare runs page documents the progression chart and side-by-side diff; Datasets replaces the old using-dataset page; Self-hosted consolidates SDK config for self-hosted instances. Online evaluators are removed.
  • Transcript view docs - New Viewing traces page covers transcript view: auto-extracted agent inputs, LLM turns, tool-call previews, and collapsible subagent cards. Tree view is still one click away when you want raw span structure.
  • Alerts and reports overhaul — Alerts now support multi-severity filtering (Info, Warning, Critical), a skip similar events option, and a second trigger type for new clusters. Every new Signal ships with a critical-severity event alert and a cluster alert by default. Workspaces get weekday and weekly signal summary reports out of the box. Alerts and reports post to an in-app notification center; Slack and email are configurable per alert or report. See Alerts and Reports.
  • Claude Agent SDK integration refresh — Updated the Claude Agent SDK page with end-to-end setup for TypeScript and Python, a multi-subagent example, and real transcript and tree-view screenshots.
  • OpenAI Agents SDK integration — Laminar.initialize() now auto-instruments the OpenAI Agents SDK in Python. Agent workflows, turns, tool calls, and handoffs land in Laminar as nested spans with system instructions preserved on every LLM call.
  • Pydantic AI integration - Laminar.initialize() now auto-instruments Pydantic AI in Python when pydantic-ai-slim is importable. No Agent.instrument_all() call or manual OTLP exporter setup is needed; raw provider instrumentors (OpenAI, Anthropic, Google GenAI, Groq, Mistral, Cohere, Bedrock) are auto-removed to avoid duplicate spans on every model call.
  • Mastra integration — Native Mastra support via MastraExporter wired through Mastra’s Observability config. Captures every agent run, model step, tool call, and sub-agent. When a coordinator agent delegates to sub-agents exposed as tools, the sub-agent’s full run nests under the parent tool span in one unified trace.

​
February 2026

  • Signals (LLM outcomes) — Define outcomes and behaviors you care about, then backfill or run triggers on new traces; signal events link directly back to trace context.
  • Labeling queues — Push spans or dataset rows into queues, label in the UI, and write results back to datasets (UI or API).
  • MCP server for trace-aware assistants — Connect Claude Code, Cursor, or Codex to query Laminar with SQL and summarize trace context inside your IDE.
  • New integrations — OpenRouter via the OpenAI SDK and Pydantic AI via OpenTelemetry, with full trace capture.
  • Debugger (rollouts) polish — More reliable rollout entrypoints and sessions for rerunning long-running agents.
  • Schema references refreshed — SQL and SDK schema docs updated to match current tables and types.

​
January 2026

  • SQL Editor — Run read-only ClickHouse SQL across traces, signals, logs, datasets, and evals; export results to datasets or labeling queues.

​
December 17, 2025

  • Platform refresh — Backend and frontend upgrades for better compatibility, performance, and reliability.
  • Unified ingest for search + events — Spans and events share the same ingestion path, improving search consistency and error handling.
  • Query engine parity — Self-hosted query engine matches production behavior with stricter validation and more reliable SQL/JSON conversions.
  • Always-on trace aggregation — Trace summaries are consistently available without feature flags; new ClickHouse tables and backfill path.
  • UI cleanup + speedups — Removed unused components and trimmed dependencies to improve load times.
  • Events become searchable — Events flow into the search index for faster discovery and analysis.
  • Stability hardening — Realtime updates, schema migrations, and queueing made more robust.
  • LAM groundwork — Foundations for upcoming LAM features across the UI and data path.
  • Events + clustering simplified — Unified data model for event and cluster analysis.

​
November 2025

  • Distributed realtime — Fanout architecture for live updates across nodes.
  • Search + ingest overhaul — Quickwit-backed search aligned with ClickHouse for faster discovery.
  • Search UX — Filters and autocomplete for query inputs.
  • Auth separation — Clear split between authn and authz in backend middleware and roles.

​
October 2025

  • Security + UX — Next.js upgrade for a critical RSC CVE and a UI redesign sweep.
  • Schema & observability — Stronger trace aggregation controls, app-server metrics/logging, and event definitions + triggers + settings UI/API.

​
September 2025

  • Self-hosted query engine — Packaged with runtime/config improvements.
  • Sessions analytics — Sessions table and UI views added.

​
April–May 2025

  • Rust + performance — App-server upgraded to Rust 1.85 (2024 edition) with dependency cleanup.
  • Large-trace UX — Virtualized trace view for heavy traces.
  • Realtime sessions — Live updates for session views.

​
January 2025

  • Next.js 15 migration — Next15 rolled across the frontend stack.

​
Year in focus

  • Search & ingestion: Quickwit-backed search, unified span/event ingestion, events indexing, ClickHouse replacing table + migrations.
  • Realtime & sessions: Distributed realtime, session table, live session updates.
  • Querying: SQL Editor, query engine parity, self-hosting, stricter validation and conversions.
  • Signals & labeling: LLM signals with jobs/triggers and labeling queues that feed datasets.
  • Debugger & rollout: Rerun long agents from cached points with improved rollout sessions.
  • Integrations: OpenRouter (OpenAI SDK) and Pydantic AI (OTel) instrumentation.
  • Frontend UX: Redesign, virtualization for large traces, unused UI removal, CVE-driven upgrades, search autocomplete/filters.
  • Infra/observability: Rust toolchain upgrade, app-server observability, RabbitMQ hardening, schema fixes.