Late this May, I hopped on the short flight from Chicago to Minneapolis for this year’s Observability Summit, ready to learn firsthand what the community was actively working on and discussing. I’m incredibly glad I went. I came home carrying a string of deeply interesting conversations and talks from experts about the future of OpenTelemetry, databases built for agentic queries, and where observability is headed as AI works its way deeper into the stack.
(My enthusiasm for AI Teammates was wide awake! But my eyes had other plans…)
Photo: CNCF Events, Observability Summit NA 2026
What struck me most though was the pace. There’s a huge appetite right now for all things AI and agent-led in observability, particularly around noise reduction and incident response. But alongside that enthusiasm I picked up on a real undercurrent of concern, that the foundation underneath all of it isn’t yet where it needs to be to make any of it effective. By the end of the second day two themes had wedged themselves into my brain. The first was a shift in how we think about observability itself, moving from reactive to proactive (an approach that resolves incidents before they become, well, incidents!). The second was a renewed conviction that OpenTelemetry, as an open standard, is the foundation that makes the AI era actually workable across vendor boundaries.
Here is what I took away from both.
The Shift from Reactive to Proactive
For most of the last decade, observability has been a reactive discipline. Something breaks, an alert fires, and a human goes digging through dashboards to figure out what happened and why. We have gotten very good at this. We have also been quietly accepting that “good” means we are always a step behind the problem.
A lot of the Minneapolis sessions were making the same argument: we do not have to keep working this way. The question kept coming up: why wait for things to break when you could be out finding the weak spots ahead of time?
I think a great demonstration of this was Hud CTO May Walter’s talk, “Let Them Eat Bugs: Practical Showcase of Agentic Issue Resolution”.
Photo: CNCF Events, Observability Summit NA 2026
I think her sharpest point was about instinct. A good engineer skims past low-signal noise to the thing that matters almost without thinking. Agents have no such instinct, so incomplete context does not slow them down, it quietly misdirects them. She tied this to a feeling we have all had reviewing AI-generated code: it compiles, the tests pass, but you are never quite sure it fits the system it is about to enter. Her reframe was to use runtime intelligence as a compass for code generation, feeding production context into the development loop before things ship. The question becomes: what does this system actually do in production, and does the code I am about to ship fit that reality?
What I like about that framing is how it extends the proactive shift past the runtime and into the development loop itself, all the way back to the moment code is written. And it lands right on the foundation question that ran through the whole summit. An agent reading your telemetry as a compass is only as good as the telemetry you hand it. If those signals are fragmented or locked into a format the agent cannot parse, you are not giving it a compass at all. That is exactly why the data layer underneath matters so much, and it is the thread I want to pull on next.
OpenTelemetry as the Standard That Unlocks the AI Era
The second theme is the one I feel strongest about, and it ties directly into the first.
If we are going to feed our telemetry into AI and agentic systems, and clearly we are, then the shape and portability of that data matters enormously. This is exactly the moment where it would be tempting to chase whatever proprietary format ships with the shiniest new tool. I think that would be a mistake. The whole point of an open standard is that you keep control of your own data regardless of which vendor’s roadmap shifts, and in a period of innovation this fast, locking yourself in is the last thing you want to do.
OpenTelemetry gives you a control layer for your data. A clean, consistent, vendor neutral stream that you can route into whatever analysis or agentic solution makes sense for you this quarter, and a different one next quarter, without re-instrumenting everything. That flexibility is worth a lot when the tooling landscape is changing month to month.
A couple of sessions reinforced this for me, including one from Collibra Principal System Architect Alex Van Boxel, titled “Taming Tenancy, Cost, and Architecture at Collibra Through OpenTelemetry and our Telemetry Backbone.” Running a SaaS platform brings the same observability problems as any enterprise, but scale and tenancy pile a huge multiplier on top of every signal, and that hits both cost and effectiveness. Collibra’s infrastructure spans virtual machines, Kubernetes clusters, and a mix of single and multi-tenant setups, and without the right context all of that telemetry collapses into a noisy, indistinguishable flood.
Photo: CNCF Events, Observability Summit NA 2026
The part that connected back to everything else for me was his point about agents. Investing in semantic contracts up front means an agent is working from structured, attributed information with real context behind it. That structure keeps an agent’s context accurate and relevant over time, and it is what lets it reason about a system without getting lost. It is the same foundation argument from a different angle. Do the unglamorous work of giving your telemetry meaning and hierarchy, and everything you want to build on top of it, agents in particular, gets more reliable.
Why These Two Threads Belong Together
Here is the connection that pulled the whole event together for me. You cannot be proactive on a shaky foundation.
Finding issues before they degrade production, letting agents investigate without anchoring bias, pushing intelligence to the edge, all of it depends on telemetry that is consistent, correlated, and portable across your stack. If your data is fragmented across formats and silos, your complex agentic RCA workflow burns time on data plumbing and never reaches the actual root causes. The proactive future everyone wants is built on a mature data foundation.
This is the part where I will admit my own bias, because it is exactly the problem we think about every day at Edge Delta. The reason we built a unified stack, pipelines, observability, and agentic analysis in one integrated product, is that bolting those layers together after the fact tends to reintroduce the very silos and inconsistencies that make proactive observability so hard. When the pipeline, the analysis, and the intelligence are designed to work together from the start, the data foundation is production ready by design, with no integration debt to pay down later. The summit conversations, more than anything, validated that this is where the discipline is heading.
Looking Ahead
The takeaway from two days in Minneapolis is that the surface we have to observe is expanding fast, the costs of observing it are climbing right alongside, and AI is reshaping both what we watch and how we respond. The teams that keep up will be the ones who got the foundation right first. An open standard underneath, a strong control plane in the middle, and the freedom to plug in whatever intelligence the moment calls for on top.
We are moving from watching and waiting to anticipating and acting. It is a good shift, and I left Minneapolis more convinced than ever that the groundwork we lay now is what determines who gets to ride that wave and who scrambles to catch up.
Top comments (0)