OpenLIT is a free, open source machine learning infrastructure project written in TypeScript and released under Apache-2.0. It has 2,770 GitHub stars, 388 forks and 60 open issues, and was last pushed 20 hours ago. On this registry it ranks #41 of 57 tracked projects in Machine Learning Infrastructure, with 5 head-to-head comparisons available. It gained 12 stars over the last 6 tracked days.

What is OpenLIT ?

OpenLIT is an open-source, OpenTelemetry-native observability and evaluation platform for AI applications, AI agents and coding agents, built for engineers who run LLM-backed systems and need to see what those systems actually did.

What it is

OpenLIT is a self-hostable observability and evaluation platform for AI applications, licensed under Apache-2.0 and written primarily in TypeScript, with instrumentation SDKs for Python and TypeScript. It lives in the AI and machine learning infrastructure ecosystem, alongside the model providers, frameworks and vector databases it instruments. Its premise is that an AI request is no longer a single LLM call: a production agent fans out into LLM calls, tool calls, retrieval, memory, sub-agent activity, prompts and code changes, and OpenLIT traces all of those stages through OpenTelemetry.

The concrete thing it replaces is the ad-hoc, per-provider visibility that teams otherwise stitch together from logs and bespoke dashboards when answering the "what did the agent actually do" question after a slow, expensive or wrong answer. OpenLIT answers it with traces and metrics covering tokens, cost, errors and evaluations, exported over OTLP to one dashboard. It also covers coding agents such as Claude Code, Cursor and Codex, capturing prompts, LLM calls, tool calls including file reads, file edits, shell commands and search, plus sub-agent activity, token usage, cost and code impact in a Coding Agents dashboard.

Key capabilities

  • Automatic instrumentation through openlit.init() in Python or the openlit package on npm, covering supported LLM providers, frameworks, vector databases and other AI infrastructure.
  • Standard OTLP export, configured with OTEL_EXPORTER_OTLP_ENDPOINT or the otlp_endpoint argument to openlit.init(), defaulting to http://127.0.0.1:4318.
  • Traces spanning LLM calls, tool invocations, prompts, retrieval, memory, sub-agents and agent steps, plus metrics for tokens, cost, errors and performance.
  • An evaluation stage in the workflow that produces cost, quality and error signals from traced agent activity.
  • Coding-agent instrumentation through the openlit CLI, with openlit coding install --vendor=cursor, --vendor=claude-code, --vendor=codex or --vendor=all.
  • openlit doctor for installation checks and openlit configure --endpoint for pointing the CLI at a collector.
  • A self-hosted dashboard on port 3000, with ClickHouse listed among the project's topics.

Who uses it and how

  • Platform and ML engineers running LLM-backed features in production, who need per-request traces of prompts, tool calls, tokens and cost when an agent misbehaves or spend spikes.
  • Teams adopting AI coding agents such as Cursor, Claude Code and Codex who want a session-level record of file reads, edits, shell commands, sub-agent activity and code impact.
  • Evaluation-minded teams that want cost, quality and error signals attached to the same traces rather than reconstructed afterwards.
  • Self-hosters comfortable running a Docker Compose stack and pointing applications at a local OTLP endpoint, keeping telemetry in infrastructure they control.

Getting started

The README quickstart clones the repository, runs docker compose up -d and opens the dashboard at http://127.0.0.1:3000; application instrumentation is pip install openlit or npm install openlit followed by openlit.init(). The coding-agent CLI installs from a provided shell script on macOS and Linux or a PowerShell script on Windows.

How it compares

No list of paid products this project replaces, and no comparable tools by name, appears in the facts provided here, so OpenLIT stands alone in this registry. The licence and operating model are nonetheless clear: Apache-2.0, self-hosted through Docker Compose, with telemetry stored in infrastructure the operator runs and no per-seat or usage cost stated.

When to use it — and when not to

A self-hoster takes on the Docker Compose stack, the OTLP collector endpoint and the ClickHouse-backed storage the topic list indicates; teams wanting a fully managed service with nothing to operate will not find one described here. Teams that cannot add SDK or CLI instrumentation to their applications and coding agents, or that need only basic log lines, get little from it. The project is active — last push September 2026, roughly 2,770 stars, 388 forks and 60 open issues — but the operational burden stays with the user, and the facts point to docs.openlit.io rather than a hosted option.

project readme (upstream, from github) — read inline
OpenLIT Logo

Open-source observability & evaluation for AI agents

Trace, evaluate, debug, and optimize AI applications and coding agents with OpenTelemetry.

⭐ Star     🚀 Quickstart     📚 Docs

Documentation License Downloads Slack X

Documentation · Quickstart · Examples · Join Slack


See what your AI agents are actually doing

AI applications are no longer just LLM calls.

A production agent can involve:

flowchart TD
    U([User]) --> A[AI Agent]
    A --> L[LLM calls]
    A --> T[Tool calls]
    A --> R[Retrieval]
    A --> M[Memory]
    A --> S[Sub-agents]
    A --> P[Prompts]
    A --> C[Code changes]
    L & T & R & M & S & P & C --> E{{Evaluation}}
    E --> O[["Cost / Quality / Errors"]]

    style U fill:#F97316,stroke:#7C2D12,color:#fff
    style A fill:#111827,stroke:#F97316,stroke-width:2px,color:#fff
    style E fill:#111827,stroke:#F97316,stroke-width:2px,color:#fff
    style O fill:#F97316,stroke:#7C2D12,color:#fff

OpenLIT gives you visibility across the entire workflow.

Trace every LLM call, tool invocation, prompt, agent step, token, cost, error, and evaluation — using OpenTelemetry.


⚡ Get started in 5 minutes

1. Start OpenLIT

git clone https://github.com/openlit/openlit.git
cd openlit

docker compose up -d

Open:

http://127.0.0.1:3000

2. Install the SDK

Python:

pip install openlit

TypeScript:

npm install openlit

3. Instrument your application

Python:

import openlit

openlit.init()

That's it.

OpenLIT automatically instruments supported LLM providers, frameworks, vector databases, and other AI infrastructure and exports OpenTelemetry traces and metrics.

4. Send telemetry

By default, configure the OTLP endpoint:

export OTEL_EXPORTER_OTLP_ENDPOINT="http://127.0.0.1:4318"

Or:

import openlit

openlit.init(
    otlp_endpoint="http://127.0.0.1:4318"
)

Open your dashboard and start exploring your AI application's traces, metrics, costs, and performance.


🤖 Observe Claude Code, Cursor & Codex

AI coding agents are powerful — but understanding what they actually did can be difficult.

OpenLIT gives you an OpenTelemetry-native view of coding-agent sessions.

Install the CLI:

macOS / Linux

curl -fsSL https://raw.githubusercontent.com/openlit/openlit/main/cli/scripts/install.sh | sh

Windows

iwr -useb https://raw.githubusercontent.com/openlit/openlit/main/cli/scripts/install.ps1 | iex

Configure OpenLIT:

openlit configure --endpoint http://127.0.0.1:4318

Install coding-agent instrumentation:

openlit coding install --vendor=all

Or install individual integrations:

openlit coding install --vendor=cursor
openlit coding install --vendor=claude-code
openlit coding install --vendor=codex

Check your installation:

openlit doctor

Now OpenLIT can capture:

flowchart LR
    S([Coding Agent Session]) --> P[User prompt]
    S --> L[LLM calls]
    S --> T[Tool calls]
    T --> T1[File reads]
    T --> T2[File edits]
    T --> T3[Shell commands]
    T --> T4[Search]
    S --> SA[Sub-agent activity]
    S --> TU[Token usage]
    S --> CO[Cost]
    S --> CI[Code impact]

    style S fill:#111827,stroke:#F97316,stroke-width:2px,color:#fff
    style T fill:#111827,stroke:#F97316,stroke-width:2px,color:#fff

Explore the resulting sessions in the Coding Agents dashboard.


🔍 What OpenLIT gives you

Traces

Understand exactly what happened during an AI request.

LLM calls Prompts & responses Tool calls Retrieval Embeddings Vector DB ops Agent steps Latency Token usage Errors

All represented using OpenTelemetry.


💰 AI cost observability

Track the cost of your AI applications across:

Models Providers Users Sessions Agents Environments

Support custom pricing for custom and fine-tuned models.


🧪 AI evaluations

Automatically evaluate LLM and agent outputs using LLM-as-a-Judge evaluations.

Built-in evaluation types include:

Hallucination Bias Toxicity Safety Instruction following Completeness Conciseness Sensitivity Relevance Coherence Faithfulness

Use evaluations to move from:

"The agent produced an answer."

to:

"The agent produced a good answer."


🐛 Debug production AI

Find the requests that matter.

Investigate:

Failed LLM calls Exceptions Latency spikes Unexpected costs Bad evaluations Problematic prompts Agent/tool failures

Go from:

Something went wrong.

to a fully traced root cause:

flowchart TD
    A[Agent] --> P[Prompt] --> L1[LLM] --> T[Tool call] --> R[Retrieval] --> L2[LLM] --> E([Error])

    style E fill:#DC2626,stroke:#7F1D1D,color:#fff
    sty

readme truncated — read the full docs on github

Frequently asked questions

Is OpenLIT free to use?

OpenLIT is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does OpenLIT do?

Monitor, debug, and scale LLM applications with ease

What is OpenLIT written in?

OpenLIT is primarily written in TypeScript. Its source is publicly available at https://github.com/openlit/openlit, and it has 2,770 GitHub stars.