Last updated: May 15, 2026
Code RED Newsletter #31
It's official. More than seven years after the OpenTracing/OpenCensus merger, OpenTelemetry has graduated from the CNCF. The TOC vote closed last weekend at 81.82% in favor - well above the 66% threshold, zero against. The project that started life as the merge of OpenTracing and OpenCensus is now sitting at the same table as Kubernetes, Prometheus, Envoy, and friends. If you've been instrumenting things with OTel for the last few years, you've probably had the same reaction as JohnHillegass on the PR: "I've integrated OTEL into so many projects that I honestly forgot it was still in the incubating phase." Same.
This issue is about what graduation actually means in practice, both for the protocol itself and for the next chapter that's already arriving on top of it: agents in production, and how we observe them.
In focus: Graduation Day
Graduation isn't an internal CNCF formality. It's the threshold a lot of enterprise security teams have been waiting for - "no beta software" rules really do block adoption. So this is a real unlock, not just a milestone. But it also marks a handoff: the protocol has settled, the surrounding projects are reorganizing around it, and the action moves up the stack to what we're observing with it. Which, increasingly, is agents.
OpenTelemetry, Officially Graduated
The graduation due-diligence document came together as TOC PR #2134, with the binding vote closing last weekend. There's a useful subtext in Ted Young's comments leading into this moment: the goal for the project from here is to "make it boring." Stability over innovation. Get the long tail of semantic conventions to 1.0 across every supported language, possibly with the help of AI tooling to do the mechanical work, so maintainers can review instead of write from scratch. The motivation is concrete: enterprises with no-beta-software rules are unblocked the day a project hits 1.0 and graduates. That's the unlock you actually feel in procurement conversations. From here, the project's job is to keep getting more boring, in the best possible way.
OpenTelemetry Ecosystem Explorer
Just in time for graduation, the OpenTelemetry community shipped the Ecosystem Explorer: a unified discovery layer across the Java agent ecosystem for now, soon the Collector, and more to come. The motivating data point in the announcement is bracing: only about half of OTel users said they relied on opentelemetry.io as their primary source. The rest were piecing things together across GitHub repos, Slack archives, and assorted READMEs. The maturity argument I keep running has a navigation dimension I hadn't fully appreciated until this landed: "supports OpenTelemetry" was always too coarse a label, but you can't even score what you can't find. A small but significant graduation-day artifact.
Jaeger v2 Re-Anchors on OpenTelemetry at Its Core
Continuing the "everyone is reorganizing around the protocol" theme: Jaeger v2 has reframed its architecture so OTLP is the primary ingestion path, with the AI agent observability gap as the wedge. The structural point matters more than the marketing framing. Jaeger has been a flagship distributed-tracing project since the early days of cloud-native observability, and a v2 that's OTLP-native rather than OTel-adjacent is a quiet "the protocol won" story. The graduation theme keeps repeating itself: as the protocol settles, the projects sitting on top of it consolidate around it.
Code RED Podcast: Observability at the Proxy Level with William Morgan
William Morgan, CEO of Buoyant and creator of Linkerd, joined Mirko for a candid conversation about what proxy-level observability looks like, and why it might be the right place to instrument AI agent traffic. Linkerd has been doing service-mesh observability for a long time; William's pitch is that the proxy layer is also a natural choke point for agent traffic. Identity, mTLS, and now visibility into which services agents are calling and how often, without modifying application code. As more autonomous agents end up calling more services more times, the proxy layer becomes a natural place to see what just happened, without having to instrument every agent and every callee separately.
Choice cuts
Pour yourself a coffee. A few more pieces from the ecosystem that pair well with the graduation theme.
OpenTelemetry Signals from First Principles
Worth bookmarking, especially this week: Ashley Mannix's first-principles walkthrough of the OpenTelemetry signals. Starts with the primitive (an event, with a timestamp and some context) and builds logs, traces, and metrics on top as incremental progressions, each serving a different diagnostic need. It's the kind of writeup I wish existed when I was first explaining OTel to platform teams who came up on three separate stacks. Pairs well with the graduation moment: a graduated protocol benefits from teaching material that doesn't start with "so there are these three signals…" as if they fell from the sky.
CloudWatch Starts Ingesting OpenTelemetry Metrics
Quietly more significant than the announcement reads: AWS opened public preview on OpenTelemetry metrics ingestion in CloudWatch. You can push OTLP metrics directly into CloudWatch and see them alongside the native AWS service metrics. The protocol-won subtext: cloud vendors are now plumbing OTel as a first-class ingestion surface, not bolting it on as an export option. Five years ago this would have been a press release dressed up as an integration. This week, it's a Tuesday.
Three Observability Stacks, Still (and a Coding-Agent Counter)
The CNCF blog ran a piece last week titled "The tools are ready. So why are most cloud native teams still running three observability stacks?". A fair counterpoint to the graduation celebration. The standards exist. The projects exist. Teams still run "OpenTelemetry for instrumentation, Prometheus for metrics, Jaeger and Tempo for tracing, OpenSearch for logs" stitched together. The protocol is done; the integration story isn't.
One small lever for that integration gap, since coding agents are now writing so much of the new code: Michele Mancioppi has been quietly building dash0hq/agent-skills, a set of OpenTelemetry skills and reference docs you install into Claude Code, Cursor, and friends. When the agent writes new instrumentation, it follows semantic conventions, picks the right signal types, and doesn't ship the half-baked console.log-equivalent of OTel. The integration story doesn't fix itself, but if coding agents are doing the work anyway, you may as well teach them the rules first.
Everything is Connected: From PromQL to Dashboards and Back
While we're on the subject of integration: a satisfying piece of Dash0 product news that lands on theme. You can now drill down from any chart, pie slice, or stat value into the raw logs, spans, and web events that produced it, with filters and time range carried over automatically. The mechanism is symbolic logic on the PromQL AST: parse the expression, extract the matchers, find the raw telemetry that matches. It was co-developed with Julius Volz, one of Prometheus' founders. A quiet example of what the protocol-won moment is supposed to unlock: stop forcing humans to copy timestamps across three tools, and let the standard query language take you to the data.
Observing vLLM with OpenTelemetry and Dash0
If you're running vLLM in production, or thinking about it, this is the practical guide. It walks through what tracing data vLLM exposes, the relevant Prometheus metrics, and how to wire it all together via the OpenTelemetry Collector into Dash0. The clean version of the "supports OpenTelemetry" question we've been running for a while: here's what the support actually looks like in practice, with screenshots.
Observing Spring AI Applications with OpenTelemetry and Dash0
Companion piece for the JVM crowd. Spring Boot 4 ships an OpenTelemetry starter for Spring AI, and this post walks through tracing LLM calls, tracking token consumption, and debugging tool invocations - all with stock OTel signals. Less novelty, more production-ready: the AI workload looks like every other workload once you instrument it properly.
Beyond the Stage: Taming Agentic Workflows with Dapr and OpenTelemetry
If you missed our KubeCon Amsterdam talk - or watched it and wanted the directors' cut - Julia Furst Morgado hosted Mauricio Salatino and me for a deep-dive webinar walking through what we actually built and the decisions behind it. The setup: a pizza store with four agents talking over MCP and A2A, protocols that are barely a year old, with all the maturity-shaped holes you'd expect at that age. We get into why we shifted from the original abstract (Dapr workflows plus the OTel operator and no-touch instrumentation) to a much more agentic demo once the protocols started moving fast, and what it actually takes to observe four agents reasoning over each other without losing the thread.
Graduation closes a chapter that started in 2019. The protocol is now boring infrastructure, which is the highest compliment we can pay to a piece of software. The next chapter is already in motion: agents are users, platforms are bottlenecks, and observing what these systems actually do is the only honest way to keep them in production.
A quick travel update before I sign off:
- Earlier this month: KCD Texas (Julia repping Dash0 on stage) and DevOpsDays Zurich.
- Next week: Cloud Native Days Romania (me) and Cloud Native Italy in Bologna (Mauricio).
- Thursday: I’m giving a keynote at KCD Czech and Slovakia.
If you're at any of these, come find us. Happy to talk graduation, agents, observability, or all of the above.
Until next time: may your agents stay observable, your traces include the prompts, and may your collectors live a long, boring, graduated life.
Kasper, out!
Hi, my name is Kasper!
I'm Kasper Borg Nissen, Director of Product Marketing & Developer Relations at Dash0. I'm passionate about Observability and bridging the gap toward developers through Platform Engineering. I've previously worked 8 years as a platform engineer, I'm a former co-chair of KubeCon+CloudNativeCon, and I'm genuinely obsessed with all things cloud-native and open standards.
