Lilypad

Lilypad

Open-source OpenTelemetry observability for Python LLM apps

71/100Safe BetFreeFree

Lilypad is a solid choice for Python devs already running an OTel backend who want lightweight, open-source LLM tracing. The @ops.trace decorator and LLM auto-instrumentation do the heavy lifting, and it pairs naturally with Mirascope. But if you need a managed UI, prompt management, or experiment tracking, skip it and go with Langfuse or Helicone instead.

Verified 4d ago · liveness 71/100 · cite: rightaichoice.com/tools/lilypad

Best for
  • Python developers building LLM apps needing OTel-based observability
  • Teams already using an OTel backend who want to add LLM-specific tracing
  • Projects requiring vendor-neutral, open-source instrumentation without lock-in
  • Users of Mirascope framework wanting integrated tracing and versioning
Not ideal for
  • Teams wanting a fully managed, hosted observability platform with a UI
  • Non-Python stacks (Python-only library)
  • Projects needing advanced prompt versioning or experiment tracking
Visit Website

IntermediateFor a Python developer familiar with OpenTelemetry, you can have console tracing running in under 5 minutes. Adding a real backend like Jaeger typically takes 10-15 minutes if you use Docker. If you're using Mirascope already, integration is instant; otherwise, you may need an hour to understand the API. Most users achieve first value within the first hour, including backend setup.API · CLIAPI available6.0k viewsVerified 4d ago
Pricing
Free
FreeFree tier5 hidden costs
Learning curve
Intermediate
For a Python developer familiar with OpenTelemetry, you can have console tracing running in under 5 minutes. Adding a real backend like Jaeger typically takes 10-15 minutes if you use Docker. If you're using Mirascope already, integration is instant; otherwise, you may need an hour to understand the API. Most users achieve first value within the first hour, including backend setup.
Runs on
APICLI
API available · 10 integrations
Who it's for
Python developer building an LLM app with MirascopeML engineer at a startup using a cloud OTel backendTeam maintaining a microservices architecture for an LLM system
Live sentiment
Is Lilypad actually worth it?

We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.

  • Honest verdict, not marketing
  • Real pros & cons from real users
  • Attributed quotes with receipts
Run a free scan

3 free scans · no card needed

Skip it if

Skip Lilypad if you are not a Python developer, if you expect a hosted UI for your traces, or if you don't already have an OpenTelemetry backend you are willing to deploy and maintain yourself.

The 30-second take
Biggest gripe

Setting up an OTel backend (e.g., Jaeger, Grafana Tempo) can require infrastructure time and cost, especially at scale.

Price reality

Lilypad is free (MIT) and open-source, so it suits individual developers and startups that want robust observability without licensing costs. Compared to hosted tools like Langfuse, you save on per-seat fees but pay in infrastructure effort. For enterprises needing managed compliance, the hidden costs of self-hosting may outweigh the free license.

In short

Lilypad — Open-source OpenTelemetry observability for Python LLM apps. Best for Python developers building LLM apps needing OTel-based observability, Teams already using an OTel backend who want to add LLM-specific tracing, Projects requiring vendor-neutral, open-source instrumentation without lock-in. Free to use.

What people actually say about Lilypad — is it worth it?

We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.

49 mentions across 6 sources (Hacker News, YouTube, Product Hunt, App Store, GitHub, Lemmy) · researched Aug 23, 2026.

27% positive73% critical
Recurring strengths
  • +MIT-licensed, free, and truly open source — no vendor lock-in.
  • +Uses OpenTelemetry standard — export to Langfuse, Jaeger, Zipkin, Datadog, etc.
  • +Simple decorators for tracing, versioning, and sessions — low boilerplate.
  • +Auto-instrumentation of LLM calls saves time and ensures coverage.
  • +Context propagation across services enables full distributed tracing.
Recurring frustrations
  • No hosted UI — you must bring and maintain your own OTel backend.
  • Very few community posts, reviews, or real-world usage reports.
  • Only 213 GitHub stars and 31 open issues — a sign of limited adoption.
  • No documentation or tutorial feedback visible in community data.
  • No support SLA — open-source project, so support is community-driven.
Patterns worth knowing
No real community feedback exists — posts are about other products (Toy Story, iPad case, game server), so brand buzz is nil.
Seen on Hacker News, YouTube, Lemmy, App Store
Open-source, vendor-neutral tracing is praised in the tool description, but not yet proven in real-world use.
Seen on GitHub, Product Hunt
Lack of hosted UI and BYO-backend requirement is a barrier — users must manage their own infrastructure.
Seen on Tool description, GitHub
Learning curve
intermediateProductive in ~A few hours to set up with your existing OTel stack
Hidden costs people mention
  • No managed backend — you pay for and run your own OpenTelemetry collector or service (e.g., Jaeger, Langfuse cloud).
  • Time and expertise to integrate and maintain the tool.

Viability Score

71/100
Safe Bet

How well maintained and how widely used is Lilypad? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this

Recent activity
not measured
Traction
100
Site health
95
User sentiment
27
What the vendor publishes
40

Last calculated: September 2026

How we score →

Key Features

  • OpenTelemetry-based distributed tracing
  • @ops.trace decorator for automatic function tracing
  • @ops.version decorator for function versioning
  • ops.session() context manager to group traces
  • ops.span() for explicit span creation
  • Automatic LLM call instrumentation
  • Context propagation across services
  • OTLP protocol support
  • Console exporter for development debugging
  • Configurable tracer provider
  • Batch span processing
  • Custom span attributes and events
  • Python-first API with type hints
  • Mirascope ecosystem integration
  • Open-source (MIT license)

About Lilypad

FreeIntermediateAPI availableAPI · CLI

Lilypad is an open-source observability module for LLM applications, part of the Mirascope ecosystem. Built on OpenTelemetry, it gives Python developers distributed tracing, function versioning, and session management for production-grade LLM observability without vendor lock-in. Key features include the @ops.trace decorator for automatic function tracing, ops.session() to group related traces, @ops.version to track function versions, and auto-instrumentation of LLM calls. Traces can be exported to any OTel-compatible backend like Langfuse, Jaeger, Zipkin, Grafana Tempo, or Datadog. Unlike managed solutions such as Langfuse, Lilypad provides vendor-neutral instrumentation but requires you to bring your own OTel backend—no hosted UI is included. It integrates tightly with Mirascope and is designed for Python developers comfortable managing their own observability infrastructure.

Behind the Verdict

Lilypad stands out by being fully open-source and vendor-neutral. It builds directly on OpenTelemetry, so you can export traces to any backend—Langfuse, Jaeger, Zipkin, Grafana Tempo, or Datadog—without locking yourself into a proprietary platform. The @ops.trace decorator makes tracing as simple as adding a line of code, and automatic LLM instrumentation means you get visibility into your model calls without manual span creation. If you're using Mirascope, integration is seamless: @llm.call and @ops.trace work together naturally. The versioning feature via @ops.version is handy for tracking prompt and function changes. However, there's a catch: Lilypad is Python-only and requires you to deploy and maintain your own OTel backend. There's no hosted UI, no managed dashboard, no prompt management console—you have to bring your own observability stack. For solo developers or small teams already comfortable with OTel, this is a lightweight, cost-effective option. But if you want out-of-the-box visualizations, alerting, or team collaboration without infrastructure overhead, you're better off with a managed platform like Langfuse. Lilypad is best for those who value control and minimal dependencies over convenience.

Researching Lilypad? Get your full AI stack in 60 seconds.

Free, no signup — tell us your goal and get tools matched to your budget & existing stack.

Real-world workflow fit

Concrete scenarios for the personas Lilypad actually fits — and what changes day-one when you adopt it.

Python developer building an LLM app with Mirascope

You add @ops.trace and @ops.version to your functions and export traces to a local Jaeger instance.

Outcome: You get detailed span breakdowns for every LLM call, including latency and token usage, helping you spot bottlenecks.

ML engineer at a startup using a cloud OTel backend

You configure Lilypad to send traces to Grafana Cloud via OTLP and use ops.session() to group a user's multi-turn conversation.

Outcome: You can track end-to-end request flows and correlate traces to user sessions, simplifying debugging in production.

Team maintaining a microservices architecture for an LLM system

You use context propagation across services to trace a request that flows through a router, a retrieval service, and an LLM call.

Outcome: You gain a full picture of distributed execution, enabling you to identify which service adds the most latency.

Use Cases

  • Trace LLM function execution to debug and optimize responses.
  • Version control and iterate on LLM prompts collaboratively.
  • Group related LLM interactions into sessions for analysis.
  • Automatically instrument LLM calls for observability.
  • Propagate tracing context across distributed services.

Models Under the Hood

GPT-4o mini

as of 2026-08-30

Limitations

  • Lilypad is a Python-only, open-source tracing library.
  • It requires you to bring and manage your own OpenTelemetry backend—no hosted UI or managed infrastructure is included.
  • It focuses on tracing and versioning; it does not provide prompt management, evaluation, or experiment tracking.
  • It integrates best with the Mirascope framework, and while it can work independently, its feature set is intertwined with Mirascope's APIs.
  • If you need a turnkey solution, consider a managed alternative.

as of 2026-08-29

Verification history

We have re-verified Lilypad 17 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.

  1. re-checked, vendor evidence unchanged
  2. re-checked, vendor evidence unchanged
  3. re-checked, vendor evidence unchanged
  4. re-checked, vendor evidence unchanged
  5. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  6. re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it

Showing the 6 most recent of 17 verification passes.

Free to cite with attribution — this page re-verifies continuously.

12-month cost

Project the real annual outlay, including the implied monthly cost when only an annual tier is published.

Annual total
Free
Over 12 months
Effective monthly

Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.

Plans compared

For each published Lilypad tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.

Open Source

$0

Ideal for

Python developers and small teams who already have an OpenTelemetry backend and prefer a free, self-hosted tracing solution without lock-in.

What this tier adds

This is the only tier—free and open-source, with no hosted service.

Hidden costs & gotchas

What the public pricing page doesn't put in bold. Captured from pricing-page footnotes, contract terms, and recurring complaints.

  • Setting up an OTel backend (e.g., Jaeger, Grafana Tempo) can require infrastructure time and cost, especially at scale.
  • Running your own backend means you handle storage, retention, and scaling, which can accrue cloud costs as trace volume grows.
  • If you want a hosted dashboard or team collaboration, you'll need to pay for an external service like Langfuse, which adds subscription fees.
  • Debugging and maintaining your OTel pipeline can consume engineering time, especially if you need custom exporters or processing.
  • While the library itself is free (MIT), you must pin it to a compatible Mirascope version; upgrading Mirascope may require changes to your tracing setup.

Where the pricing makes sense

The company stage and team size where Lilypad's pricing actually pencils out — and where peers do it cheaper.

Lilypad is free (MIT) and open-source, so it suits individual developers and startups that want robust observability without licensing costs. Compared to hosted tools like Langfuse, you save on per-seat fees but pay in infrastructure effort. For enterprises needing managed compliance, the hidden costs of self-hosting may outweigh the free license.

Setup time & first value

How long it actually takes to get something useful out of Lilypad — broken out by persona, not the marketing-page minute.

For a Python developer familiar with OpenTelemetry, you can have console tracing running in under 5 minutes. Adding a real backend like Jaeger typically takes 10-15 minutes if you use Docker. If you're using Mirascope already, integration is instant; otherwise, you may need an hour to understand the API. Most users achieve first value within the first hour, including backend setup.

Switching to or from Lilypad

How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.

Migrating in
  • From custom logging: Wrap your LLM calls with @ops.trace to instantly get structured spans without changing your application flow.
  • From Langfuse SDK: Replace Langfuse's instrumentation with @ops.trace and export to your existing OTel endpoint, but you lose Langfuse's hosted UI.
  • From manual span creation: Switch to @ops.trace to eliminate boilerplate and ensure consistent attribute naming.
Migrating out
  • To Langfuse: Export traces using the Langfuse OTLP endpoint, and you can adopt their hosted dashboards without re-instrumenting.
  • To Datadog APM: Send OTel traces to Datadog's agent, then use Datadog's LLM Observability features for deeper analysis.
  • To Grafana Tempo: Point the OTLP exporter to Tempo and use Grafana dashboards for visualization.

Integrations

LangfuseJaegerZipkinGrafana TempoDatadogOpenTelemetry CollectorPrometheusGoogle Cloud TraceAzure MonitorAWS X-Ray

Resources & Guides

Tutorials & Learning

Tools that pair well with Lilypad

Common stack mates teams adopt alongside Lilypad, with the specific reason each pairing earns its keep.

Alternatives to Lilypad

View all
OpenLIT

OpenLIT

Open-source, OpenTelemetry-native LLM observability and AI engineering platform for teams.

FreemiumTry
Arize Phoenix

Arize Phoenix

Open-source LLM agent observability with tracing, evals, and experiments

FreemiumTry
Dash0

Dash0

OpenTelemetry-native observability with AI SRE Agent0 for automated production insight.

FreemiumTry

Frequently Asked Questions

Used Lilypad? Help shape our editorial sentiment research.