When we start using Claude Code, Codex, OpenHands, or custom agents, we all discover the same problem: when something goes wrong, we don’t know exactly why.
We see the final result. We don’t see:
- what tools the agent called,
- how much each step cost,
- what context it used,
- how long each operation took,
- where the error appeared.
Laminar is an open source project that tries to solve exactly that. It’s an observability platform for agents and LLM-based applications that lets you log, visualize, and analyze complete AI executions.
And although the concept might sound enterprise-y, the reality is much simpler: if you’ve ever wondered “what exactly did my agent do to arrive at this response?”, Laminar is probably the tool you were looking for.
What problems does it solve?
Let’s say you have an agent that:
- receives a request,
- queries a vector database,
- calls OpenAI or Anthropic,
- executes tools,
- generates a response.
If the result is bad, you normally only see the final output.
Laminar lets you inspect:
- each model call,
- prompts and responses,
- token consumption,
- costs,
- tools used,
- latencies,
- relationships between subagents,
- complete execution traces.
In other words: it transforms a black box into something you can actually analyze.
Real-world use cases
1. Claude Code and development agents
If you’re using Claude Code or any coding agent, you probably want to answer questions like:
- What files did it inspect?
- What tools did it execute?
- How much time did it spend on each step?
- Where did the error occur?
Laminar logs the complete execution and lets you navigate it visually.
2. Multi-agent systems
Many teams already work with architectures made up of:
- Planner
- Researcher
- Coder
- Reviewer
When the final result is incorrect, figuring out which agent made the mistake can be tricky.
Laminar lets you visualize the complete interaction between agents within a single trace.
3. Cost control
One of the most practical features.
Laminar automatically captures:
- Input tokens
- Output tokens
- Model used
- Estimated costs
- Duration of each call
This makes it easy to quickly identify particularly expensive prompts or workflows.
If you’ve ever been surprised by an OpenAI or Anthropic bill, you already understand why this matters.
4. Tool debugging
Modern agents increasingly depend on external tools:
- APIs
- MCP Servers
- Databases
- Internal systems
When a tool returns unexpected data or throws an exception, Laminar lets you pinpoint exactly where the problem occurred and what information the agent received at that moment.
Self-hosted installation
The quickest way to get started is with Docker Compose.
git clone https://github.com/lmnr-ai/lmnr
cd lmnr
docker compose up -d
Once it starts, the interface is available at:
http://localhost:5667
For more complete deployments, the repository also includes production-oriented configurations.
TypeScript SDK installation
npm add @lmnr-ai/lmnr
Basic initialization:
import { Laminar } from "@lmnr-ai/lmnr";
Laminar.initialize({
projectApiKey: process.env.LMNR_PROJECT_API_KEY,
});
From that point on, traces will start recording automatically.
Python SDK installation
pip install "lmnr[all]"
Initialization:
from lmnr import Laminar
import os
Laminar.initialize(
project_api_key=os.environ["LMNR_PROJECT_API_KEY"]
)
For self-hosted installations:
Laminar.initialize(
project_api_key="<KEY>",
base_url="http://localhost",
http_port=8000,
grpc_port=8001,
)
Instrumenting your own functions
A particularly useful feature is the @observe decorator.
from lmnr import observe
@observe()
def process_request():
...
Each execution gets recorded as a span within the overall trace.
This lets you combine:
- model calls,
- tools,
- business logic,
- internal functions,
in a single visualization.
Available integrations
Laminar already offers integrations for:
- OpenAI
- Anthropic
- LangChain
- LangGraph
- AI SDK
- Browser Use
- Playwright
- Stagehand
- OpenHands
- Modern agent frameworks
So most teams can adopt it without major changes to their current stack.
The most interesting part
Years ago, observability was something we associated with:
- Kubernetes
- APIs
- Microservices
- Cloud infrastructure
Today a completely new category is emerging:
observability for agents.
And it makes sense.
Modern agents are no longer just a single call to a model. They execute tools, query external systems, coordinate subagents, and maintain context over extended periods.
As that complexity increases, so does the need to understand what’s happening internally.
Laminar is one of the most interesting open source projects appearing in this space because it doesn’t try to build another framework or another model.
Its sole purpose is to answer a question that we all end up asking sooner or later:
What exactly did my agent do to arrive at this result?
And when agents start working for hours, coordinating multiple tools, and consuming thousands of tokens per session, that answer can be far more valuable than any benchmark.