A new AI model goes live for a small group of users. Some of them start seeing errors. The build is the same for everyone, so checking the deployment history gets you only so far. Which users got the new model? What else was happening in the application when the errors began? And can you turn off the feature before the incident channel fills up with theories?
That’s the kind of investigation Sean O’Dell, who leads developer experiences at Dynatrace, wants to make easier. In a conversation with The New Stack’s Frederic Lardinois at KubeCon + CloudNativeCon in Salt Lake City, O’Dell explained how Dynatrace brings data from application code, infrastructure, and AI workloads together so developers can see what happened and decide what to do about it.
Give the rollout its own signal
O’Dell said the project can start with a feature flag. A team can ship a build, then use a flag to expose a feature or model to a subset of users. If the team can see that flag alongside its telemetry, it can check whether errors are concentrated among users who got the feature.
O’Dell described what a developer might conclude. “It would be something like, ‘Hey, I saw some issues, but it wasn’t a build; it was actually a feature,’” he said.
That’s where Dynatrace’s interest in OpenFeature comes in. O’Dell sees feature flagging and observability working together during progressive rollouts, when teams need to know both who got a change and how the application behaved afterward. If a rollout starts causing trouble, the flag lets the team disable the feature while it investigates. The pull request can wait its turn.
Start with OpenTelemetry, then follow the request
Lardinois asked whether AI agents need a new observability project of their own. O’Dell’s answer starts with the instrumentation developers may already have in place. “OpenTelemetry allows me a starting point to build upon,” he said.
“An odd answer in the UI may send a team straight to the model, even when the evidence it needs is elsewhere in the stack.”
O’Dell points to OpenTelemetry’s conventions for generative AI and to OpenInference, which builds on OpenTelemetry to provide AI instrumentation. The practical question for developers is how to follow a request when it crosses an application, a database, and a model call. An odd answer in the UI may send a team straight to the model, even when the evidence it needs is elsewhere in the stack.
Dynatrace pitches its Grail data lakehouse and Smartscape as tools that can help teams make sense of that evidence together. A developer investigating a regression can look at the relationships among the services involved and consider what changed in the code or infrastructure. An agent assisting a site reliability engineer can draw on that context, too.
“We want agents to make the right decision at the right time”
O’Dell describes the role telemetry can play in those decisions. “We want agents to make the right decision at the right time,” he said.
The interview gets into what makes that hard. A front-end developer trying to understand what users saw may need real-user monitoring, while a platform engineer following a slow request needs a view of the backend. An agent needs context suited to the task it has been given. That makes deciding what evidence to surface part of the engineering work, alongside collecting it in the first place.
Watch the full interview on The New Stack’s YouTube channel to hear O’Dell and Lardinois discuss where open standards end and an observability platform adds value, why token economics are becoming an engineering concern, and which guardrails matter as agents take on more operational work.
The post Dynatrace just laid out its AI observability playbook at KubeCon. Here’s why it matters for developers. appeared first on The New Stack.

