Last updated: June 12, 2026
Code RED Newsletter #33
OpenTelemetry is the foundation. It is not the destination. That's the line behind a repositioning we made last week: Dash0 is extending from "OpenTelemetry-native" to "Observability for the AI era." The message is simple: agents, not humans, increasingly write, ship, and run software - all the way out to the "dark factory" people have started sketching. So observability can't just be a wall of dashboards someone squints at mid-incident. It has to be the thing those agents reason over.
And here's the catch: none of that climb up the autonomy ladder works without telemetry the agents can actually trust. An agent reasoning over your system is only as good as the signal it reads - garbage telemetry in, confident garbage analysis out. For agent and LLM workloads, that signal lives in the GenAI semantic conventions, which puts one unglamorous question at the center of the whole AI-era pitch: is your GenAI telemetry any good? The spec side has come a long way - the conventions now describe real LLM and agent behavior - but "supports GenAI" still means wildly different things from one library to the next. Same "supports OpenTelemetry is too low a bar" problem I keep banging on about, aimed at a shinier target.
One more bit of Dash0 news that fits the moment: we were named to Redpoint's 2026 InfraRed 100, the list of private companies building the infrastructure layer for AI. Fitting company to keep, given where we just said we're headed.
In focus: GenAI, Spec vs. Reality
What the GenAI Spec Says vs. What You Actually See
My favorite kind of talk: someone does the unglamorous validation work in public. At Observability Summit North America, Zach Groves of Datadog - a vendor engineer, no less - put real GenAI OpenTelemetry libraries on a tier list and showed three ways "supports OTel" silently fails: emitting deprecated attributes, emitting outright wrong attributes, or span-processing the data into a proprietary namespace entirely. The spec is finally good; the implementations are a wild west. It's the whole OpenTelemetry Support Maturity Model argument in one talk - the gap lives in the semantic conventions, and the only honest test is to validate what your library actually emits. Required viewing if you've ever taken a compatibility claim at face value.
Five Semantic Conventions, One Config Property
If Groves diagnoses the disease, Mauricio Salatino - fresh off keynoting KCD New York - shows the field dressing. His post walks through how Arconia (created by Thomas Vitale) lets a Spring AI app switch between five competing GenAI convention schemas (OpenTelemetry, OpenInference, OpenLIT, and friends) with a single config property. Genuinely useful engineering - and the clearest illustration of the problem: needing a "convention flavor" switch at all is the fragmentation story compressed into one line of config. The band-aid is clever. The wound is real.
Jaeger Evolves to Trace AI Agents
What happens when a decade-old tracing project meets a workload that refuses to behave? This CNCF blog walks through how Jaeger is adapting to trace AI agents, where tracing's founding assumptions - deterministic call graphs, predictable fan-out - simply don't hold. The throughline I like: agents don't get a brand-new observability stack, they get the mature one we already have, stretched and reshaped to fit. Which is exactly right - the worst outcome would be a parallel universe of bespoke agent telemetry that talks to nothing else you run.
Code RED Podcast: Tracing at Planet Scale with Heinrich Hartmann
A change of altitude. Heinrich Hartmann joined Mirko to explain how Zalando monitors sixty million spans per second - and the number is almost beside the point. What's worth your commute is the philosophy underneath: what you keep, what you drop, how you sample in a way that survives contact with reality. I put it here on purpose: it's the discipline GenAI telemetry is about to need and mostly lacks. Agent traces are verbose, non-deterministic, and expensive, and "collect it all, sort it out later" stops working fast.
Agent0 Goes GA - From Signal to Pull Request
I framed the "observability for the AI era" shift up top; here's the artifact that makes it real (and the most Dash0-centric thing in the issue): Agent0 is now generally available. It correlates the signals, traces a problem back to the source code that caused it, and opens a pull request with a fix - validating every artifact (alerts, dashboards, PRs) against live telemetry first. Why it belongs in a GenAI issue and not a changelog: an agent is only as good as the spans it reads, so the boring convention work is the moat. It's OTel-native by design, and the human stays on the merge button - it drafts, you decide. June is free against real production data before pricing lands in July.
Choice cuts
Pour yourself something cold - it's June, the conference calendar is brutal, and your collectors deserve a moment too. A few more pieces from the past couple of weeks, some still on the convention beat, some just too good to skip.
Towards Semantic Conventions for Carbon
Staying on the convention thread, for a brand-new signal: the Green Software Foundation is assembling a working group to define a semantic-convention registry for Software Carbon Intensity - emissions, energy, carbon intensity, functional units - and submit it to the OpenTelemetry Semantic Conventions SIG. Exactly the right venue, and the right lesson from GenAI: standardize the signal before it fragments into five bespoke schemas. Twenty seats, applications open through June 24.
Read the call for participants
From Spicy Autocomplete to the Dark Factory
A pattern worth naming: agentic development has quietly standardized on "levels of autonomy," borrowed straight from NHTSA's driving-automation model. The origin text is Dan Shapiro's five levels from January, which gave us "spicy autocomplete" at the bottom and the "Dark Factory" at the top. In the last two weeks, three more landed on the same frame: Platform Engineering's four, Dash0's six (which keeps Shapiro's dark factory as L6), and Mauricio Salatino's five - GenAI Assisted up to Full Autonomy - which adds the sharpest version of the platform-engineering angle: each jump (especially Level 2 to 3) demands the platform shift from reviewing code lines to validating intent, and skipping that work just breeds "Shadow AI." Same argument in all four: it's a sequential progression, not a menu - skip a rung and you get what one piece calls a "Bullshit Factory." Build the harness for the next level, not the highest one.
Read Shapiro's five levels of autonomy
Vendor Neutrality Isn't Magic
A useful splash of cold water on the protocol itself. Adriana Villela and Josh Lee argue, in this New Stack post, that OTel's neutrality is real but bounded: it's absolute at ingestion (OTLP, the Collector, the SDKs) and then it runs out. Their honest map of where lock-in still lives is the valuable part - queries, dashboards, alerts and SLOs, and IaC all typically have to be rebuilt when you switch vendors, because each one rides on a proprietary surface. They also flag the exceptions that point the way out: PromQL-compatible data sources, and Perses' open, portable dashboard format. That last thread is the one we pull on at Dash0 - the openness shouldn't stop at ingest, so we lean on open standards like PromQL above the ingestion line and Perses for portable dashboards. Neutrality at ingest is the floor; portable queries, dashboards, and alerts are the ceiling worth building toward.
RUM Events, On Your Charts
Small but on-theme (yes, this one's ours): Dash0 can now overlay real user-behavior events from RUM as annotations on your time-series charts. The point isn't the feature, it's the correlation - lining up a latency spike against what a user was actually doing is the kind of "connect the signals" work good telemetry should make trivial.
The thread through this issue: GenAI observability hasn't crowned a winner yet - and it'd be premature to pretend otherwise. The competing conventions exist for legitimate reasons, and even the most complete of them is still in development. So the open question isn't which spec wins. It's whether your tooling actually emits what any spec says, or just wears it as a costume. Same maturity question we've asked about "supports OpenTelemetry", same answer: don't trust the label, validate the signal. Get that right, and agents acting on your telemetry - with you still on the merge button - become something you can actually run in production, not just demo on stage.
A bit of road news before I sign off. KCD New York ran this week, with Julia Furst Morgado organizing, Mauricio Salatino keynoting, and the Dash0 crew at the booth. Booth conversations are the part of these events I miss most when I can't make it - they're where you find out what people are actually wrestling with - and the texture from New York was exactly this issue's theme: every other question had moved up the stack to agents and LLMs. Coming up, there are a few ways to find us at PlatformCon: stop by the Dash0 booth, catch my keynote at the Live Day in London, sit in on Julia's workshop at the New York Live Day, or join the virtual event all week for more talks from the Dash0 crew. Wherever you catch us, come say hi and tell me which of your GenAI libraries is lying about its semantic conventions.
Until next time: read the spec, then read your spans, trust neither your vendor's README nor your own assumptions, and may every GenAI library you adopt emit exactly the attributes it claims to.
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.
