Why we threw the baby out with the bathwater: Why we rebuilt on OpenTelemetry

We have just dropped the the next major version of the LangWatch Python SDK. Over the past 2 months (March → May 2025), we lovingly tore out our all of our stoic leaders hand-crafted tracing and observability code, and in it’s place is a brand new, simple, standards-driven OpenTelemetry compatible SDK. This release ships with zero breaking changes, and it’s all just a just a single command away.

And on top of that, this has laid the ground work for us to start rapidly shipping a lot of exciting features; think batch evaluations, seamless prompt management, MCP instrumentation, and we’re just kicking off.

A warm welcome to LangWatch

Hey there 👋, I’m Alex - an Engineer at LangWatch. OpenTelemetry fetishist, and in a proud love/hate relationship with Python, especially after this project. I jumped aboard at the start of March, with my first week being the usual early stage startup scavenger hunt, learning about the business, mapping out the repo, finding where all the bodies are buried, and trying to figure out why Python won’t install using the exact same command your colleague just used.

Week two? Learning my first project was this. A full re-architecture of the most popular entry-point to our product, with complete retro-compatibility, in a language I wasn’t particularly familiar with. No pressure, right? Spoiler: It seems to have gone well (I’m still here…)

What Is OpenTelemetry? Why it’s a game-changer for GenAI Apps

Think of OpenTelemetry as the USB-C of observability: one open, language & vendor-agnostic standard that works the first time, no flipping it round 3 times… Plug the LangWatch endpoint into any OpenTelemetry compatible collector and watch the spans flow. Once you have the basic collector-exporter setup, you can plug in, usually in a single line of code, instrumentors for everything from Databases to Servers, Loggers to Feature Flags, and now even to Generative AI.

To cut it short, you get more, by doing less. What’s not to love?

Observability must be a first-class citizen in GenAI

GenAI really is like people. It’s not deterministic, they don’t behave, they even answer back and negotiate. The same prompt can cost twice as many tokens between two almost identical requests, stall and require multiple retries, or just go on an absolute acid trip and reinvent reality. Without rich traces recording prompt content, generations params, token counts, model version, latency, tool calls, and the ever growing list of features, keeping this portion in a black box is unsustainable.

LangWatch, coupled with all the benefits of the OpenTelemetry ecosystem, is essentially the Flight Data Recorder for your GenAI applications. Silently observing, tracing every prompt, token, latency spike, rag invocation, and hallucination allowing you to dive in and replay, dissect, debug, and then optimise when things (inevitably) get funky.

From “Moonshine” to Craft Brewing

Tired: Our existing Python SDK used a custom interpretation of the trace and span pluming that OpenTelemetry standardises. This felt like a good option at the start, especially as OpenTelemetry at the time had no GenAI standards defined and the ecosystem was moving so quickly. But this has ended up with some less than ideal problems for us, and users alike. Hand-rolled spans, inconsistent and non-portable data structures, and a full exporter-collector we had to babysit.

Wired: Now we’re pulling up to the function with native OpenTelemetry spans, context propagation, baggage, battle-tested exporters and processors that “just work”. Not to mention incredible documentation to boot.

Plug and play, this is all you need to get started.

What You Gain with the New LangWatch SDK: Instant Benefits

As someone we all have weird feelings about now used to say “The best part is no part”. Being able to strip out all the additional overhead we were maintaining and growing means we can spend much more time shipping the features that matter, and give you the confidence you need to ship as quick as you like.

You also immediately have access to a wealth of LLM instrumentors, with a few of them hand-pick for your convenience on our brand new docs. Go and check them out (but finish the blog first, of course).

There's also the open-source dividend at play here. By reducing siloed projects and focusing on a single shared goal, we benefit the entire community. We're committed to actively participating in Special Interest Groups and Working Groups, sharing our experience to advance the broader OpenTelemetry mission.

What’s Next for LangWatch: Batch Evals, Prompt APIs, and MCP Support

Making our Roadmap go Super Sonic

As I mentioned briefly at the start of this blog post that I hope found you well, the longer-term win of this project is the new base we have to launch new products, improvements to our existing ones, as well as a much deeper integration across the whole platform. We have a few very exciting goodies coming, and sooner than you might think.

Batch Evaluations API
A new set of API’s to make running batch evals a breeze. Running evals in your critical production flow, a Jupyter notebook, or even just in a step in your CI? We’ve got intuitive API’s your team will love.

Prompt Retrieval & Instrumentation API - Version, Diff, Rave, Repeat
To compliment our hard-hitting Prompt Optimization Studio and recently shipped Prompt Versioning product, soon you’ll be able to retrieve versioned and secure prompts, via the SDK, and have that data automatically instrumented across all of your traces. It just works.

MCP instrumentation
We gained some valuable insight into the MCP ecosystem when we build the LangWatch MCP Server in our of our Hack Fridays, and see this is an area of the GenAI observability stack that would benefit from some love and attention.

Go hard or Go home?
We’re doing both. OpenTelemetry cleared the runway for our first-class Go SDK, complete with native OpenAI instrumentation.

How to Get Started with LangWatch’s OpenTelemetry SDK for Python

We’ve revamped and really pushed the boat out with the docs that are launching along side this release. Head over to the docs for a complete getting started guide, with guides on common practices, pit-falls, and the like.

Read the docs.

Migration - blink and you’ll miss it

Already using LangWatch? Upgrade like it’s going out of style.

uv add "langwatch>=0.2.0"

That’s it. Your current tracing calls stay the same, and might even get a few more useful insights out of the box. Anything we’ve marked for deprecation has a gentle warning, guide to move on, and have months until we plan to delete anything.

Install and Instrument, all in 3 lines of code

uv add langwatch

import langwatch
from openai import OpenAI()

client = OpenAI()

@langwatch.trace() # create a trace over your desired path
def main():
	langwatch.get_current_trace().autotrack_openai_calls(client) # insturment openai calls
	# ... rest of your message handling logic ...
	pass

Run the script, open your dashboard, and watch the spans flocking to you.

How to return the favour

If the new SDK feels smoother—and we think it will—let us know. File an issue the moment something smells off, star or watch the repo to stay in the loop, and tell the next dev wrestling with GenAI traces that there’s an easier way. Your feedback keeps the upgrades coming.

Swapping out our tracing internals felt like replacing a jet engine mid-flight - somewhere over the open ocean - but now we’re cruising at full throttle. We can’t wait to build the next wave of LLM-Ops tooling together. 🚀

Useful links

• Docs - Homepage

• Docs - Getting Started

• Docs - Python Guide

• Docs - Python Integrations

• Docs - Python Tutorials

• OpenTelemetry Docs - Python

Frequently Asked Questions

pip install --upgrade langwatch
# or
uv add "langwatch>=0.2.0"