
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.

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
- Clone the OpenLIT repo and run
docker compose up -d, or connect your app to an existing OTLP endpoint. - Install the SDK with
pip install openlitfor Python ornpm install openlitfor TypeScript. - Add
openlit.init()at the top of your code so supported LLM providers, frameworks and vector databases get instrumented automatically. - 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.
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.
Related content
Explore related tools, skills, and articles for OpenLIT.
OpenLIT Alternatives
Base Code
Base44 (Wix) · Coding · ProductivityBase Code is a shared cloud development environment from Base44. Teammates describe changes to an existing GitHub codebase in chat, preview them live and send them back as pull requests.
Google EmbeddingGemma 2
Google DeepMind · Writing · Image · CodingGoogle EmbeddingGemma 2 is a 740M-parameter open model that turns text, code, images, audio, and video frames into vectors in one 768-dimension space, running on phones and laptops.
GitGlow
GitGlow · Coding · ProductivityGitGlow is a local-first desktop Git client that lets independent developers review their own code and their AI agents' changes in one place before shipping.
