OpenLIT

OpenLIT

OpenLIT · Coding

OpenLIT is an open-source, OpenTelemetry-native platform for LLM observability, evals and guardrails, so you can trace, score and fix AI agent behavior.

Interface preview of OpenLIT

About OpenLIT

What Is OpenLIT

OpenLIT runs the observability layer for AI applications. You point your app at it, and every model call, tool call, retrieval and agent step shows up as a trace you can read. The platform handles tracing, evaluations, guardrails, prompt management and cost tracking from one place.

The pitch is portability. OpenLIT writes standard OpenTelemetry data, so you can keep it in the built-in dashboard or ship the same traces to Grafana, Datadog or any OTLP backend. Nothing locks your telemetry into a vendor format, and you can self-host the whole stack under Apache 2.0.

The catch is that OpenLIT is a developer tool. Getting value out of it means wiring up an SDK or a collector, and you'll need to run your own storage for production volumes. If you want a finished app with no setup, this isn't it.

Getting Started

  1. Clone the OpenLIT repo and run docker compose up -d, or connect your app to an existing OTLP endpoint.
  2. Install the SDK with pip install openlit for Python or npm install openlit for TypeScript.
  3. Add openlit.init() at the top of your code so supported LLM providers, frameworks and vector databases get instrumented automatically.
  4. Open the dashboard and read your first traces, then set up evals, prompts or guardrails as the app grows.

Product Information

A quick look at OpenLIT's pricing, supported platforms, and performance.

Free PlanYes
Paid PlansSelf-hosted free (Apache 2.0)
PlatformWeb, Self-hosted, Docker, Kubernetes
DeveloperOpenLIT
CategoryCoding
Release DateJan 2024
Latest UpdatedMay 2025
Website Visits7.2K
Website Global Rank2.8M
API AvailabilityYes

Best for

The users, tasks, and scenarios where this tool fits best.

Users

  • Developers building LLM apps
  • AI platform and SRE teams
  • Teams migrating off a closed observability tool

Tasks

  • Debugging a failing agent run
  • Cutting model spend
  • Comparing prompts before shipping
  • Blocking prompt injection at runtime

Scenarios

  • Shipping a RAG chatbot to production
  • Running coding agents in CI
  • Watching GPU cost during training or inference

Key features

OpenTelemetry-native tracing

OpenLIT records every LLM call, tool call, MCP request, retrieval and agent step as a standard OpenTelemetry trace. You can filter by user, session, cost or latency, and you can send the same data to Grafana, Datadog or any OTLP endpoint instead of keeping it in OpenLIT alone. That portability is the main reason teams pick it over a closed tool.

Automatic instrumentation and zero-code options

Adding openlit.init() is enough to instrument supported providers, frameworks and vector databases, and the list runs past 50 integrations including OpenAI, LangChain, CrewAI and ChromaDB. For coding agents like Claude Code, Codex and Cursor, a CLI installs instrumentation without touching your source.

LLM evals with LLM-as-a-judge

OpenLIT scores outputs for hallucination, bias, toxicity, relevance, completeness and instruction following. You can run these checks on live traffic or on an experiment, and gate a CI pipeline on the results, so a quality drop blocks a release instead of reaching users first.

Prompt Hub with versioning

Prompt Hub stores prompts in one place, versions them with Major, Minor and Patch tags, and swaps in {{variable}} values at runtime. You can deploy or roll back a prompt without shipping new app code, which keeps copy changes out of the release cycle.

Runtime guardrails

Guardrails inspect requests as they arrive and act on prompt injection, sensitive topics and topic restrictions. You set the rules, and OpenLIT enforces them on the request path, which gives you a safety layer that doesn't depend on the model behaving.

Cost, latency and GPU monitoring

The platform handles cost tracking and latency across models, providers, users, sessions and agents, and supports custom pricing for fine-tuned models. A separate GPU collector pulls utilization, memory, temperature and power from NVIDIA, AMD and Intel hardware, so cost and hardware pressure sit in the same dashboard.

Pros and cons

Pros

  • OpenTelemetry-native, so traces stay portable and you avoid a proprietary format
  • Free to self-host under Apache 2.0, with no license key and full data ownership
  • One-line setup for supported providers, plus zero-code options for coding agents
  • Combines observability, evals, guardrails, prompts and GPU monitoring in a single platform
  • ClickHouse-backed storage holds up to high-volume LLM and agent telemetry

Cons

  • It's built for developers: non-technical users will find the setup and concepts out of reach
  • Self-hosting for real production traffic means running your own ClickHouse and keeping it healthy
  • The feature set is broad, so the onboarding docs take time to work through before you're productive
  • Unlike a hosted SaaS, you're responsible for upgrades, scaling and backups

Frequently asked questions

OpenLIT is an open-source platform that traces, evaluates and guards AI agents and LLM apps. It captures model calls, tool calls and retrievals as OpenTelemetry traces, then layers evals, guardrails and prompt management on top.