Lilypad

Lilypad

Open-source OpenTelemetry tracing, versioning, and sessions for Python LLM apps—bring your own backend.

71/100Safe BetFreeFree

Pick Lilypad if you're a Python team already running an OpenTelemetry backend and want LLM tracing without another SaaS contract. The @ops.trace decorator plus automatic LLM instrumentation covers most of the work, and ops.session() and @ops.version add grouping and version tracking that a bare OTel SDK won't give you. If you want a hosted UI, prompt management, or experiment tracking on day one, choose Langfuse or Helicone instead—Lilypad gives you the instrumentation, not the dashboard. Note the install is "mirascope[otel]" and the work is on you to stand up the exporter and backend.

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

Best for
  • Python developers building LLM apps who already run an OTel backend
  • Teams standardizing on OpenTelemetry and avoiding vendor lock-in
  • Mirascope users who want tracing bundled with the framework
  • Platform teams with existing observability infrastructure
Not ideal for
  • Non-Python stacks, since this is a Python library
  • Teams wanting a fully managed observability product with a hosted UI
  • Projects needing built-in prompt management or experiment tracking
Visit Website

IntermediateFor a Python dev who already has a TracerProvider, it's minutes: pip install "mirascope[otel]", call ops.configure() with the provider, and add @ops.trace to the functions you care about. For a team that still needs to stand up an OTel collector and choose a backend, budget hours to days depending on the backend—that infrastructure work is the real setup cost, not the library.APIAPI available6.0k viewsVerified 18d ago
Pricing
Free
FreeFree tier2 hidden costs
Learning curve
Intermediate
For a Python dev who already has a TracerProvider, it's minutes: pip install "mirascope[otel]", call ops.configure() with the provider, and add @ops.trace to the functions you care about. For a team that still needs to stand up an OTel collector and choose a backend, budget hours to days depending on the backend—that infrastructure work is the real setup cost, not the library.
Runs on
API
API available · 5 integrations
Who it's for
Backend Python developer with an existing OTel stackMirascope user iterating on a promptDeveloper debugging locally before deploying
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 want an observability platform that hosts traces, shows you a UI, and manages prompts for you—Lilypad is an MIT-licensed Python instrumentation library and you bring and run the OpenTelemetry backend yourself.

The 30-second take
Biggest gripe

There's no license fee, but you pay for the OpenTelemetry backend you export to—hosting, storage, and retention for Jaeger, Tempo, Datadog, or similar land on your own bill.

Price reality

Lilypad itself is free under the MIT license, so the cost comparison isn't tier-versus-tier—it's infrastructure you already pay for versus adding a managed observability subscription. Teams already running OTel get LLM tracing at effectively zero incremental license cost; teams comparing against hosted options like Langfuse or Helicone should budget the backend and the ops time instead of a per-seat fee.

In short

Lilypad — Open-source OpenTelemetry tracing, versioning, and sessions for Python LLM apps—bring your own backend. Best for Python developers building LLM apps who already run an OTel backend, Teams standardizing on OpenTelemetry and avoiding vendor lock-in, Mirascope users who want tracing bundled with the framework. Free to use.

No head-to-head comparison for Lilypad yet — the alternatives below are the closest matches we list.

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

Average across the 6 sources that answered — each source counts once, not each post.

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: October 2026

How we score →

Key Features

  • Distributed tracing with the @ops.trace decorator
  • Session grouping via ops.session()
  • Explicit span creation with ops.span()
  • Function versioning with the @ops.version decorator
  • Automatic instrumentation of LLM calls
  • Context propagation across distributed services
  • Built on OpenTelemetry for backend neutrality
  • Export to any OTLP-compatible backend
  • Console span exporter for local development
  • Configurable TracerProvider via ops.configure()
  • Python-first API with type hints
  • MIT-licensed and installable from PyPI as mirascope[otel]
  • Mirascope framework integration
  • Works alongside the @llm.call decorator in the same function

About Lilypad

FreeIntermediateAPI availableAPI

Lilypad is the mirascope.ops module: an MIT-licensed observability library for Python LLM applications, built on OpenTelemetry. Install it with "pip install mirascope[otel]" and you get distributed tracing via the @ops.trace decorator, session grouping with ops.session(), explicit spans through ops.span(), function versioning with @ops.version, automatic instrumentation of LLM calls, and context propagation across services. Because it speaks OTel, traces can be exported to any compatible backend—Langfuse, Jaeger, Zipkin, Grafana Tempo, Datadog, and more—so instrumentation stays vendor-neutral instead of tied to one closed platform. It is a library, not a hosted product: there is no Lilypad UI or managed cloud, you configure a TracerProvider and point spans at the backend you already run. That makes it a good fit for Python developers and teams already operating an OTel stack who want LLM-specific tracing without lock-in, and a poor fit for anyone who wants a ready-made dashboard, prompt management, or experiment tracking out of the box.

Behind the Verdict

Lilypad sits in an unusual spot: it is the observability half of the Mirascope ecosystem rather than a standalone company product, and that shapes both its strengths and its limits. On the strength side, the design is disciplined. Everything runs through OpenTelemetry, so the question of "which backend?" never gets answered by Lilypad—it gets answered by you. Traces from an @ops.trace-decorated function can land in Langfuse, Jaeger, Zipkin, Grafana Tempo, or Datadog by swapping the TracerProvider configuration, and for development you can attach a ConsoleSpanExporter and read spans straight from stdout, as the quick-start shows. The decorator surface is small and composable: @ops.trace for function-level tracing, ops.session() to group related traces, ops.span() for explicit spans where you want finer control, @ops.version to tag function versions, and instrumentation that captures LLM calls automatically. Context propagation handles the distributed case where a request crosses services and you still want one coherent trace. Because it's MIT-licensed and installs from PyPI as mirascope[otel] (the docs show v2.4.0), there is no seat count, no usage meter, and no vendor that can change its pricing terms on you. The weaknesses are the mirror image. There is no hosted UI, no prompt management layer, and no experiment tracking in what's documented here—if you need to compare two prompts head-to-head or let a non-engineer browse traces, this library alone won't do it. You also pay for the vendor-neutrality in operational cost: someone on your team has to run and maintain the OTel collector and whatever backend you choose, handle retention and sampling, and secure access. For a solo developer or a small team without DevOps capacity, that overhead can outweigh the freedom. The documentation itself is a docs-site module page rather than a marketing site—the /pricing, /changelog, /release-notes, and /docs paths all return "The page you are looking for does not exist,"—so the observable surface for evaluating it is the Ops overview plus the guides under /docs/ops. Integration coverage with specific backends is documented in the Configuration guide rather than on a separate marketplace page, which we did not reach this run. Where it fits: Python codebases that already emit OTel, teams that have standardized on a backend and don't want a second observability silo for LLM traffic, and Mirascope users who want tracing to come along with the framework. Where it doesn't: non-Python stacks, teams shopping for a finished observability dashboard, and anyone expecting Lilypad to host, store, or visualize their traces. Treat it as a well-built instrumentation library with a deliberate scope boundary, not as a platform—and judge it on whether that boundary matches where your stack already lives.

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.

Backend Python developer with an existing OTel stack

Install mirascope[otel], call ops.configure() with the team's existing TracerProvider, and decorate the LLM call path with @ops.trace while keeping the @llm.call decorator in place.

Outcome: Model calls show up in the backend the team already monitors, with no new vendor, no new dashboard to learn, and no instrumentation lock-in.

Mirascope user iterating on a prompt

Wrap the function with @ops.version while tuning the prompt, and use ops.session() to keep a multi-turn run grouped together.

Outcome: Version tags make it possible to tell which prompt revision produced a given trace, and sessions keep related turns from scattering across the trace list.

Developer debugging locally before deploying

Attach a ConsoleSpanExporter through SimpleSpanProcessor and run the function with @ops.trace to print spans to the terminal.

Outcome: Span structure and timing are visible during development without standing up a backend first.

Use Cases

  • Trace a Python LLM function end to end with @ops.trace to see latency and call structure.
  • Group a multi-turn conversation into one ops.session() for later analysis.
  • Tag and compare function versions with @ops.version while iterating on a prompt.
  • Instrument LLM calls automatically instead of hand-writing span code around every request.
  • Export traces to an existing Jaeger, Tempo, or Datadog backend your team already runs.
  • Debug locally by printing spans to the console with ConsoleSpanExporter.
  • Follow a single request across services with context propagation.

Models Under the Hood

openai/gpt-4o-mini

as of 2026-09-14

Limitations

  • Lilypad is a library, not a platform: the docs describe tracing, sessions, spans, versioning, LLM instrumentation, and context propagation, and nothing about a hosted UI, trace storage, prompt management, or experiment tracking.
  • You supply the backend—configuration points at any OpenTelemetry-compatible target, and development can use the console exporter—which means you also own collector setup, retention, sampling, and access control.
  • It is Python-only.
  • The published docs live under the Ops module guides (Configuration, Tracing, Sessions, Spans, Versioning, LLM Instrumentation, Context Propagation) rather than a standalone product site.

as of 2026-09-30

Verification history

We have re-verified Lilypad 18 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-checked, vendor evidence unchanged
  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 18 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 teams who already run an OpenTelemetry-compatible backend and want LLM tracing without adding a paid observability subscription.

What this tier adds

Starting tier and only tier: MIT-licensed library installable via pip as mirascope[otel], covering tracing, sessions, spans, versioning, LLM instrumentation, and context propagation.

Hidden costs & gotchas

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

  • There's no license fee, but you pay for the OpenTelemetry backend you export to—hosting, storage, and retention for Jaeger, Tempo, Datadog, or similar land on your own bill.
  • Running the OTel collector and keeping it updated is engineering time that doesn't show up on an invoice, and it scales with how many services you instrument.

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 itself is free under the MIT license, so the cost comparison isn't tier-versus-tier—it's infrastructure you already pay for versus adding a managed observability subscription. Teams already running OTel get LLM tracing at effectively zero incremental license cost; teams comparing against hosted options like Langfuse or Helicone should budget the backend and the ops time instead of a per-seat fee.

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 dev who already has a TracerProvider, it's minutes: pip install "mirascope[otel]", call ops.configure() with the provider, and add @ops.trace to the functions you care about. For a team that still needs to stand up an OTel collector and choose a backend, budget hours to days depending on the backend—that infrastructure work is the real setup cost, not the library.

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 a bare OpenTelemetry setup: add @ops.trace, ops.session(), and @ops.version on top of your existing TracerProvider without changing backends.
  • →From Mirascope without ops: install the otel extra and layer tracing onto the @llm.call functions you already have.
  • →From print-statement debugging: swap in the ConsoleSpanExporter to see structured spans during development.
Migrating out
  • ↗To a managed platform like Langfuse: keep equivalent instrumentation but move trace storage and the UI to the vendor instead of your own backend.
  • ↗To a broader prompt-management product: pair Lilypad's tracing with a separate tool for prompt versioning and experiment tracking.

Integrations

LangfuseJaegerZipkinGrafana TempoDatadog

Resources & Guides

Tutorials & Learning

YouTube returned 6 videos for “Lilypad”, and we withheld 6: 6 could not be judged, because “Lilypad” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Lilypad.

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

OpenLIT is an open-source, OpenTelemetry-native agent harness engineering platform for LLM tracing, evals, and guardrails you self-host.

FreemiumTry
MLflow

MLflow

Open source AI engineering platform for agent and LLM tracing, evaluation, prompt management, and ML lifecycle work.

FreeTry
RAGAS

RAGAS

Open-source Python framework that replaces vibe checks with reproducible evaluation loops for RAG pipelines and AI agents.

FreeTry

Frequently Asked Questions

Used Lilypad? Help shape our editorial sentiment research.