The News
At Dynatrace Perform 2026, CEO Rick McConnell used the opening keynote to frame AI-powered observability as mandatory for resilient software and reliable AI. The core thesis: Dynatrace is aiming to connect deterministic AI “answers, not guesses” with agentic AI actions to enable meaningful autonomous operations, starting with the “low-hanging fruit” and expanding coverage over time.
Across the broader keynote, Dynatrace showed how this vision is being operationalized. The company positioned Grail as the backbone for preserving end-to-end context, pulled dependency intelligence directly into analytics, and extended observability deeper into AI and agent-driven workloads. At the same time, Dynatrace addressed long-standing friction around log cost and noise, tied user experience signals more closely to business impact, and emphasized ecosystem execution (most notably with ServiceNow) as the mechanism for turning trusted insight into governed, closed-loop action.
Analysis
Observability Becomes the Control Plane for AI-Native Operations
Dynatrace’s most important message wasn’t “we have agents.” It was: autonomy is impossible without trust. McConnell repeatedly anchored the strategy around determinism using causal/predictive/gen AI to produce reliable conclusions that can safely trigger action. In practice, this is a bet that observability is evolving from a monitoring surface into a decision layer that can govern automation across modern delivery and operations.
For developers and platform teams, this framing matters because it aims to address the real reason “autonomous ops” has historically stalled: not lack of automation tooling, but lack of confidence that automation will do the right thing consistently, under pressure, in production.
Why “Answers, Not Guesses” Is a Developer Problem
In dev terms: flaky telemetry is like flaky tests. If engineers don’t trust the signal, they won’t wire it into pipelines, release gates, or automated remediation. Dynatrace is positioning Grail + deterministic analytics as the prerequisite that makes agentic workflows viable, because agents that act on uncertain data create new failure modes.
McConnell also offered a pragmatic adoption model: autonomy doesn’t need to cover everything. He cited a CIO who argued that even partial autonomy (e.g., ~30% of incidents/workloads) could translate into tens of millions of dollars in savings and meaningful UX improvements. That’s an important point for engineering leaders: the KPI isn’t “full autonomy,” it’s measurable coverage of repeatable scenarios.
“Act, Not Just Alert” Signals a Shift From Monitoring to Cloud Operations
Steve Tack framed a common enterprise reality: teams are drowning in telemetry but still “starving for action,” because humans remain the glue across fragmented tools. Dynatrace is trying to pull that glue into the platform via easier hyperscaler onboarding, analytics that surface directly in cloud operations views, and tighter paths from insight to remediation.
A key enabling move here is Smartscape moving into Grail. Dependency graph and topology data are becoming queryable and composable (via DQL), rather than a sealed black box. That matters because dependency context is what turns “an alert” into “a decision,” particularly when you need to understand blast radius and downstream risk.
AI Workloads Force a New Troubleshooting Model
Dynatrace highlighted a real challenge teams are now facing: agentic interactions can be uniquely variable, which makes “what changed?” and “why did this fail?” much harder to answer. The keynote emphasized deeper LLM/agent analytics (model/version comparison, agent interaction visibility) and full-context tracing across the AI stack, from prompt to model behavior to infrastructure performance.
For developer audiences, the implication is straightforward: if you’re pushing AI into production, you’re going to need observability that treats AI behavior as first-class telemetry, not just GPU utilization and latency graphs.
Market Challenges and Insights Driving This Shift
- Trust is the bottleneck to autonomy. Teams won’t delegate action to agents unless the underlying diagnoses are repeatable, explainable, and bounded by guardrails.
- Tool fragmentation is now a throughput tax. Context switching (dashboards, tickets, runbooks, cloud consoles, IDEs) slows incident response and increases cognitive load.
- Telemetry economics are becoming architecture. Log volume and cost pressure pushes teams toward sampling and silos, which directly undermines root-cause and prevention goals.
- AI adds variance and increases blast radius. When every execution can differ, debugging requires stronger correlation across app + model + infra + user experience.
What This Means for Developers and Platform Teams
Dynatrace’s keynote repeatedly pulled observability closer to the developer loop: reduce “alt-tab detective work,” bring production context into developer tools (IDEs/portals were name-checked), and connect release activity to runtime impact (feature observability, with a DevCycle reference). The point is less about “shifting left” as a slogan and more about keeping developers in flow with the right production signals at the right time.
Two concrete takeaways for AppDev and platform teams:
- Expect more pressure to define safe automation boundaries: which incidents are eligible for auto-remediation, what rollback looks like, and how you measure success.
- Expect more cross-functional coupling between engineering and workflow systems (incident/change management). The ServiceNow partnership messaging reinforces that autonomy will be operationalized through governed workflows, not free-running agents.
Looking Ahead
Dynatrace is betting that the next chapter of observability is a platform shift: from visibility to trusted decisioning, and from decisioning to controlled action across an ecosystem. The near-term success metric won’t be whether enterprises “go autonomous” overnight. It will be whether teams can consistently automate meaningful slices of operations such as auto-preventing common failures, auto-remediating repeatable incidents, and auto-optimizing where the risk is low and the ROI is clear.
What to watch post-Perform:
- Evidence that “answers, not guesses” reduces MTTR and improves change quality in real production environments.
- How quickly Dynatrace turns partner integrations (especially ServiceNow) into repeatable closed-loop patterns enterprises can scale.
- Whether AI workload observability matures from tracing and dashboards into actionable, developer-grade debugging workflows that handle variance at scale.
SUSE Introduces a Practical Starting Point for Cloud Sovereignty Readiness
Palo Alto Networks and Chronosphere Signal Observability-Security Convergence
Advancing DevSecOps for Cloud-Native Readiness and Security at Scale
RenderATL Brings OpenJS Summit Into the Center of Modern JavaScript
Scaling Observability and Reliability in the Era of Cloud-Native Delivery
