Observability Summit North America 2026

This talk presents a practical methodology for migrating a large proprietary observability platform to an OpenTelemetry-native architecture, using a GenAI-assisted workflow paired with a robust spec-driven strategy. Faced with hundreds of custom Java-based sensors, the engineering team designed a spec-driven conversion process that leverages GenAI to extract specifications, generate unit tests, and assist in implementing Go-based OpenTelemetry receivers. Each stage incorporates human review and test feedback loops to address the reliability limitations of GenAI and ensure functional correctness.

Additionally, a data-driven feasibility evaluation was conducted prior to large-scale conversion, where defined task types were benchmarked with and without GenAI to quantify effort savings and highlight where GenAI provides the greatest value.

Attendees will learn a reproducible workflow for large-scale migrations from proprietary to OpenTelemetry, how to pair GenAI with automated testing to manage risk, and insights on where GenAI accelerates real-world engineering tasks without compromising quality.

OpenTelemetry’s GenAI semantic conventions are evolving quickly. Version 1.37 marked a major shift in how LLM behavior is expressed using standard spans and attributes. While later releases refined and clarified the spec, real-world adoption remains uneven, and “GenAI-compatible” can mean very different things across the ecosystem.

In this talk, I’ll share hands-on lessons from implementing and validating GenAI support in real emitters, including close collaboration with Strands. Implementing the 1.37 spec on both sides surfaced semantic ambiguities that only became clear in practice and ultimately led to stronger implementations.

I’ll also outline the current GenAI instrumentation landscape: Strands emitting 1.37+ compliant spans; OpenLLMetry, which mixes newer conventions with legacy and custom attributes; and OpenInference, which claims OpenTelemetry compatibility but does not emit GenAI semantic convention attributes.

Finally, I’ll show how these gaps surface in practice—teams believing they emit 1.37-compliant telemetry but sending pre-1.37 or non-spec data—and briefly touch on transition guidance like OTEL_SEMCONV_STABILITY_OPT_IN.

This session presents an AI-powered SRE Agent designed to autonomously orchestrates complex, multi-source investigations by querying internal observability providers and knowledge bases.
A primary focus is the "Data Volume Problem." Modern observability systems generate terabytes of metrics and logs daily; at Nubank’s scale, the Prometheus MCP alone has more than 23,000 metrics available, while log queries can span billions of rows. The team overcame LLM context limits through on-premises data filtering, intelligent summarization, and selective context assembly. This architecture utilizes "Expert Guides" to reduce 23,000 raw metrics to approximately 14 relevant data points before LLM processing.
The talk covers multi-source orchestration using the Model Context Protocol (MCP) for pluggable tool discovery, allowing the AI to progressively load and correlate only the observability sources.
The platform enables the delivery of expert instructions for any specific scenario through targeted, versioned prompts. This transformation allows the platform to scale across the enterprise, performing virtually any investigative task beyond its original root cause analysis mission.

As large language models (LLMs) move into production, raw metrics alone aren’t enough. This talk presents an open-source AI observability solution built on Open Data Hub (ODH) that deploys LLMs using vLLM and KServe, scrapes inference metrics using Prometheus, and feeds them into a summarization model to generate actionable insights. We’ll demonstrate a working UI that translates low-level metrics like latency, GPU usage, and token throughput into human-readable summaries—giving platform teams an intelligent way to monitor LLMs at scale. No dashboards to interpret—just straight answers from your models about your models.

The OpenTelemetry Collector is powerful, but the "debug exporter" only shows raw output. What if you could see your OpenTelemetry logs - with structure, filters, and context - right in your terminal?

This talk introduces Gonzo, an open-source, OTLP-native terminal UI that visualizes logs from the Collector or any OTLP-capable source in real time. Learn how to validate both source instrumentation, and Collector pipelines - including components like filelog, k8sattributes, and transform - without a backend.

Whether debugging, testing configs, or teaching OTel, Gonzo offers a faster, clearer way to understand your telemetry as it flows.

Key Takeaways:
- Validate source instrumentation and Collector pipelines end-to-end
- See enriched OTel logs with structure and context in the terminal
- Debug and iterate on OTel configs faster - no backend required

Enterprises often struggle with the "black box" nature of proprietary APM tools and the high cost of distributed tracing at scale. In this session, we will demonstrate how Comcast tackled this challenge by migrating 350 critical applications from AppDynamics to a cloud-native OpenTelemetry (OTel) stack, achieving a truly unified end-to-end observability experience.

We will pull back the curtain on the architecture that powers this migration. Specifically, we will show how we leveraged the OpenTelemetry Collector to generate Request, Error, and Duration (R.E.D.) metrics from trace data using the SpanMetrics connector. A key highlight will be our unique deployment of Conduit, which serves as a resilient transport layer to ensure data integrity and effective load balancing in a high-volume environment.

Attendees will leave with a blueprint for breaking free from APM vendor lock-in. To help the community fast-track this transition, we will also be sharing and walking through our reusable, battle-tested Grafana dashboards that can be leveraged by any enterprise.

Modern observability stacks excel at capturing signals about infrastructure health, application performance, and request flows. Yet one critical class of decisions remains largely invisible: authorization.
In distributed systems, authorization decisions increasingly determine not only whether an action succeeds, but if data is accessed, tools are invoked, or automated agents are allowed to act. These decisions are often evaluated outside application code using Policy as Code frameworks, yet their outcomes are rarely observable in a structured, privacy preserving way.
In this session, we explore how Policy as Code, Open Policy Agent, and the OpenTelemetry project can be combined to treat authorization decisions as observable events. We examine what it means to observe a decision without logging sensitive inputs, how decision structure differs from traditional metrics and traces, and why decision level observability is becoming essential in cloud native and AI driven systems.
Attendees will leave with a conceptual framework for thinking about authorization as telemetry, and a clearer understanding of where observability is heading as systems become more autonomous and policy driven.

During this session we’ll discuss ElastiFlow’s Edge Observability strategy, which includes an OTel native edge processing node with local DuckDB storage for all OTel signals and an agentic AI system that is model agnostic (we often run it with OpenAI’s gpt-oss-20b), exposing its tools through an MCP server.

Instead of just forwarding OTel signals from various Edge collectors, the signals are analyzed and routing decisions are made. Alerts are sent to the Observability Platform right away, while logs are stored locally and analyzed for patterns. Instead of forwarding all logs, we might only care about a few conditions of interest, often correlated with other signals, and send these to the Observability Platform, while less interesting logs can be aggressively aggregated.

With this approach, we were able to reduce the storage and ingest cost of Observability Platforms by half while actually decreasing the mean time to insight.

As infrastructure scales across regions and clusters, Prometheus deployments fragment into isolated islands of metrics—disconnected from logs, traces, and the dashboards operators actually live in.

This talk is for the Prometheus community. If you've wrestled with federation sprawl, alert duplication, or the gap between your metrics and the rest of your observability story, this session is for you.

We'll demonstrate how OpenSearch's distributed data source support lets multiple Prometheus clusters coexist natively alongside logs and traces in a single unified interface, no data migration, no parallel stacks.

You'll learn:

• Unified querying across Prometheus clusters
• SLO tracking wired directly into dashboards
• Application management that finally connects the signals your teams have been operating in isolation

This is about completing the observability loop the Prometheus community has always needed, open, composable, and community-driven.

Most MCP servers fail the same way: they expose observability data without understanding what AI models need to reason effectively. The result? Tools that overwhelm models with metrics, miss critical context, and introduce unnecessary security exposure.

At Multiplayer, we built an MCP server to give AI coding assistants access not just to production telemetry but to full stack data: frontend screens and data, backend traces, logs, and request/response content and headers. What we learned challenges the "more data is better" assumption that drives most integrations.

This talk shares the hard lessons from moving an MCP server into production. You'll learn why filtered, intent-driven context outperforms comprehensive data access, how to design tools that align with developer workflows rather than API surfaces, and the security trade-offs that matter when LLMs query your observability stack.

We'll cover practical design patterns for MCP servers in the observability space: scoping data by blast radius, surfacing relationships over raw metrics, and handling authentication without compromising developer experience. This talk is about what works when AI meets production systems.

Agentic AI systems represent a fundamental shift in software architecture: autonomous agents reason, plan, invoke tools, and orchestrate complex workflows without deterministic control flow. This breaks many assumptions behind traditional observability.

When agents independently make decisions, failures no longer follow a single request path. How do you debug emergent behavior across multiple agent steps? How do you analyze and control token-driven costs? How do you ensure reliability when outputs are non-deterministic?

This session explores why observability is a first-class requirement in the agentic AI era and how OpenSearch can act as the analytical backbone for understanding autonomous AI systems in production. We will cover practical techniques for instrumenting agent workflows with OpenTelemetry and indexing traces, logs, metrics, and AI decision artifacts into OpenSearch for deep correlation and analysis.

Attendees will learn battle-tested patterns for tracing agent reasoning and tool usage, investigating failures and hallucinations, monitoring latency and cost signals, and building dashboards that make agentic AI systems transparent, debuggable, and production-ready.