Observability Summit North America 2026

Traditional observability assumes humans operate systems. AI agents break that model—they make autonomous decisions, execute operations without approval, and drift in capability over time. Yet most organizations have zero observability into their AI agent infrastructure.

When developers spin up MCP servers through Claude Desktop or Cursor, security and ops teams are blind. No metrics. No traces. No logs. Just autonomous agents accessing databases, calling APIs, and modifying production systems—completely outside your observability stack.

This talk explores how to instrument AI agents and MCP servers using familiar CNCF tools. We'll cover:

• Why traditional APM fails for autonomous agents (no request/response, emergent behavior, capability drift)
• Detecting anomalies in agent behavior (statistical baselines vs. ML-driven detection)
• Correlating agent actions to business outcomes

You'll see working demos of agent observability plus open-source code for instrumenting LangChain, CrewAI, and custom agents.

Walk away with patterns to extend your existing observability stack to AI agents before they become your biggest blind spot.

No platform owner wants to be told their platform is down by a user. A core responsibility of the platform operating model is ensuring a reliable platform for the organization. In practice, it isn't always easy to detect when things are broken, especially when it falls outside of the traditional metrics coverage.

In our work, we adopted synthetic monitoring using Kuberhealthy, a CNCF project, to gain better visibility into whether the Kubernetes platform is operating as a user would expect. Synthetic monitoring allows us to replicate application developer workflows to validate end-to-end functionality of the platform.

Come and learn about implementing synthetics, how to not break things, and broadly how to improve stability with Kubernetes using synthetic monitoring.

We see IoT everywhere, from smart fridges to air quality sensors, but what about applying observability to billions of living things? Introducing Meowy, my virtual cat with a full observability stack. In this talk, I'll build a digital pet from scratch in Go, instrument it with OpenTelemetry, and visualize its "life" in real time, live-tracking its habits, moods, and (attempted) escapes.

I'll show how to create a RESTful "cat API," instrument it for tracing, and set up alerting with the ELK stack and Kibana visualizations. We'll cover observability basics (logs, metrics, and traces), how to apply them to our digital pet, how to structure telemetry data for "living" systems using AI tools, and how to query all our cat stats with an MCP-connected AI agent. By the end, we'll calculate the average MPH (meows per hour) and expand our understanding of observability applications. No prior observability experience required—just some Go basics and a love for any living thing, from feline to fungal!

Metrics observability workloads are growing in scale, resulting in (a) higher cost to operate observability infrastructure, and (b) slower query latencies.

The usual approaches to deal with these are:
- sample data
- roll up data
- reduce data cardinality
- send less queries

All of these approaches compromise the coverage of the observability infrastructure and can result in missing important anomalous behavior.

Through our research, we have developed a radically new approach to achieve large scale, low cost, and low latency without compromising the coverage of the observability infrastructure.

Our system reduce querying cost and latency by 100x by using 2 key techniques:
- streaming precomputation
- sketch-based approximation

Our system is developed as a drop-in accelerator to an existing Prometheus-Grafana stack, without modifying Prometheus or Grafana.

We will release an open-source prototype of this system in the Q1 2026.

As large language models scale across hundreds of GPUs and multi-node AI systems, they’ve become a major operational challenge for infrastructure engineers. Traditional observability tools stop at the node level, leaving GPU health and utilization invisible until workloads fail or budgets spike. Imagine a 25 day training job failing on day 23 because one GPU silently throttled!

In this session, we’ll explore GPU-Scanner, an open-source observability extension for Kubernetes GPU clusters. Built to integrate with Prometheus & OpenTelemetry, GPU-Scanner adds both active and passive GPU health checks, capturing throughput, TFLOPs, memory diagnostics, thermal consistency, and long-run stability metrics.

We’ll demo real-world failure modes like catching a GPU “off the bus” or detecting thermal throttling and show how alerts flow into your existing observability stack. Leave with a practical playbook to proactively validate GPU clusters and maximize reliability and utilization.

Java is one of the most widely used languages for enterprise applications. Frameworks such as Spring Boot and Quarkus make observability straightforward when the OpenTelemetry Java agent can be injected.

In many production environments, however, modifying application code or JVM startup parameters is not possible. In these cases, eBPF-based instrumentation enables observability without code changes, but applying eBPF to Java is challenging. JVM abstraction layers, differences across JDK versions, and the diversity of frameworks and libraries complicate generic instrumentation. The problem becomes even harder when applications rely on TLS-encrypted communication such as HTTPS, gRPC, databases, and messaging systems, where payloads are opaque.

This talk explains how the OpenTelemetry eBPF Instrumentation (OBI) project addresses these challenges, covering key design decisions, trade-offs, and current limitations. The discussion is grounded in real-world examples, including Spring Boot services using HTTPS and gRPC, and a Quarkus application with TLS-encrypted PostgreSQL and Kafka, showing what is possible today with agentless Java observability using eBPF.

Nubank is the largest digital bank outside Asia, operating in Brazil, Mexico, and Colombia, and serving over 120 million customers. As a cloud-native company, Nubank distributed digital environment relies on more than 4,000 microservices, generating nearly 1 petabyte of monitoring logs daily. To better manage this volume and reduce operational costs by over 50%, Nubank recently transitioned from an external vendor to an in-house log platform. In this talk, we'll share the platform architecture and the challenges encountered during the migration journey.

Configuring Ingress, Gateway API, or service meshes in Kubernetes can feel like exploring an open world without a map : one wrong turn, and traffic vanishes. In this session, we’ll explore how to detect and prevent misconfigurations using OpenTelemetry, eBPF-based instrumentation (OBI), and enriched logs from service meshes and ingress controllers. Like a hero collecting tools to unlock new areas, we’ll show how to identify relevant data sources, parse and process their output, and apply common correlation rules to understand the impact of configuration changes. We’ll demonstrate how these techniques can be applied across observability platforms to reduce tool sprawl and improve operational efficiency. Attendees will leave with a practical, backend-agnostic approach to building a multi-source observability strategy for Kubernetes networking.

What if we could move a big chunk of bug fixing and solving production issues to agentic AI? That would be so cool. In this talk we will go through the end to end process of setting up a background agentic workflow that detects production errors, finds their root causes, assesses the right solution and opens a PR - so you wake up in the morning to tasks almost fully completed for you by your loyal agent.

Together we will dive into the entire process of setting up this system that is currently running in real production environments - understanding the different tools, the infra challenges, the agentic accuracy spectrum, and more…

Modern telemetry systems often struggle not because of missing features, but because of hidden constraints in how data is buffered, scheduled, and moved through the system. This session explores the practical realities of building a telemetry data plane that must operate under extreme throughput, tight latency budgets, and strict resource limits.

Using real-world experience from developing a high-performance open source telemetry agent, we’ll examine how design tradeoffs around buffering, concurrency, and I/O shape system behavior at scale. Topics include user-space serialization strategies, adaptive buffering models, memory-mapped persistence, and multithreaded I/O coordination, along with how these choices interact with core Linux primitives such as epoll, asynchronous I/O, and zero-copy techniques.

Rather than focusing on APIs or products, this talk dives into the mechanics and constraints that determine whether a telemetry system remains predictable under load. The discussion is grounded in production lessons learned from operating at billions of events per minute and highlights patterns that apply broadly to collectors, agents, and streaming systems.

Modern observability has embraced eBPF for profiling CPU usage and tracing network paths in production systems. Yet one critical layer remains largely under-instrumented: storage. Despite being a frequent source of performance issues, storage I/O is still treated as a black box, especially in cloud native environments.

This talk we will walk through the basic storage I/O path in Linux and Kubernetes, highlight where traditional metrics fall short, and discuss the kinds of storage latency and wait signals that eBPF can surface at runtime without requiring kernel modifications or specialized debugging setups.

Using simple examples, the session will show how hidden storage latency and queuing effects surface in real workloads, and why these blind spots become more visible with data-intensive and AI workloads where applications or GPUs often wait on storage without clear indicators.

By the end of this talk, attendees will gain a practical understanding of where storage observability breaks down today, what eBPF can realistically help uncover at a foundational level, and how to reason about storage-related performance issues alongside CPU and networking metrics.