Enterprise AI is rapidly evolving from standalone models to agentic AI systems, where multiple AI agents collaborate to gather information, reason across data sources, and generate complex outputs. These systems unlock powerful new capabilities, but they also introduce significant operational challenges. Organizations must be able to observe, govern, and optimize AI agents, models, and infrastructure in real time.

Dynatrace helps support this need by providing broad visibility across key layers of the AI stack—from agent orchestration and model inference to GPU infrastructure and enterprise applications. With Dynatrace, teams can monitor AI workflows, understand model behavior, optimize costs, and help improve reliability as agentic systems scale.

Why agentic AI needs full-stack observability

As organizations build GPU-accelerated platforms for AI training and inference, understanding system behavior becomes increasingly complex, with bottlenecks potentially occurring anywhere – from GPU utilization, model latency, token consumption, and downstream service dependencies.

Dynatrace connects these layers through full-stack AI observability, designed to help teams monitor model performance, trace multi-agent workflows, track GPU and infrastructure utilization, detect bottlenecks across AI pipelines, and potentially accelerate troubleshooting with AI-powered root cause analysis.

This unified visibility helps organizations run AI workloads with the same reliability, efficiency, and operational confidence expected from modern enterprise systems.

This unified visibility helps organizations operate AI workloads with improved visibility and operational confidence. By integrating with NVIDIA AI–Q Blueprint and the NVIDIA Agent Toolkit, Dynatrace enriches agent reasoning with high-quality operational telemetry while at the same time helping teams govern and identify opportunities to optimize costs.

How Dynatrace addresses Agentic AI

Dynatrace is designed to assist your team with monitoring infrastructure usage and model behavior and detecting pipeline bottlenecks and token consumption while improving reliability by accelerating troubleshooting and root cause analysis. It also provides a unified view of AI workflows from agent to model down to the infrastructure, allowing organizations to support responsible AI operations, manage cost, improve performance and support agentic workflows at scale.

Every agentic deployment is customized with different agents, tools, models, and data pipelines; therefore, observability is an important capability for understanding how these systems behave in production. The complexity arises as agents interact with multiple enterprise data sources, including:

• internal datasets
• external web and knowledge repositories
• proprietary research systems
• models served through NVIDIA NIM and Nemotron

Dynatrace can serve as operational data source for AI agents that may help improve the quality of generated insights and enable more informed decision-making. With flexible integration across customized AI-Q implementations, this architecture also lays out the groundwork for automated analysis, research, and decision making.

How Dynatrace integrates NVIDIA AI-Q

By combining NVIDIA’s AI-Q Blueprint with Dynatrace AI observability, organizations gain the transparency and operational intelligence needed to govern, optimize, and scale complex AI systems.

Dynatrace integrates into AI-Q environments in two ways.

1. Observability and cost intelligence for Agentic AI workflows

The NVIDIA Agent Toolkit generates lightweight OpenTelemetry traces that Dynatrace ingests to visualize agent workflows and model interactions.

Dynatrace automatically maps the underlying infrastructure supporting AIQ deployments including NVIDIA NIM and Nemotron microservices and enriches telemetry with AI-specific signals such as:

• token usage
• inference latency
• model metadata
• GPU utilization

This provides comprehensive visibility across key components including:

• AI models and inference workloads
• agent orchestration pipelines
• GPU and infrastructure resources
• enterprise data interactions

With these insights, teams can quickly detect performance bottlenecks across agent pipelines, monitor GPU utilization and overall infrastructure health, and identify inefficient model usage. This visibility can help organizations identify cost optimization opportunities associated with AI workloads. Together, these capabilities position observability as important components for building reliable and scalable AI systems.

2. Dynatrace as a high-quality data source for AI agents

Dynatrace can also serve as an operational intelligence source for AI agents.

Through Model Context Protocol (MCP) integrations, Dynatrace exposes telemetry that agents can use in their reasoning workflows, including:

• infrastructure performance metrics
• operational incidents and problems
• deployment and reliability trends
• system behavior and resource consumption

This allows AI agents to incorporate real-time operational insights into their decision-making. Instead of relying solely on external data, agents gain contextual awareness of enterprise systems, which may support more informed outputs Dynatrace ingests NVIDIA Agent Toolkit OpenTelemetry traces, model telemetry, and infra metrics exposing operational context via MCP.

Together, these technologies create a powerful foundation for deploying deep research in the enterprise as reflected in the picture below.

AI-Q use cases

The following are illustrative examples of what becomes possible when AI-Q-based research agents incorporate Dynatrace operational data and insights into their reasoning workflows. While NVIDIA AI-Q is a reference framework rather than a formal certified Dynatrace integration, these scenarios show how agentic research systems could use Dynatrace AI observability to generate richer analysis, identify patterns, and support more informed decisions.

Infrastructure migration analysis

AI agents combine Dynatrace operational telemetry such as performance trends, incidents, and deployment velocity with infrastructure and cloud cost data to evaluate platform migration scenarios (for example, OpenShift to AKS). The system produces data-driven recommendations with quantified tradeoffs to support strategic decisions.

Large-scale incident analysis

By analyzing thousands of historical problems, AI agents can identify recurring patterns, understand infrastructure behavior, and correlate technical issues with business KPIs. This enables deep operational insights and long-form analysis that would be difficult and time-consuming for humans to produce.

AI cost governance and optimization

Enterprises can use observability data from Dynatrace to analyze token consumption, model usage, and inefficient data interactions across AI workloads. Agents can identify patterns and suggest potential optimizations such as more efficient models or improved workflows.

Software delivery and reliability insights

DevOps and SRE teams can use agentic analysis to correlate deployments with incidents, assess build quality trends, forecast reliability risks, and identify engineering priorities—using Dynatrace as the trusted operational data source.

Get started today

• Try the Dynatrace Playground — Explore AI observability with sample data
• Explore NVIDIA integrations in the Dynatrace Hub
• Stream NAT telemetry to Dynatrace — NVIDIA Agent Toolkit OpenTeletemetry guide
• Use Dynatrace as an operational data source — Remote MCP Docs

The post Smarter, safer Agentic AI: Dynatrace observability meets NVIDIA AI-Q appeared first on Dynatrace news.

Organizations are evolving from human-driven operations to supervised autonomous operations, where AI investigates, recommends, and remediates, and humans stay in control of what matters most. A big part of delivering on that vision is working with the agents that customers already run in their cloud environments.

Harness the power of hyperscale agents

Each hyperscaler has AI agents that automatically investigate and help resolve production incidents using native cloud telemetry and tools. They act like embedded site reliability engineers, analyzing issues and recommending or executing remediation steps without waiting for a human to start the process.

AWS DevOps Agent provides investigation and remediation in AWS using native tooling. An Azure SRE Agent specializes in investigating and remediating Azure issues. And Google Gemini Cloud Assist is for incident analysis across Google Cloud Platform (GCP).

Over the past year, we’ve published how Dynatrace supercharges each of these cloud agents individually. When an issue occurs, Dynatrace Intelligence combines causal, predictive, and agentic AI using the Smartscape dependency graph to automatically link related symptoms and root causes across the environment into one unified problem card.

When Dynatrace integrates with the AWS DevOps Agent, dependency-aware root cause analysis combines with AWS frontier-agent capabilities, and joint customers report up to 70% reductions in mean time to resolution. When Azure SRE Agent connects with Dynatrace, deterministic, causation-based AI flows directly into Azure-native remediation workflows, cutting the back-and-forth between teams. And with Google Gemini Cloud Assist, Dynatrace delivers the same production context layer to GCP-hosted incidents: precise root cause, full topology, real business impact.

From integrations to intelligent orchestration

Many enterprises run workloads across AWS, Azure, and Google Cloud simultaneously, and managing three separate integrations with separate routing logic and separate cost controls is its own operational tax. Cloud SRE Agents provides a single orchestration layer that routes problems to specific hyperscaler agents based on configurable profiles to see everything happening across all three cloud agents.

The Cloud SRE Agents app writes findings back to Dynatrace, and provides your team with measurable visibility into autonomous actions.

How Cloud SRE Agents works

When Dynatrace Intelligence detects a problem and identifies the root cause, Cloud SRE Agents calls dedicated cloud-native agents from AWS, Azure, and Google Cloud to retrieve deeper insights from the sources that only they can reach: CloudTrail history, Azure subscription policy, GCP project IAM, recent deployments, and native runbooks. These agents run in parallel, gathering evidence as soon as the problem is detected. Their findings, and, where applicable, the recommended remediation path, are displayed in the same Dynatrace problem view that the on-call SRE is already using in their day-to-day workflow.

One view. No tab-switching. The work starts without you.

Three workflows do the orchestration in the background:

• Investigate evaluates your Interaction Profiles and dispatches matching problems to the right agents in parallel.
• Periodic Tasks polls each cloud provider for completion, detects stalled or timed-out investigations, and writes findings back as problem annotations.
• Event Handlers normalize the cloud-provider event stream so every action correlates back to its originating problem, end to end.

Cloud SRE Agents has the insights and intelligence to decide which agent gets which problem, tracks each run to completion, and brings the answers back together in a single view. The Overview tab provides a real-time, interactive network graph of problems, agents, and activities. The replay view allows the user to step back in time and get an overview of what has happened when, as well as the status of each investigation.

Intelligent routing with Interaction Profiles

In agentic operations, routing rules make the difference between turning autonomous systems loose on every alert and pointing them precisely where they earn their keep. Interaction Profiles are how you express routing judgment in Cloud SRE Agents. Each profile pairs a set of conditions with the agent or agents that should handle the problems flagged by the profile, and evaluates the conditions whenever Dynatrace Intelligence detects a problem.

The conditions you can write are deliberately broad. You can route by the cloud account, subscription, or project an incident touches; by problem category (availability, error, slowdown, resource contention); by affected entity type (a Kubernetes cluster, a database, a Lambda function); by tag, label, or any custom attribute carried in the problem record. Conditions combine with AND/OR logic and nest as deeply as you need, keeping real production routing policy inside the app rather than spilling into custom workflows or scripts.

Three ways teams put it to work

Route problems to the right cloud, automatically

A spike in Lambda error rates belongs to AWS DevOps Agent. An Azure App Service degradation calls for Azure SRE Agent. A Pub/Sub latency issue lands with Gemini Cloud Assist. In a multicloud estate, none of those decisions should fall to a human at 2:00 AM. A profile filtered by AWS Account ID, Azure Subscription ID, or GCP Project ID, then narrowed by resource type or tag, settles the routing question once. Every matching problem is automatically routed to the right specialist with the right cloud-native context.

Optimize spend with budget-aware routing

Cloud AI agents do work, and that work has a cost. Cloud SRE Agents lets you set a Monthly Duration Budget per agent and gate dispatch on it via a Has Available Budget filter: once the budget is exhausted, new investigations either stop (in strict enforcement mode) or proceed with a logged warning. The duration figure itself is a proxy, derived from Dynatrace event timestamps rather than the cloud provider’s clock, which makes it useful as a circuit breaker and directional signal, not a substitute for AWS, Azure, or GCP usage reports. The governance value is what matters: you decide how much autonomous investigation you’re willing to underwrite each month, and the system holds the line.

Tier autonomous investigation by problem type and entity

Not every Dynatrace problem warrants an autonomous investigation. Problem Category filters let you dispatch agents only to the problem categories that warrant it, for example, availability or error problems that require immediate action, rather than slowdowns or custom alerts where human triage might still be the right call. Layer on Entity Type filters, and you can further focus on specific infrastructure tiers (hosts, services, process groups, Kubernetes clusters). The result is a tiered model: high-severity issues receive immediate autonomous investigation, lower-severity signals queue for human review, and your team controls the threshold.

Governance that makes autonomous work measurable

Agentic operations earn trust when teams can see what the agents did, why, and whether it worked. Cloud SRE Agents treats that as a first-class concern, with two views built for the two audiences who care about it.

The Activity tab is the audit trail. Every investigation and mitigation appears as a card on a unified timeline; expand any card to see the agent’s full findings, the evidence it pulled, and the action it took or recommended. Each response can be rated Good, OK, or Bad, building a quality signal grounded in what your team actually saw rather than what the system predicted. When a single problem triggers work across multiple agents, those activities roll up to a single status (in progress, done, or stalled), so you always know where things stand without having to reconstruct the run from individual records.

The Statistics tab is where autonomous operations become a number you can show to a leadership team: problems handled, mitigations executed, average investigation time, MTTR and MTTI trends, success rates, and satisfaction scores broken down by agent. The same view doubles as a directional cost lens, since agent working time is the dominant driver on the cloud side of the bill. Treat the number as a trend signal and a circuit-breaker input, not a billing record (reconcile against AWS, Azure, and GCP usage reports for exact spend), and it makes the case for expanding agentic coverage with evidence rather than anecdote.

Why production context multiplies the value

What changes Cloud SRE Agents from a smart dispatcher into something more is what Dynatrace Intelligence contributes before an agent ever begins its analysis. Dynatrace delivers deterministic, causation-based root cause analysis grounded in Dynatrace’s Smartscape real-time dependency mapping, alongside business impact assessment and correlated telemetry. That context shapes the entire direction of the investigation. A cloud agent arriving with that foundation starts from “this specific service on this specific host is the root cause, and here’s the customer impact” rather than “something is wrong somewhere in this account.”

The numbers reflect it. According to AWS, organizations using the AWS DevOps Agent with Dynatrace see up to a 75% reduction in mean time to resolution.

Western Governors University, which runs a fully online learning environment for 200,000 students, uses AWS DevOps Agent with Dynatrace to automate cross-system correlation that previously required manual effort across multiple tools. At a larger scale, United Airlines transports more than 500,000 passengers daily across a hybrid environment that includes more than 500 AWS accounts, 20,000 Lambda functions, and 38,000 OneAgent deployments.

The team’s description of the before and after status is direct: previously, multiple tools with overlapping functions created gaps and black boxes during troubleshooting. With AWS DevOps Agent and Dynatrace, Dynatrace identifies the responsible layer, the agent investigates and provides resolution steps, and everything surfaces in a single Dynatrace view. No 3:00 AM tool-switching required.

Get started

For a closer look at the individual integrations, read the posts on AWS DevOps Agent and Dynatrace and Azure SRE Agent and Dynatrace, or see how Dynatrace Intelligence powers autonomous operations. To put your cloud agents to work today, install Cloud SRE Agents from the Dynatrace Hub. Cloud SRE Agents is currently available as a community-supported app.

The post Orchestrate multicloud AI agents for autonomous incident resolution appeared first on Dynatrace news.

As more agentic AI projects come online, the observability market is abuzz with familiar promises: tool consolidation, AI-powered insights, and faster remediation through smarter tools. On the surface, this sounds like progress. But beneath the excitement, many discussions are framed around the wrong question.

The real issue isn’t about how to adopt autonomous operations; it’s about ensuring AI agents are operating reliably and resolving problems without introducing new ones. When evaluating new observability solutions, the question should be:

Can this observability solution accurately analyze complex, dynamic telemetry in context so AI agents can act autonomously with trust, precision, and reliability?

As systems become increasingly agent driven, observability is crossing a structural boundary. Approaches designed for environments where only humans decide and act must adapt to a world where agents increasingly operate autonomously with human oversight, while keeping organizations informed.

Rethinking observability for the agentic age

Observability platforms were initially intended to support engineers in delivering reliable applications, services, and infrastructure to users, and alert them in the event of a problem. Dashboards, alerts, and correlation helped teams investigate incidents, piece together what happened, diagnose issues, decide on next steps, and resolve the problem. This model worked when changes were pushed manually.

The assumption was that more data, better correlation, and cleaner interfaces will lead to increased visibility and improved operational decision making.

Agentic AI systems break that assumption.

With faster release cycles and AI-generated code, manual investigations can no longer keep pace. Moreover, observability platforms must now provide actionable insights to both humans and AI agents.

As agents begin operating as autonomous participants in software environments by triggering mitigations, scaling infrastructure, and optimizing behavior in real time, observability can no longer function solely as a human interface. It must also provide AI systems with a reliable, contextual fact basis that agents can act on programmatically. Machines can’t rely on dashboards and alerts. They require a deterministic foundation of unified, real-time data that delivers accurate, context-rich answers at exabyte scale.

Agentic systems break the mold of “good enough”

Many observability platforms layer probabilistic AI on top of siloed data. They use LLMs to correlate signals and rank likely causes—but they can’t always determine correctness.

“Probabilistic” means that the same input will generate a different output based on a probability distribution of predefined outputs, delivering a different answer when the same problem occurs. This approach is also prone to hallucinations, requiring additional human validation, which can increase operational overhead and token costs, delay resolution of business-critical issues, and divert resources from strategic initiatives.

Enterprise-grade observability must now answer: Is this insight reliable enough for autonomous action?

AI built on siloed data is inherently unreliable. Autonomous systems depend on deterministic, contextual, and trustworthy data to act reliably.

“Deterministic” means that the same input always results in the same output by using factual data to trace the exact causal changes that created the issue. When agentic AI systems act on business-critical applications, the cost of being “mostly right” becomes operationally unacceptable.

This is where a subtle but critical divide appears in the market. Aggregating signals and correlating anomalies can surface patterns. Patterns alone are not a solid basis for decisions, and without deterministic understanding, AI systems inherit that uncertainty and can propagate it downstream.

To drive reliable enterprise autonomous operations, AI agents require a unified, AI-powered observability platform that can analyze exabytes of data in real time and across models to pinpoint root cause, delivering actionable answers in context of what’s affected and its business impact.

From correlated guesses to deterministic answers

This shift in the demands of observability hinges on a clear distinction:

• Probabilistic AI correlates signals that happened around the same time and therefore appear related, pulling information from fragmented data stores to propose a likely root cause.
• Deterministic AI uses causal analysis to pinpoint what happened and why, recommend remediation actions, and identify business impact.

Probabilistic AI is intended to narrow the search space and direct engineers toward potential resolution, but it still requires interpretation.

Deterministic AI establishes sequence, dependency, and impact, enabling systems to decide safely without waiting for humans to connect the dots.

Auto‑remediation, auto-prevention, and auto-optimization all depend on this leap. A platform that unifies telemetry only at the UI layer may deliver data and potential root cause, but it can’t compensate for fragmented understanding and missing context underneath. When context is pieced together after the fact, confidence is never guaranteed.

You can’t automate what you don’t precisely understand.

Context driven observability as the control plane for AI

In an autonomous enterprise, observability doesn’t sit beside execution; it’s embedded within it. This integration requires that teams adopt a new mindset toward observability architecture.

Because more AI workloads are happening at the source, telemetry must be optimized and streamlined before ingest, not after the fact, from the edge to the back end. Data access must be unified, context-aware, and always-hydrated on a massive scale. Answers must be explicit, not implicit, and they must be informed by automatic, real-time dependency mapping.

Likewise, intelligence must combine deterministic and agentic AI—not as add‑ons, but as a single reasoning system from ingest to execution.

In this model:

• AI agents can become the primary consumers of observability data.
• Humans can shift toward strategy, architecture, oversight, and exception handling.
• Observability evolves from a reactive lens into a control plane for autonomous operations.

Observability purpose-built for autonomous operations ensures successful agentic AI initiatives

This moment represents an architectural transition, not just an incremental upgrade cycle. Correlation-dependent observability that uses probabilistic AI can be extended, augmented, and rebranded, but it will always carry the limitations of approximation and human validation.

The next era belongs to an observability platform that’s built for machine understanding from the start: a unified, context driven architecture that delivers deterministic answers at machine speed, precision, and scale.

The post Beyond correlation to autonomous action: Why “good enough” observability fails in the age of agentic AI appeared first on Dynatrace news.

The Dynatrace MCP Server is now available in Port via Port MCP Connectors. A single OAuth flow connects it in minutes. Set up Port AI to communicate with Dynatrace, GitHub, Slack, and your service catalog in a single conversation, correlating production signals, code, and ownership in a single agent run rather than three browser tabs and a manual handoff. For incident triage, this turns a multi-tool investigation into a single prompt: just ask Port AI what’s wrong; you’ll get details about the failing service, the error signature, the file and function, and the suspect commit.

Ground every Port AI conversation in live production data from Dynatrace

Port is an agentic engineering platform that platform teams use to organize their software development lifecycle. It gives software and DevOps teams a central place where engineers can find system information, take action on it, and route work across their connected tools, without waiting on IT or operations.

Port AI is the assistant that queries the catalog using natural language. Through Port MCP Connectors, the same chat also reaches external systems, such as Dynatrace, GitHub, and Slack.

Dynatrace complements Port by providing context-rich observability and security insights, right where you need them:

The result: Team members ask a question in the Port AI chat, where they’re already working, and get back complete answers that no single tool could produce on its own.

Incident triage from a single Port AI prompt

The Dynatrace MCP Server provides Port AI with a set of tools it can call during any conversation. For incident triage, the most relevant needs are:

• Query production data. Logs, traces, metrics, and events from across the Dynatrace tenant returned in structured form.
• List open problems. An overview of all active problems on the tenant.
• Get problem details. Root cause, causal chain, and affected entities for a specific problem.
• Get troubleshooting guidance. Relevant troubleshooting guides matched to a problem description.

The full toolset also covers security findings, entity and topology lookup, query generation, forecasting, and more. See the Dynatrace Hub for the complete list. In combination with Port AI, these capabilities turn the Port AI chat into a single place to ask production questions.

The example below walks through the triage of an incident affecting broker_service, a fictional service. The same investigation, done manually without this integration, starts in Dynatrace (where the failing service shows up in seconds), then jumps to GitHub to scan recent commits, to Slack to confirm ownership, and back to a doc to write up the summary. With this Port AI integration, those steps run in a single agent run, with the Dynatrace signal at the center of the chain.

The scenario begins when broker_service degrades and lands as a new incident, INC-1003. In Port AI chat, an SRE asks, “Help me understand the root cause of INC-1003.”

Port AI loads the ai-incident-triage skill and runs the following steps:

1. Resolve the incident in Port’s catalog. Port AI looks up the incident entity and pulls the affected service identifier.
2. Query Dynatrace. The Dynatrace MCP Server queries logs and traces for broker_service. The response carries the first-seen failure timestamp and the top error signature.
3. Find the suspect commit in GitHub. Port AI passes the failure window to the GitHub MCP Server, locates the failing function, and lists the commits to that file. One commit aligns with the first-seen timestamp.
4. Return a structured triage summary. Port AI returns the failing service, the error signature, the file and function, and the suspect commit.
5. Post to Slack and close the loop. The Slack MCP Server posts the same summary to #incident-updates (Figure 2). The incident entity records a triaged_at timestamp through a Port self-service action.

Within a single agent run, the engineer receives a triage summary in Slack that already includes the live Dynatrace signal.

The same Dynatrace integration allows many more use cases, such as deployment correlation, on-call summaries, and postmortem drafts, each built as a Port AI skill.

Security triage works just as easily: ask Port AI about a vulnerability; the Dynatrace MCP Server returns the affected running services, severity, and exposed entities, while Port resolves ownership and routes the fix to the accountable team.

Roll it out across teams, govern centrally

The integration is designed for organization-wide rollout. Admins maintain central control over which tools are exposed and who can access them, while each query remains scoped to the user’s existing permissions.

• Per-tool selection. Admins choose which Dynatrace tools Port AI can call across the organization. Sensitive tools can be scoped to selected groups.
• Per-user authentication. Each user authenticates to Dynatrace through OAuth. Queries return only the data that their existing Dynatrace permissions already allow.
• Audit trail on both sides. Every Port AI call and every Dynatrace MCP call names the same person, with no stitching required between platforms.
• Scales without new workflows. The same per-user model that works for a pilot team works for hundreds of developers. No separate access-request workflow needed.

Get started: connect Port with Dynatrace

The Dynatrace MCP Server connects to Port through a single OAuth flow. Setup takes a few minutes and is done once by an admin.

• Add Dynatrace as a data source. In Port, go to Data Sources > + Data source > MCP Servers. Select Dynatrace, fill in the connector details, and select Connect to authenticate with your Dynatrace tenant.
• Expose the tools you want Port AI to use. Under Allowed Tools, add the Dynatrace capabilities you want available to your organization (querying production data, listing problems, getting problem details, finding troubleshooting guidance). Select Publish.
• Register the incident triage skill. Add the ai-incident-triage skill from Port’s skill library and point it at the incident entities in your catalog.

Once published, the integration is available to every authenticated Port user in your organization. Each user authenticates to Dynatrace individually through OAuth on first use.

For full setup walkthroughs, see Port documentation

Port MCP Connectors documentation: connector setup and admin configuration

Triage incidents with AI: full skill walkthrough

The post Port and Dynatrace: One-prompt incident triage with the Dynatrace MCP Server appeared first on Dynatrace news.

A developer triaging a bug in Jira, or an on-call engineer responding to an alert in Jira Service Management (JSM), can ask their Rovo agent to investigate production issues in Dynatrace using plain language, without leaving Jira or JSM. The Rovo agent answers any relevant questions, calls the appropriate Dynatrace tools, and posts the results back to the Jira workspace. Admins can now complete setup in minutes. Every call runs with the permissions of the requesting user, every action is logged, and data access and cost remain under central control.

Move from “ask the platform team” to “ask the agent”

If your organization uses Dynatrace, much of your production knowledge may reside with the Dynatrace experts on your organization’s platform or SRE team. Everyone else (developers triaging Jira bugs, on-call responders running down JSM alerts, or support engineers handling escalations) either learns enough Dynatrace to investigate production issues on their own or pings the platform team and waits for a response.

The Dynatrace Model Context Protocol Server for Rovo moves this valuable production expertise into the Rovo agent, where it’s accessible to all Rovo users. The Rovo agent holds the Atlassian context (the bug, the alert, the service it relates to) and calls Dynatrace for the production context (problems, topology, root cause). Meanwhile, the developer asking the question gets a usable answer directly in the tool where they’re already working.

How does an on-call engineer use Rovo to triage a JSM alert?

A JSM alert is triggered when a service degradation is detected. The on-call engineer opens the alert’s response panel and asks the Rovo Ops Agent, Atlassian’s built-in AI agent for JSM incident response, to investigate.

Rovo Ops calls the Dynatrace MCP Server, retrieves the open problem, the root cause, and the related signals, and returns a single answer: what went wrong, what’s related, and what to do next. The on-call engineer either acts on this problem context directly or escalates the alert, with the full analysis already attached.

How does a developer triage a Jira bug with Rovo and Dynatrace?

Let’s say Jira provides details of a bug in a service that a developer doesn’t own. The developer asks the Rovo agent a question in the issue’s chat panel: “What’s going on with this service right now?” Rovo returns the open Dynatrace problem, the elevated error rate, and the dependency that’s causing the issue.

Rovo’s answer posts as a comment on the bug in Rovo, so the next person who opens the ticket sees the investigation is already done. From there, the bug typically closes as a duplicate of the active incident or routes to the team that owns the failing deployment, in minutes rather than hours.

How to roll out the Dynatrace MCP Server in Atlassian Rovo

MCP Server setup is a configuration task, not a project. The Dynatrace MCP Server is pre-approved by Atlassian as an external MCP integration and is included with Dynatrace SaaS at no extra cost. In a few clicks, an admin connects Dynatrace using the Rovo admin UI, authenticates against the Dynatrace tenant, and selects which tools to expose. Once connected, the integration is available across Jira, Jira Service Management, and Confluence.

The Dynatrace MCP Server tool set is ready for immediate use, providing data retrieval through Grail, topology and entity context, root cause analysis, active security findings, time-series forecasting, and change-point analysis.

Security, governance, and cost stay under administrator control

Admins keep control over security, governance, audit, and cost on both the Atlassian and Dynatrace sides.

• Per-user enforcement, end-to-end. Every Dynatrace call runs as the requesting user via OAuth 2.1, with authorization based on the user’s Dynatrace permissions. On the Atlassian side, Rovo and Rovo Ops only see the Jira and JSM data that the user is already entitled to see.
• Per-tool selection. From a checklist in the admin panel, administrators choose which Dynatrace tools the Rovo agents in the organization can call. (New tools released later must wait for admin approval before they become available.)
• Audit trail on both sides. Every Rovo invocation and every Dynatrace MCP call names the same person, with no stitching required between platforms.
• Usage and costs are observable in Dynatrace. Tool call volume can be observed with Dynatrace, and costs can be clearly attributed to data owners.
• Adding more Dynatrace users doesn’t increase your cost. Dynatrace consumption is priced on data, not per user, so onboarding more developers and on-call engineers doesn’t instantly impact your billed costs.

Get started with the Dynatrace MCP Server for Rovo now

The integration is generally available. To connect it:

1. In Atlassian Jira or JSM, go to Atlassian Administration → Rovo → Rovo MCP server.
2. Add the Dynatrace MCP Server and authenticate against your Dynatrace tenant.
3. Select the Dynatrace tools you want to expose to your Rovo agents.

Full setup instructions are available in the Atlassian documentation and the Dynatrace MCP Server documentation.

Because the MCP Server is included with Dynatrace SaaS, you can easily set up a pilot program. Just connect the integration for one dev team, allow them access to a narrow set of tools, and then monitor the team’s usage and related costs. The patterns that emerge (which tools are called, by whom, and at what cost) can serve as a basis for a confident wider rollout.

The post Dynatrace MCP Server for Atlassian Rovo: Investigate production problems without leaving Jira or JSM appeared first on Dynatrace news.

If you’ve already wired an AI coding assistant up to Dynatrace, through the MCP server, the Dynatrace CLI (dtctl), or a custom agent you built yourself, you’ve seen your agent have difficulty interpreting data or calling for fields that don’t exist. This makes sense, your agent may be making assumptions based upon training that isn’t relevant. It lacks the skills to understand how to get the best value from Dynatrace. That is where Dynatrace for AI fills the gap.

What are agent skills?

Agent skills are an open format for packaging domain knowledge that AI agents can load on demand. A skill is a folder containing a SKILL.md file with focused instructions, examples, and optional reference material. Compatible agents, such as Claude Code, GitHub Copilot, Cursor, Cline, or others, discover installed skills and load the full content only when it’s relevant to the task at hand.

The net effect: you can install dozens of skills without bloating an agent’s context window. Agents pull in exactly what’s relevant when it’s relevant, and ignore the rest.

Built for agents working with Dynatrace

Dynatrace for AI is a curated set of skills that give an agent the three things it needs to efficiently do real work on Dynatrace:

• Access to Dynatrace data and insights: through DQL queries against Grail®, Smartscape® dependency graph, or problem records.
• Dynatrace expertise: the syntax rules, entity-model distinctions, and query patterns that separate a working query from one that looks correct but returns nothing.
• Task-level starting points: ready-made prompt templates for common engineering workflows, so teams don’t have to invent the approach from scratch.

Skills don’t connect to Dynatrace directly. You have to pair them with the MCP server or dtctl to perform live queries and initiate actions. Together, they turn an agent with generic observability intuition into one that easily extracts value from Dynatrace.

Complement your agent with domain expertise

The first release of Dynatrace for AI agent skills is focused on the workflows that engineering teams run every day:

• DQL fundamentals: covering the pipeline model, core data objects, and when to use fetch, timeseries, or smartscapeNodes to prevent failures that typically come from models trained on generic query-language data.
• Observability across the stack: services, traces, logs, frontends, and problems, each covering the entity model, key fields, and query patterns that make answers correct rather than merely plausible.
• Infrastructure and cloud: covering Kubernetes, AWS, and hosts.
• Platform tasks worth delegating: providing programmatic creation of dashboards and notebooks

Prompt templates for common workflows

Alongside the skills, the repo hosts a small set of prompt templates you can use as structured starting points to invoke the right skills for specific tasks. These save teams from having to design their approach from scratch and make outcomes more consistent across agents and users.

Current templates include:

• Performance regression: walks the agent through comparing RED metrics before and after a deployment, correlating any regression with distributed traces, and summarizing the root cause.
• Daily standup: pulls the last 24 hours of problems, deployment activity, and notable anomalies for a team’s services, so anyone can walk into a standup with the relevant production context already framed.
• Troubleshoot a problem: takes a problem ID and guides the agent through root-cause analysis, including affected entities, correlated events, relevant logs and traces, and creates a structured summary for the incident channel.

These are a starting point, not a ceiling, designed to be forked and shaped to your team’s on-call runbooks.

What Dynatrace for AI is and what it isn’t

Skills and prompts are a knowledge and workflow layer. They don’t connect to your Dynatrace environment, define what actions your agent can take, or set guardrails. That’s the job of the tool you pair them with and your Dynatrace permission model.

The quality of what your agent can produce also depends on the entities your environment is instrumented to capture. Skills help agents ask better questions of data, but they don’t control what data is collected.

Think of this skill as onboarding a smart new hire who already knows software, but needs to learn your platform. The skills are the platform user guide; your observability data is the work itself.

Get started

It’s super simple to install the skills and prompts in one go. Just run:

npx skills add dynatrace/dynatrace-for-ai

…or activate the skills as a Claude Code plugin:

claude plugin marketplace add dynatrace/dynatrace-for-ai
claude plugin install dynatrace@dynatrace-for-ai

Make sure your agent can reach Dynatrace, then try a real agent-skill task. A few good example starting prompts:

• “Compare the error rate of the checkout service over the last hour vs the same hour yesterday.”
• “Are any pods in the production namespace restarting or getting OOM-killed right now?”
• “Use the performance-regression prompt to check the deployment I just shipped.”

The difference in output quality is immediate: fewer corrections, cleaner queries, and answers that accurately reflect how Dynatrace continuously models your environment in real-time.

The Dynatrace for AI project is open source and actively developed. Issues, discussions, and pull requests are all welcome, especially from teams running agent skills against real workloads. We’d love to hear from you.

The post Dynatrace for AI: Teach your AI coding agent how to use Dynatrace appeared first on Dynatrace news.

From generic AI to task‑focused operational agents

Dynatrace ready‑made agents are purpose‑built capabilities that apply Dynatrace intelligence to specific, recurring operational tasks. Each agent focuses on a clearly defined problem, such as explaining why a service is slow, summarizing unusual behavior in an environment, or helping you understand what changed and why it matters. These agents are designed to take a question or a signal based on the exact data that is in your environment and organization and turn it into a useful answer you can act on.

Because Dynatrace agents are ready‑made, there is no need to define prompts, train models, or design behavior from scratch. Each agent already knows:

• What type of input to expect,
• Which Dynatrace signals and context it should use,
• And what output types are most useful for each addressed problem type.

All available ready-made Dynatrace agents can be found in Dynatrace Hub.

Trigger agent actions with Dynatrace Workflows and the Dynatrace MCP Server

Ready‑made agents can be triggered automatically as part of Dynatrace Workflows or available wherever you already work via the Dynatrace MCP Server.

Using agents in Dynatrace Workflows

Dynatrace Workflows lets you run agents in response to events or on a schedule. Instead of manually asking questions about potential problems and remediation steps, the workflow autonomously responds to changes in your environment.

For example, the Kubernetes Troubleshooting Agent runs nine parallel queries for data enrichment, and Dynatrace Intelligence turns all the information into a structured diagnosis. Customize the agents to your needs, including instructions for human approval steps and automated remediation.

The fastest way to get started is with Dynatrace ready-made agentic workflow templates, currently available in a preview release. Instead of building from scratch, you get proven automations that summarize issues, suggest remediation, and deliver insights directly to the tools your teams already use.

Power users can go further by building their own agentic workflows that combine Dynatrace Intelligence actions with any trigger, data source, or integration in Workflows. Use cases range from auto-scaling Kubernetes clusters based on Dynatrace Intelligence forecasts to generating query-cost-optimization recommendations for stakeholders, to virtually any other automation your environment requires.

Using agents through the Dynatrace MCP Server

The Dynatrace MCP Server makes the agents available outside the Dynatrace web UI, without requiring you to deploy or operate any additional infrastructure. You can connect Dynatrace to any MCP‑compatible client in minutes, with no server to install, host, or maintain.

Through the tools exposed by the MCP Server, you can use natural language to query data in Grail®, check system health, and get problem analyses and remediation recommendations. This brings Dynatrace directly into the tools you already use, such as your IDE, Claude Code and Cowork, Microsoft Copilot, Slack, or automation platforms like n8n. The Dynatrace MCP Server also powers integrations with systems like Azure SRE, AWS DevOps, GitHub Copilot, Atlassian Rovo Ops, Amazon Q, and others.

This means agents are no longer tied to a single interface. You can ask Dynatrace questions and get grounded, production‑ready answers wherever you work, using the same agents and intelligence that power Assist and workflows.

Dynatrace Assist: a simple way to test ready-made agents

The quickest way to use a ready‑made agent and see how it works before you start creating a workflow is with . Dynatrace Assist lets you ask questions about your environment using natural language, without switching tools or setting anything up.

A simple way to start is with a real problem you already have. For example, when a service becomes slow, open Assist and ask a question such as “Summarize the open problems and highlight those that need immediate attention.” Assist interprets the question, evaluates the environment you’re working in, and pulls together relevant data and context using Dynatrace Intelligence. Instead of manually navigating metrics, traces, logs, and dependencies, you get an explanation grounded in what is actually happening in your system.

Continuing your conversation with Assist, you can refine the question or follow suggested drill‑downs. Assist supports this as a single flow, helping you move from an initial question to deeper analysis and, where applicable, to next steps. You’re not configuring an agent or defining behavior. You’re simply asking a question and letting Dynatrace coordinate the right intelligence and ready‑made agents behind the scenes.

This makes Assist your lowest‑friction entry point for using Dynatrace agents. You get a concrete result quickly, using the same data and context you already rely on in your daily work.

What’s next?

If you haven’t already, open Dynatrace Playground, or your Dynatrace tenant, and ask Dynatrace Assist a question to see the ready-made agents in action.

The post Dynatrace AI agents begin working for you on day one, and are built to grow with you appeared first on Dynatrace news.

Get immediate production visibility inside Claude Code, the next-gen AI coding assistant from Anthropic. The Dynatrace MCP server can now be used as a ready-to-use connector for Claude Code, Cowork, and Chat. Connect in minutes to query logs, traces, and problems; conduct live debugging from your terminal, and validate AI-first workflows with real data.

Model Context Protocol (MCP) is the standard for connecting AI assistants to live tools and data. The Dynatrace MCP server brings your full observability and security context into every Claude session. This means fewer context switches, less time hunting through dashboards, and better answers that are grounded in what’s actually happening in your environment.

How to connect Claude Code with Dynatrace

Getting started is straightforward. Open Claude, go to Connectors, and search for “Dynatrace.” Install the Dynatrace MCP Server connector, follow the setup steps, and you’re connected.

How Dynatrace MCP Server and Claude give you visibility into your production data

Whether you’re investigating a production issue, reviewing a deployment, or working through a security vulnerability, you can ask Claude in plain language and get answers backed by your actual Dynatrace production data. This is not just documentation summaries or generic guidance, but a real window into production.

Troubleshoot without leaving Claude Code

Let’s say you receive a Jira ticket with details of an error. Instead of switching to dashboards and digging through logs to find out what went wrong, you can now ask Claude. Dynatrace pulls all root-cause information, related logs, metrics, traces, and CPU and memory profiling data from your production environment directly into the session. You can query these details by impact, filter by service, and request remediation suggestions, all without knowing in advance where to look or how to write the DQL query.

This same workflow applies when you’re checking for vulnerabilities in your running workloads, verifying whether a recent deployment introduced regressions, or proactively catching performance issues before they hit production.

You can now also use dtctl, the open source CLI for the Dynatrace platform, in Claude Code alongside the Dynatrace MCP server to manage dashboards, run workflows, and execute DQL from your terminal.

The post Bring real-time production insights into Claude Code with the Dynatrace MCP Server appeared first on Dynatrace news.

What is dtctl?

dtctl (short for “Dynatrace control”) is the open-source CLI for the Dynatrace platform; it’s kubectl-inspired, terminal-native, and designed for both AI agents and humans. Platform engineers, SREs, and developers use it to manage workflows, dashboards, queries, and settings from the command line.

With dtctl, AI agents use the same command line interface and commands that your platform engineers, SREs, and developers use to autonomously manage workflows, dashboards, queries, and settings.

Three ways to connect agents to Dynatrace

Dynatrace offers three access patterns for AI agents and automation, all governed by the same IAM permission system. Regardless of which path you choose, an agent can access only the data and operations permitted by its authentication scopes. The right choice depends on your use case; in practice, most teams use more than one approach.

• MCP (Model Context Protocol): A standardized, schema-driven interface in which every tool call is declared upfront and validated automatically. Agents get structured, predictable interactions while platform teams get strict control over which tools are exposed and a full audit trail of every call.
• API: Access to the full platform surface with maximum flexibility. The API is ideal when you need endpoints that higher-level tools can’t cover. The tradeoff: you build and maintain everything yourself, from endpoint selection to token lifecycle, pagination, and rate-limit retries.
• dtctl (CLI): A terminal-native and composable command line interface that’s built for execution speed, with minimal setup: Just run a command, inspect the result, adjust, and repeat. This offers a natural fit for tight iteration loops, scripting, and agents that need to get things done without overhead.

Why is CLI gaining traction for agent workflows?

CLIs have been the primary interface for automation since the early days of Unix, and for good reason. Output is structured, syntax is predictable, and there’s no protocol overhead. MCP mirrors how humans interact with tools and includes discovery, negotiation, and structured handshakes. This is valuable when you need it; however, every schema negotiation round-trip adds tokens and latency to the agent’s context window. CLI skips that entirely and cuts straight to execution.

Use the same CLI tool and commands for human engineers, scripts, and AI agents

Whether you’re a platform engineer or an AI agent, dtctl gives you the same powerful Dynatrace interface. Like kubectl or git, dtctl follows a simple verb-noun syntax: Just state what it is you want to do, then state what you want to act on. What makes dtctl stand out is that it’s designed to support human engineers and AI agents equally.

• A single interface for everything. Workflows, dashboards, notebooks, queries, SLOs, Dynatrace Intelligence, and more, all accessible through the same consistent set of commands. There’s no need to stitch together multiple API endpoints or learn different tools for different resources.
• Built for AI agents. dtctl lets agents discover all available commands at runtime, no documentation needed, no upfront configuration. When running inside an AI agent, dtctl automatically switches to structured output that agents can parse and act on, including follow-up suggestions and error context.
• Built for humans, too. Use tab-autocomplete resource shortcuts like db for dashboards and wf for workflows, –mine to filter your own resources, and an edit command that opens YAML in your $EDITOR and uploads on save. Because dtctl follows familiar command-line patterns, experienced users move fast from day one.
• Managing multiple environments is simple. Switch contexts between dev, staging, and production with a single command. Authenticate via SSO or API token, run dtctl doctor to verify the setup, and you’re ready to go.

For all technical details and the full command reference, visit the dtctl repository on GitHub.

An AI agent modifies a Dynatrace workflow end-to-end

What makes AI agents truly useful is their ability to close the loop: They can discover data, make changes, verify results, and fix what’s broken all without handing control back to a human operator.

Here’s what such a scenario looks like using dtctl. In this example, a Dynatrace workflow queries the number of Kubernetes pods and sends an email report. The goal is to enhance the query so that it lists every pod with its respective node tolerations, making it a cross-entity query that explores the data model, identifies the correct relationships, and iterates until the output is correct.

Using GitHub Copilot in VS Code, the agent works through the full cycle autonomously:

• Discover: Explores the Dynatrace data model to find the right entities and relationships: how pods connect to nodes and where tolerations are stored.
• Iterate: Refines the query step by step until the output matches the goal, then updates the workflow and rebuilds the email report.
• Apply and run: Pushes the updated workflow to Dynatrace and executes it.
• Verify: Checks whether the workflow ran successfully and produced the expected results.
• Fix: If something fails, it reads the error, adjusts the query, and tries again.

The human operator defines only the intent, and the agent handles the rest. Watch this full video walkthrough to see it in action.

Create and modify dashboards without leaving your code editor

One concrete example of what dtctl enables is dashboard creation and management directly from the terminal. Because Dynatrace dashboards are structured data, they can be version-controlled, templated, and automated just like any other code artifact.

To illustrate this, the OpenClaw Gateway Monitoring dashboard shown below was created end‑to‑end in just a few minutes. A developer used GitHub Copilot in VS Code to create an AI observability dashboard similar to others, tailored specifically for monitoring OpenClaw. The agent then pulled existing Dynatrace AI observability dashboards as templates, adapted the layouts and queries to OpenClaw’s monitoring needs, and deployed the results using dtctl; all this was managed by the developer without leaving their IDE.

For day-to-day management, the workflow remains the same, whether executed by an agent or a human: just pull a dashboard, adjust queries or filters, preview the changes, and save the dashbaord. Coding agents can be instructed to update queries across multiple dashboards with a single prompt. And it takes just a single command to promote dashboards from dev to production, or to roll them back instantly if something breaks.

You can take dtctl even further: wire dashboard definitions into your CI/CD pipeline so that, as a service evolves, its dashboards evolve automatically.

Try out dtctl today

dtctl is fully open source and available at dynatrace-oss/dtctl on GitHub, with documentation, skills, and examples to get you started.

Our dtctl Quick Start Guide walks you through the complete setup in under five minutes:

1. Connect dtctl to your environment.
2. Run your first query.
3. Pull a dashboard.
4. Modify the dashboard queries.
5. Save your dashboard.

From there, install the agent skill to teach GitHub Copilot, Claude Code, or Cursor how to operate your Dynatrace environment.

The project is in active development. If you hit a bug or have a use case to share, open a GitHub issue or start a discussion, and help us shape the roadmap.

The post dtctl: The Dynatrace observability CLI that’s built for AI agents and humans appeared first on Dynatrace news.

What Agent Mode can do with Dynatrace observability data

Once connected with Dynatrace MCP Server, Postman’s Agent Mode works with real runtime data rather than just API requests and responses. When an API test fails or behaves unexpectedly, the agent can correlate the behavior with Dynatrace telemetry such as service metrics, traces, logs, and detected anomalies.

This allows developers to quickly understand whether an issue is caused by the API itself or by what’s happening behind it, such as a slow dependency, a failing backend service, or a recent change impacting runtime behavior. Because this context comes directly from Dynatrace, developers can ask follow‑up questions in natural language and get answers grounded in production data. All of this happens inside the Postman workflow, without switching tools or manually querying observability dashboards.

The result is a faster feedback loop: APIs can be tested, validated, and debugged with awareness of how they actually behave in live environments, not just how they respond in isolation.

Explore Dynatrace use cases with Postman

This integration is most valuable in situations where API behavior needs to be understood in the context of how systems actually run, not just how endpoints respond in isolation.

Common scenarios

Instantly check Dynatrace environment health in Postman

Quickly connect Dynatrace as an MCP server in Postman, set up environment variables, and use natural language prompts to get a real-time overview of open problems in your monitored environment. This streamlines troubleshooting by surfacing actionable issues directly in Postman, saving you time and reducing context switching.

Diagnose and resolve API failures with Dynatrace insights

By running API tests and intentionally triggering failures, you can leverage the MCP server to pinpoint the root causes of errors, such as backend issues or logic bugs, using the real-time insights from Dynatrace. This empowers developers and testers to quickly distinguish between code and infrastructure problems, accelerating debugging and improving application reliability.

Get a holistic application health assessment in Postman

You can ask the MCP server in Postman broad, natural-language questions about the overall health of your application and the services monitored by Dynatrace. The server provides a summary of performance and health across multiple services, highlights slow endpoints, and offers actionable recommendations. This allows you to quickly identify bottlenecks and focus on critical issues, supporting proactive performance management and efficient troubleshooting.

Automate continuous health checks with Postman collections

You can have Postman automatically generate collections that call Dynatrace endpoints on a schedule, enabling ongoing performance and health monitoring between releases. This ensures teams are proactively alerted to issues, supporting continuous delivery and higher service quality.

Reduce guesswork in AI-assisted workflows

AI‑assisted development is only as effective as the context an agent can access. Without reliable runtime data, agents are limited to reasoning from API definitions, test results, and assumptions, making it difficult to distinguish real system issues from surface‑level symptoms.

By connecting Postman’s Agent Mode to Dynatrace through MCP, agents can ground their reasoning in trusted observability data from live systems. This gives the agent access to the same production signals developers rely on today, such as service health, performance trends, errors, and dependencies, rather than relying on inferred behavior alone.

The result is more actionable AI assistance. Instead of guessing why an API behaves a certain way, the agent can explain what is happening in the system and why, reducing false conclusions and improving the quality of recommendations in AI‑driven workflows.

Try Postman’s Agent Mode with Dynatrace

The Dynatrace MCP Server is available in the Postman MCP Catalog and can be connected to Postman’s Agent Mode to bring runtime observability data directly into API workflows.

• Learn more about the Dynatrace MCP Server on Dynatrace Hub

• Try out Agent Mode with the Dynatrace MCP server:

For teams already using Dynatrace and Postman, this is a straightforward way to add production context to AI‑assisted API development. For teams exploring Agent Mode, it provides a practical foundation for grounding agent workflows in real system behavior.

The post Observe API responses to runtime behavior: Connect Postman’s Agent Mode with Dynatrace appeared first on Dynatrace news.

The Dynatrace platform provides expanded data access via the Dynatrace MCP server and several APIs that tie into agentic integrations from our ecosystem, our IDE plugins, CLIs, and Dynatrace® Apps. The Dynatrace MCP server has been a cornerstone of making this innovation available to our developer audience right in the IDE. However, MCP is heavily relying on text-based output. This blog introduces new Dynatrace MCP Server application support, which we’re happy to contribute to the community, upgrading UI capabilities by enabling data visualization. It empowers developers and organizations to build their own agentic platforms and visualize experience data, without relying solely on LLM reasoning.

Why are MCP applications so valuable to Developers?

A picture is worth a thousand words

Charts, color cues, and visual tables are here for a reason. We just need a quick look to determine whether something is right or wrong, and with MCP Apps, those visuals can appear in the same conversation with Dynatrace Assist or when interacting with Dynatrace Intelligence from within Kiro, GitHub Copilot, or any other MCP integration, where we ask questions while avoiding context switching and speeding up analysis and result checking. Once we get the insights we need, we can dive even further into the platform applications with comprehensive context.

For example, during a problem investigation, we observe a spike in requests across all endpoints, especially for the v1/trade/long/process endpoint.

Dynamic visual results

Interactive UIs let users modify results per their needs. With the new visual results, we can filter, pivot, and drill into results without re-issuing prompts; the model and UI remain in sync and continue the conversation with a richer context.

Actionability built in

Visuals can include action buttons, for example, Open in Notebooks, which calls back to the server to drill into the data stored in Dynatrace Grail® unified data lakehouse. You can create dashboards and notebooks directly from any page without changing context.

Human verification

Human involvement in data analysis is one of the factors that differentiate these processes from purely LLM-based solutions. Keeping humans in the loop to validate and interpret results visually is one of the most important factors for organizations that want to maintain control over their data analysis process.

MCP App architecture

MCP extension protocol integration

The Dynatrace MCP Server uses the @modelcontextprotocol/ext-apps library to register interactive UI applications alongside traditional text-based tool responses. This allows the MCP client (such as GitHub Copilot) to extend the standard MCP results with visual capabilities.

Tool-to-UI binding

Tools are registered via the _meta.ui.resourceUri property that links the tool’s output to its visual counterpart. When execute_dql returns results, the host knows to render the associated UI app as well.

Data flow

Structured output parsing

The tool returns results as structured markdown containing metadata and a JSON block. The UI app parses this response, extracting record counts, warnings, and the actual data records.

Real-time client-side rendering

A lightweight TypeScript-based web-app (execute-dql.ts) receives the tool result via the app.ontoolresult callback and dynamically builds an interactive HTML table—complete with sortable columns, hover states, and expandable JSON cells.

Single-file bundling

When using Vite with vite-plugin-singlefile, the HTML, CSS, and TypeScript are bundled into a self-contained HTML resource that the MCP server serves on demand.

See it in action

Take a look at this example video showing an investigation into slowdowns.

In the following screenshots, you can see examples of how data that is structured in a visual way helps us to ask the right questions or continue investigations promptly.

In reviewing error logs, we see frequent errors appearing in easytrade-broker-service.

While analyzing service degradation due to the slowdown, we found that two services were affected for approximately 30 minutes.

What about security?

Let’s call out the elephant in the room: security is a major concern with MCP servers, and adding HTML rendering on top is likely to raise eyebrows.

There are a couple of security measures and best practices in place to protect our users:

1. Dynatrace MCP Apps are always rendered in a sandboxed iframe controlled by the host.
2. Our MCP apps communicate only with the MCP host via JSON RPC. No direct communication with the internet occurs with Dynatrace MCP apps.
3. We make use of battle-tested React components, inheriting all security-relevant features of React.

Get started

Dynatrace MCP Apps is already included in the latest version of our local MCP Server, and will soon be added to our remote server as well. If you’re already using the local MCP server, you only need the updated version, which should be automatically available in your Dynatrace environment. If the update doesn’t happen automatically, or if you aren’t already using the local Dynatrace MCP server, install it via the GitHub MCP registry and start experimenting using the provided quickstart.

To better understand how you can uplevel your AI assistants with live production insights from Dynatrace, read our most recent blog post or explore the Dynatrace Agentic AI ecosystem in Dynatrace Hub.

The post Fueling visual insights with MCP applications for complex data analysis appeared first on Dynatrace news.

Unify cloud resources across accounts, regions, and services into a single, real-time dependency graph

As workloads continue to sprawl across AWS, Azure, Google Cloud, and on-premises data centers, teams are overwhelmed by massive volumes of telemetry and constant change. Simple questions like “What service depends on this?” or “Is this vulnerability exposed?” often turn into hours of manual investigation. Smartscape changes this dynamic by unifying every cloud asset, metadata field, and connectivity path into a single, real-time dependency graph, delivering instant answers and visualizing them in a continuously updated Smartscape view. Instead of hopping between AWS and Azure consoles, platform teams finally get a continuously updated picture of how their cloud environments are truly behaving.

With new AWS integrations, Smartscape now also captures deep configuration data, such as VPCs, load balancers, security groups, subnets, network services, and compute metadata, and models these dependencies as native cloud entities. Unlike any other observability vendor, Dynatrace provides full access to the raw observability data in Grail via Dynatrace Query Language (DQL), unlocking powerful exploratory analytics use cases. Each entity includes the complete unprocessed definition of the cloud service as JSON, covering metadata, resources, configuration, security, and networking details, and tags, making this information fully transparent and directly queryable. This unified model delivers immediate customer value:

• Security posture and exposure analysis: detect publicly reachable endpoints, analyze real security group and network policy paths, and prioritize fixes based on true blast radius and reachability.
• IAM hygiene and drift control: uncover risky role sharing across Lambdas, identify configuration drift across accounts and regions, and validate whether access paths reflect intended policy.
• Cost optimization: identify x86 vs ARM workloads, right-size EC2, RDS, and EBS based on real utilization, and connect cloud spend to actual service dependencies to make safer cost decisions.
• Architecture & multi-account visibility: map cross-VPC and cross-region dependencies, unify runtime topology across all cloud accounts, and eliminate hidden or forgotten resources.
• Operational readiness & risk reduction: understand how misconfigurations or outages propagate through infrastructure and into applications, improving impact assessment and response.

The Clouds app provides comprehensive insights and metadata, including metrics and logs for your services, deep insights into resource configurations and cloud topology, and the ability to leverage your cloud tags for access and visibility. With Clouds, teams can interactively explore and analyze their cloud estate, apply segment filters, follow connectivity paths, and compare environments.

Understand your entire setup at a glance through advanced visual analytics

The new Smartscape app’s domain-specific views turn complex, multi-layered cloud estates into something teams can understand instantly. Visual exploration makes it easier to:

• Understand real, observed connectivity between workloads across VPCs and environments, enriched with cloud networking context such as subnets and security constructs.

• Instantly understand problems and their blast radius with affected entities clearly highlighted.

• Identify hidden relationships or unintended dependencies that spreadsheets or lists will never surface.
• Validate migration plans, architectural assumptions, and segmentation strategies before changes go live.

Create a single source of production truth with flexible views and segmentation across cloud dimensions, including tags, accounts, regions, environments, and ownership.

This visual context is often where the “aha” moments happen, the point where teams finally see how their cloud is structured, where risks live, and where optimizations will have the greatest impact.

Utilize DQL for advanced insights customized and enriched with what matters to you

For deeper investigation or automation, DQL lets teams query relationships, join topology with logs and metrics, and run impact assessments programmatically. These queries can be operationalized through dashboards and notebooks. Learn more about how to utilize the new Smartscape DQL commands to query the AWS topology.

Kubernetes: how Smartscape gives you clarity on fast-moving, complex clusters

Kubernetes environments evolve continuously: pods appear and disappear within seconds, configurations drift, and a single missing reference in a YAML file can cascade into service failures across namespaces, or even clusters. While traditional tools expose fragments of this reality, they fall short when teams need complete answers to foundational questions like what does this depend on?, what changed?, or why did this break?

Smartscape further enhances Dynatrace Kubernetes observability by unifying Kubernetes objects, relationships, and configurations across clusters and clouds into a single, real‑time dependency graph. Instead of jumping between kubectl commands, point‑in‑time UIs, and disconnected dashboards, teams gain a continuously updated, system‑level view of how their Kubernetes environments actually behave.

With enhanced ingest, Smartscape now captures all major Kubernetes object types, including ConfigMaps, Secrets, Ingress, PV/PVC, workloads, services, and namespaces, and stores their full YAML definitions and metadata directly in Grail. Teams can query configurations across clusters and clouds, trace live end-to-end dependency paths, and automatically surface misconfigurations, missing references, policy violations, and drift. What was previously scattered across files and tools becomes instantly explorable context, at a global scale. The value of Smartscape can be felt immediately:

• Faster troubleshooting: trace live relationships across clusters, namespaces, workloads, and services to pinpoint drift or misconfigurations that cause runtime failures.
• YAML misconfiguration detection: identify missing references, invalid fields, or policy violations with full YAML-in-context, and regenerate correct configurations using Dynatrace Intelligence.
• Ephemeral awareness: retain visibility into short-lived workload changes or crashes that normally disappear before engineers can inspect them.
• Policy and compliance enforcement: check networking, storage, config maps, resource quotas, and image standards at the object level for stronger governance.
• Safer releases: segment clusters by team or namespace and visualize impact paths before and after deployments to reduce risk and improve deployment confidence.

All enhanced Kubernetes insights and YAML definitions are directly accessible within the Kubernetes app.

In Smartscape, access the Kubernetes domain view, where you can:

• Visualize cluster topology for instant clarity on structure and relationships.
• Follow real dependency chains across namespaces, workloads, services, and underlying infrastructure to understand impact paths.
• Segment clusters dynamically by team, namespace, environment, or workload identity for precise context.
• Isolate critical workloads or namespaces for focused investigation and remediation.
• Validate architectural assumptions by comparing expected versus actual relationships.

For advanced analytics, DQL lets you query Kubernetes objects, relationships, and signals at scale. For actual use cases and examples, check out this notebook on the Dynatrace Playground.

Other domain-specific enhancements, from infrastructure to services

The new Smartscape unlocks a broader range of high-impact use cases across every layer of your IT environment, with topology-enriched information across apps; many new ways to explore your data via DQL, and several additional, use-case-optimized Smartscape views. Below are some additional examples and inspiration to help you get started:

Services

Smartscape now gives you deeper insight into how services connect and communicate in real time. By modeling upstream and downstream dependencies alongside KPIs and infrastructure anchors, Smartscape makes it easier than ever to understand how services interact, where failures originate, and how changes ripple across the stack.

With the new Service Dependency Graph view, teams can instantly visualize their service landscape. The interactive graph makes it easy to follow call flows, isolate a single service and its direct dependencies, highlight performance or error hotspots, and identify unexpected communication paths. Apply your own business context, for example, ownership, to help teams see how services come together to deliver business functionality.

Infrastructure

Smartscape expands visibility into infrastructure by mapping all running components, showing how they’re connected, and identifying how performance issues might impact other critical services. The Infrastructure Overview turns this into an intuitive, navigable map that lets teams focus on the data relevant to them and spot bottlenecks or drift patterns through topology shape. Building on this foundation, upcoming Dynatrace enhancements will allow teams to visually inspect host‑to‑process chains and explore network paths enriched with SNMP/LLDP data.

Problems

Smartscape enhances problem analysis by automatically connecting detected anomalies to the entities and dependencies they impact across your environment. This shows not only what is broken, but how issues propagate across services, workloads, and infrastructure, giving teams immediate clarity on root cause and blast radius. The Problem Graph highlights affected entities, correlates related anomalies, allows for impact isolation, and provides AI-powered insights in context.

End-to-end discovery

The Smartscape app also exposes your entire digital ecosystem as one coherent model, visualizing all dependencies and connecting cloud resources, Kubernetes clusters, infrastructure components, and services end-to-end in the Smartscape on Grail view. This allows teams to understand the real system structure, uncover hidden dependencies, and validate architectural assumptions with complete context rather than piecemeal data.

Experience the new Smartscape today

Smartscape changes how teams operate by providing automatic, real-time context across all domains, enabling faster troubleshooting, safer releases, stronger security posture, and more cost-efficient operations.

• Explore domain-specific views for AWS EC2, Kubernetes, Infrastructure, and Services, with Azure coming soon.
• Run impact analysis with DQL graph queries.
• Combine topology with logs/metrics/traces/RUM for full stack insights.
• Let Dynatrace Intelligence take safe, informed actions based on production truth.

The post The new Dynatrace Smartscape improves operational efficiency across clouds, Kubernetes, infrastructure, and more appeared first on Dynatrace news.

Dynatrace has surpassed $1 billion in lifetime AWS Marketplace sales and earned the AWS Financial Services Competency—a milestone that reflects expanded co-innovation, deepened AI-powered observability capabilities, sustained triple-digit growth over the past three years, and accelerated customer adoption across global markets.

These achievements build on the advancements announced at AWS re:Invent 2025, including attaining the AWS Agentic AI Specialization, expanding integrations with Amazon Bedrock AgentCore and AWS DevOps Agent, and being named AWS Public Sector Technology Partner of the Year for LATAM.

Here is a closer look at how these milestones advance agentic AI observability and cloud operations for customers on a global scale.

The power of a strategic collaboration that puts customers first

Reaching $1 billion in sales on AWS Marketplace is a testament to the powerful synergy between Dynatrace and AWS. Dynatrace growth in AWS Marketplace sales has surged over the past three years, delivering sustained triple-digit growth.

As enterprises adopt cloud-native procurement to accelerate modernization, demand for Dynatrace continues to expand globally. AWS Marketplace has been instrumental in supporting this growth, enabling Dynatrace to reach customers across industries in over 20 regions through streamlined tax handling, multi-currency support, and other strategic offerings.

“Collaborating with Dynatrace through AWS Marketplace has been transformative for our joint customers,” said Ed Smoke, Vice President of Intelligent Operations Partner Alliances at AHEAD. “The streamlined procurement process and seamless integration of the Dynatrace AI‑powered observability platform with AWS services enable organizations to accelerate modernization with confidence. By leveraging AWS Marketplace, we’ve helped customers align their investments with AWS Enterprise Discount Programs, delivering greater value and efficiency.”

Global scale meets local impact

Enterprises continue to accelerate Dynatrace adoption through AWS Marketplace to streamline procurement, reduce onboarding time, and align spending with AWS Private Pricing Addendum. Customers trust the Dynatrace platform to:

• Simplify procurement, streamlining the buying process to get technology into the hands of teams faster.
• Optimize cloud spend, utilizing AWS committed spend to invest in observability that drives efficiency.
• Scale confidently, deploying Dynatrace across complex, multi-region AWS environments with ease.

These organizations aren’t just buying software; they are investing in a platform that serves as the foundation for their digital resilience. And this streamlined route allows customers to adopt the Dynatrace AI-powered observability platform quickly while maximizing the value of their AWS investments.

“Partnering with Dynatrace through AWS Marketplace has been a strategic win for Storio group,” said Alex Hibbitt, Engineering Director, Customer Platform at Storio group. “The streamlined procurement process, providing efficiency for both our teams and our vendors, has allowed us to quickly adopt the Dynatrace AI-powered observability platform to gain real-time insights across our cloud environments. By centralizing our purchasing through AWS Marketplace, we were able to align our spend with our commitment to AWS, maximizing the value of our cloud investments while accelerating our modernization journey. The Dynatrace platform’s seamless integration with AWS services has empowered us to innovate faster, reduce operational complexity, and focus on delivering exceptional value to our customers.”

Agentic AI is fueling the next wave of innovation

While generative AI remains wildly popular, agentic AI—systems that don’t just generate content but take action—is moving to the fore. In fact, according to the recent Dynatrace research report, The Pulse of Agentic AI, 50% of agentic AI projects are in production for limited uses or departments, and 23% are in mature, enterprise-wide integration. Further, 72% of respondents expect agentic AI budgets to increase in the next year.

Dynatrace recently earned the AWS Agentic AI Specialization—a distinction that validates our deep technical expertise in observing and governing agentic AI systems.
As organizations move from AI experimentation to production, they face new challenges, including how to monitor an AI agent that acts autonomously and how to ensure it stays within its guardrails.

Our expanded collaboration with AWS directly addresses these needs through integrations designed to provide end-to-end visibility into an AI ecosystem.

1. Amazon Bedrock AgentCore Observability

Dynatrace continues to expand deep technical integrations with AWS to support modern cloud‑native and AI‑driven architectures. Dynatrace provides full‑stack analytics across services such as Amazon Bedrock AgentCore and AWS automation pipelines, enabling teams to operate, secure, and scale agentic AI workloads with confidence.

To build agents on Amazon Bedrock, teams need more than just logs—they need context. This new integration provides native, end-to-end observability for Amazon Bedrock AgentCore, enabling developers and site reliability engineers to:

• Monitor agent interactions across various AWS offerings.
• Debug complex workflows by tracing requests from the user to the LLM and back.
• Audit performance to ensure agents deliver accurate, safe, and efficient results.

2. Kiro powers and Kiro Autonomous Agent

Dynatrace is also integrating with Kiro, AWS’s agentic integrated development environment. Kiro leverages deep insights from the Dynatrace AI-powered observability platform to accelerate developer productivity.

Imagine an AI agent that can handle bug triage, suggest code fixes, or even implement features—all while being guided by the precise telemetry data from Dynatrace. This Kiro Powers integration extends observability directly into the developer workflow, enabling:

• Faster root-cause analysis. Agents can autonomously troubleshoot issues based on real-time performance data.
• Spec-driven development. Actionable insights help developers build higher-quality code from the start.

3. AWS DevOps Agent

To further streamline operations, Dynatrace has integrated with the AWS DevOps Agent. This collaboration accelerates root-cause isolation by adding domain-specific AWS context to Dynatrace findings.

The result is autonomous troubleshooting that detects performance degradations, quantifies their business impact, and provides clear remediation instructions. It’s about reducing the noise to let teams focus on solving the problems that matter most.

“By leveraging AWS Marketplace, we were able to align our spend with our AWS Enterprise Discount Program, maximizing the value of our cloud investments while accelerating our modernization journey.” said Luca Domenella from Soldo.

Accelerate your cloud journey with Dynatrace and AWS

Reaching $1 billion on AWS Marketplace is a historic moment for Dynatrace, but it’s just the beginning. The combination of triple-digit growth in AWS Marketplace sales over the past three years, expanded deal sizes, and groundbreaking innovation in agentic AI, Dynatrace is moving faster than ever.

Whether you are looking to simplify your cloud operations, secure your AI workloads, or simply get more value from your AWS investment, Dynatrace is the partner you need. Check out our AWS Marketplace listing to see how easy it is to get started, and contact us today for more information.

The post Dynatrace accelerates a new era of growth and innovation with AWS appeared first on Dynatrace news.

New research from Dynatrace reveals how organizations are adopting agentic AI to drive greater business value through automating operations. But as teams push toward AI‑driven automation at scale, they’re also confronting a core challenge: the variable, context-dependent nature of AI systems makes it difficult to establish the reliability, safety, and governance needed to fully realize ROI.

Context is key for AI systems to avoid losing track of instructions, hallucinating missing dependencies, or misinterpreting evolving system states—especially during extended multi‑step tasks. Some of the technical challenges AI agents present include:

• Context fragmentation: As tasks grow more complex, agents cannot reliably hold, retrieve, or apply the full operational context they need for accurate decisions.
• Unpredictable autonomy: Small gaps or inconsistencies in context can cause cascading errors that affect downstream systems, workflows, and data integrity.
• Lack of verifiable control signals: Without real‑time, fact‑based grounding, agents cannot validate their own assumptions or detect deviations, making it extremely difficult for leaders to operationalize autonomy safely.

These issues explain why agentic AI is accelerating but still challenged to become “production‑ready” without a new foundational layer of observability, governance, and human oversight.

The emerging reality: What the 2026 Pulse of Agentic AI reveals

The 2026 Pulse of Agentic AI is a global survey of 919 senior leaders and decision makers directly involved in or responsible for agentic AI development and implementation. Results show that agentic AI is advancing rapidly but encountering structural barriers on the path to scalable autonomy.

• Agentic AI is moving quickly from experimentation into real operations. Most organizations (72%) now run 2-10 agentic AI initiatives, and 50% have at least some production deployments. Adoption is strongest where reliability and risk sensitivity are highest: IT operations (70%), data processing (51%), and cybersecurity (49%), where automation can deliver fast, measurable gains.
• Maturity is uneven. While investment is rising and expectations for ROI are high—44% have projects in broad adoption in select departments—only 23% have projects in mature, enterprise-wide adoption. The primary blocker is not ambition, but trust. Leaders cite security and data privacy (52%), and technical challenges (51%)—especially limited visibility into agent behavior and difficulty defining when agents can act autonomously versus when humans must intervene.
• AI operations forge a new role for human oversight. Most agentic decisions are reviewed or validated by people (69%), and 44% rely on manual methods to monitor agent interactions—slowing scale and increasing operational risk. These findings make one conclusion clear: agentic AI cannot reach its potential through experimentation alone. Scaling autonomy requires stronger governance, clearer decision boundaries, and real‑time observability that connects AI behavior to system reliability and business outcomes.

From insight to execution: Why AI projects are stalling and how observability enables results

The research makes clear why many agentic AI initiatives stall before delivering full business value.

Leading organizations are already using observability as more than a monitoring tool

Observability is becoming the foundation for scaling agentic AI safely. Nearly seven in ten respondents apply observability during implementation to integrate agents with existing systems, monitor data quality, and detect anomalies. As agentic systems move into production, observability is increasingly used to track agent performance in real time, validate outputs, and correlate AI behavior with reliability, efficiency, and risk.

Observability data alone is not enough

At the same time, the research exposes a clear gap: many teams still rely on manual reviews to understand agent interactions, slowing scale and limiting trust. Respondents consistently point to limited real‑time visibility and weak connections between technical signals and business outcomes as barriers to autonomy.

Observability must become a fact-based control plane for agentic AI

This is the inflection point. Organizations that treat observability as a real‑time control plane—governing decisions, enforcing guardrails, and grounding AI actions in facts—are better positioned to expand autonomy with confidence. The following 90‑day action plan translates these proven practices into practical steps leaders can take now.

A 90‑day action plan for execs and IT leads

Operationalizing agentic AI requires moving deliberately—from experimentation to governed, observable autonomy. The first 90 days should focus on building AI trust, resilience, and measurable business impact.

The bottom line: Autonomy only scales with trust

Agentic AI is here—and it’s accelerating. The organizations that win the next phase of AI transformation will be those that implement autonomy with control to minimize risk:

• Build incrementally, moving from supervised to autonomous operations
• Ground all agent decisions in deterministic observability data
• Redesign human roles to guide, not replace, human judgment
• Treat reliability, safety, and transparency as business‑critical capabilities

With a well‑structured 90‑day plan, enterprises can convert experimentation into operational advantage—unlocking the resilience, scalability, and efficiency that agentic AI promises, while keeping humans firmly in control of outcomes.

The post Building trust in agentic AI: An observability‑led 90‑day action plan appeared first on Dynatrace news.

AI is changing the way we work, from boosting our efficiency and executing tasks on our behalf. As AI enters the agentic era, Dynatrace Assist is your trusted partner for working smarter with Dynatrace. Powered by Dynatrace Intelligence, it helps you solve problems faster and brings AI into your daily workflow.

Today, we’re announcing Dynatrace Assist, our next-generation AI chat that goes far beyond answering questions. It lives where you work, understands your environment, and helps you get real work done with the full power of Dynatrace Intelligence behind every interaction.

Dynatrace Assist is the evolution of Davis CoPilot®, but make no mistake: this is much more than a rebranding. It’s a paradigm shift in capability, outcome, and value.

Your agentic partner helps you gather insights

Dynatrace Assist is where the full power of Dynatrace Intelligence, the new Dynatrace agentic operations system, is available at your fingertips. Instead of moving between dashboards, queries, and tools, you can simply start with the conversational interface: ask a question and let Dynatrace Intelligence do the work.

Dynatrace Intelligence interprets your prompt using generative, causal, and predictive AI capabilities to understand what you’re trying to achieve. Like a member of your team, Assist pulls together context from Grail, maps relationships utilizing Smartscape’s dependency graph, and collaborates in real time with Dynatrace agents. As the conversation unfolds, you move from understanding to exploration—following suggested drill-downs, refining your analysis, and understanding the next steps. This allows for a single, seamless flow from question to insight to execution.

Multi-step reasoning that understands your environment

Assist doesn’t just do what you ask—it thinks several steps ahead. It helps you understand the why, decide what to do, and see what comes next. And all of this is fully transparent, showing you exactly which data backs each decision, so you can trust the recommendations and proceed decisively and confidently.

Under the hood, Assist combines Grail’s unified data lakehouse with Smartscape’s dependency graph, layered with our causal and predictive AI. By leveraging the same tools that are hosted on the Dynatrace MCP Server, Assist can pull insights from any part of your environment and kick off deeper analysis when needed.

From incident to remediation in a single flow

AI on its own is meaningless. AI needs context and data to deliver real value, and you need intelligence that understands your environment and helps you move faster with confidence. Dynatrace Assist is built for exactly that. It works alongside you, sharpening decisions, removing friction from investigations, and accelerating the steps that typically slow teams down.

Let’s look at the following example: when a production issue arises, teams waste precious minutes jumping between dashboards, logs, and alerts to reconstruct what went wrong and determine the next steps.

Investigations start with a simple question like “Summarize all open problems and highlight those that need remediation.” Assist immediately pulls together the evidence. It connects Grail data, Smartscape relationships, and real-time signals from Dynatrace agents to piece together a clear explanation of the issue. Instead of scattered clues, Assist collaboratively guides you in selecting a problem to focus on and recommends how to remediate it. This continuous flow compresses investigation time, reduces MTTR, and gives teams a controlled way to move from insight to remediation without breaking focus.

Explain raw data with actionable insights

Logs, signals, and low‑level data points often require deep domain knowledge to interpret. In large digital environments, that knowledge is spread across different teams, which means understanding what a particular message means, how serious it is, and whether it requires action can easily slow teams down.

When you select a log entry (or another signal in Dynatrace) and ask Dynatrace Assist to explain it, it responds like an expert colleague with the necessary domain knowledge and an understanding of the system’s inner workings. It interprets the data in context, highlights what is important, clarifies the potential impact, and outlines likely causes or sensible next steps. Instead of searching for error codes elsewhere or waiting for someone with deeper expertise, teams get immediate clarity. This turns raw, technical signals into practical guidance and shortens the path from confusion to confident action.

Identify and respond to critical vulnerabilities

Vulnerabilities in your system significantly increase the risk of critical incidents, such as data loss or unauthorized access. When a new vulnerability alert appears, teams need immediate clarity about what it means, which services are exposed, and what actions they should take.

With a series of simple prompts, such as described below, Assist pulls in security findings, maps the impacted components across Smartscape, and identifies the root cause. It guides you through the decision-making process, including proposing a fix to the identified problem. All without leaving Dynatrace or switching between tabs, applications, or tools. This tight loop gives teams a faster understanding, more consistent responses, and a significantly reduced risk window.

Prompts used in this use case:

1. Are there any open threats I need to be aware of?
2. Investigate the SQL injection vulnerabilities and provide more details.
3. Show me input for <<add your vulnerability>>.
4. Give me a fixed query.

Dynatrace Assist is here, and it’s just the beginning

Dynatrace Assist doesn’t replace your expertise; it amplifies it, so you can resolve issues sooner, uncover insights more naturally, and move from intention to outcome with far less effort. It is your gateway to Dynatrace Intelligence, which makes you and your teams more productive, accelerates your operations, and uses the full Dynatrace platform to deliver real outcomes.

Ask. Analyze. Act.

And start today with Dynatrace Assist.

The post Dynatrace Assist: Ask, analyze, and act with Dynatrace Intelligence appeared first on Dynatrace news.

Dynatrace is the first AWS Partner to integrate as an MCP target for Amazon Bedrock AgentCore Gateway, marking a significant milestone in how AI agents interact with enterprise observability systems. This integration demonstrates how the model context protocol (MCP) allows AI agents to securely access real-time system intelligence, unlocking new automation and decision-making capabilities. For developers building agentic AI workflows, this integration opens new possibilities, from querying live observability data and detecting anomalies to empowering agents that proactively respond to system issues with comprehensive monitoring insights.

As organizations adopt agentic AI to automate complex workflows, AI agents increasingly need real-time context to make reliable, safe, and efficient decisions. Amazon Bedrock AgentCore provides powerful capabilities for building and orchestrating agents. The new integration with Dynatrace MCP Server gives agents direct access to the deep, real-time observability signals they need to understand system health, anomalies, dependencies, and performance trends.

Dynatrace unifies metrics, logs, traces, problems, topology, and causal context into a single, real-time source of truth for human operators. With our new Amazon Bedrock AgentCore Gateway + Dynatrace MCP Server integration, your agents can now access these same high‑quality signals programmatically through the MCP.

This gives Bedrock agents continuous visibility into system behavior, allowing them to reason with real production data, detect issues early, validate assumptions, and act intelligently within automated workflows, all through a simple, lightweight integration that includes a Dynatrace environment, a Bedrock account, and a few configuration steps in AgentCore Gateway.

Give your Bedrock agents real-time system awareness

With this integration, agents access high‑quality, causal, real‑time signals that they can query directly through the AgentCore Gateway, enabling them to operate with full environmental awareness. Your agents can access:

• Real‑time service metrics (latency, error rates, throughput, resource consumption)
• Live problem and anomaly feeds (issues detected by Dynatrace Intelligence with full causal context)
• Distributed traces and end‑to‑end execution paths (span data, timing, dependencies)
• Dependency and topology information (Smartscape® entities, relationships, and service maps)
• Logs and event streams (structured logs, events, audit information)
• Entity metadata and health states (services, processes, hosts, cloud resources, statuses)

These signals allow agents to ground their reasoning in real production conditions, allowing for faster diagnostics, proactive adaptation, and more intelligent workflow automation.

What this looks like in practice

Once connected through MCP, your Bedrock agents can request Dynatrace insights using simple natural‑language instructions. For example:

• “Show me any active problems in my environment.”
• “Retrieve the latency for my checkout service over the last hour.”

Use the Dynatrace MCP Server to access insights from Dynatrace Intelligence directly within your agent workflows.

Bringing it all together: the integration architecture

The integration architecture consists of four primary components working together:

1. AI agent: Your AI agent running on Amazon Bedrock, equipped with access to tools and knowledge bases. When the agent needs observability data to make decisions, it invokes the AgentCore Gateway.
2. Bedrock AgentCore Gateway: The AgentCore Gateway acts as the orchestration layer that manages connections to multiple MCP servers. It manages the complexity of MCP protocol handling, request routing, and response aggregation, allowing your Bedrock agents to focus on decision-making logic by receiving requests from Bedrock agents and routing the requests to the appropriate targets—including your Dynatrace MCP server.
3. Dynatrace MCP Server: A specialized MCP server that exposes Dynatrace observability capabilities through standardized MCP protocols. It provides secure, real‑time access to Dynatrace Intelligence and returns structured observability data to the agent.
4. Dynatrace environment: Your organization’s Dynatrace environment, providing root cause analysis, optimization recommendations, and comprehensive observability data across your infrastructure, applications, and services.

How to connect Amazon Bedrock AgentCore to Dynatrace via MCP

This integration is intentionally lightweight and can be set up in minutes. You only need:

• A Dynatrace environment (SaaS)
• An Amazon Bedrock account with AgentCore access
• A few configuration steps in AgentCore Gateway
• (Optional but recommended) A deployed Dynatrace MCP Server

Here’s the high-level setup flow:

1. Set up the Dynatrace MCP Server: Configure your MCP Server endpoint and OAuth 2.0 credentials for secure agent access.
2. Create an AgentCore Gateway: Use the AgentCore starter toolkit, AWS CLI, AWS Console, or SDK to create a gateway with MCP turned on and configure inbound authentication (Amazon Cognito or another OAuth provider).
3. Add Dynatrace as a gateway target: Register your MCP server as a target and map appropriate OAuth credentials and scopes.
4. Connect your Bedrock agent: Connect your agent to the Gateway and verify available MCP tools via listTools.
5. Start querying Dynatrace via MCP: Your agent can now retrieve problems, metrics, traces, logs, and topology directly from Dynatrace.

This integration gives your Bedrock agents direct access to Dynatrace real‑time observability and topology insights, allowing more informed reasoning, safer decisions, and autonomous, context‑aware workflows.

Give your agents direct access to Dynatrace real‑time observability insights. Get started today by exploring the Bedrock AgentCore reference implementation.

The post Fuel Bedrock agents with observability data via the Dynatrace MCP Server appeared first on Dynatrace news.

Agentic AI is no longer a concept—it’s a catalyst for enterprise transformation. According to the Boston Consulting Group, organizations that embed AI agents into workflows, rather than simply bolting them on, are achieving 30–50% faster processes and reducing low-value work by up to 40%. These gains come when autonomy is balanced with human oversight and governance from day one. Dynatrace is facilitating this shift through an agentic ecosystem that connects trusted, real-time production context to AI agents across development, operations, and security.

AI is only as smart as the data it works with and only as effective as the workflows it’s embedded into.

Agentic ecosystem as part of the agentic operations system

With the launch of Dynatrace Intelligence, the Dynatrace platform has evolved into an agentic operations system that provides autonomous, intelligent collaboration across development, operations, and business workflows. It’s uniquely architected to power real-time, autonomous operations by orchestrating both ready-made Dynatrace agents and external ecosystem agents.

Whether it’s invoking a coding agent, optimizing your cloud or Kubernetes infrastructure, or creating a ticket, Dynatrace Intelligence coordinates bi-directional interactions between agents in the agentic ecosystem, including AWS Kiro, GitHub Copilot, ServiceNow Assist, Azure SRE agent, Atlassian Rovo Ops, and many others.

A trusted ecosystem is one where agents and AI assistants in your IDEs, ITSM suites, and other tools can securely connect to Dynatrace to interact with real-time observability and production data in context (metrics, logs, traces, topology, vulnerabilities), reason with causal intelligence, and take actions based on smart workflows—all under your supervision, and designed to achieve the goals you define.

Ecosystem architecture

Our three-layer architecture provides precision, governance, and extensibility, allowing teams to innovate without compromising control.

• Grail®, the unified data lakehouse, and Smartscape®, Dynatrace’s real-time dependency graph, provide the technical foundation, analyzing dependencies across business, teams, services, processes, infrastructure, and more. They ensure that Dynatrace Intelligence acts based on facts, not guesses, and ensure its AI-powered decisions are accurate and actionable, as a prerequisite for autonomous operations.
• The Dynatrace MCP server provides connectivity to the Dynatrace platform as well as the necessary tools for interacting with Dynatrace Intelligence to automate tasks, triage problems, perform risk assessments, or update business workflows.
• Agentic workflows, ready-made agents, and ecosystem agents address real-world use cases: from crash inspection to vulnerability remediation, Kubernetes optimization, or improving developer productivity.

Real agentic ecosystem use cases for developers, SREs, and IT Ops engineers you can implement today

The selected examples below show how AI‑powered, production‑aware workflows remove friction and accelerate real outcomes across development, operations, and security. For more scenarios and use cases showing what you can already unlock with our agentic ecosystem, explore our Dynatrace agentic ecosystem integration blog posts.

AI-accelerated troubleshooting and development in your IDE

Developers often lack immediate access to deep production context when debugging or optimizing services. Moving between terminals, dashboards, and monitoring tools interrupts flow, slows investigation, and forces teams to rely on partial information. This creates delays in identifying issues, verifying changes, and understanding real performance impact, wasting time to understand what’s happening in production. A single incident forces them out of their IDE and into complex tool‑hunting, increasing cognitive load and slowing onboarding and MTTR.

The Dynatrace integration with Amazon Kiro brings real‑time observability directly into the developer’s terminal. Using natural‑language prompts, developers can instantly retrieve live metrics, logs, traces, problem context, and topology insights from Dynatrace without leaving Kiro. This eliminates context switching, accelerates diagnosis, and allows rapid decision‑making in the exact moment developers need clarity. With production‑accurate insights available inline, teams ship fixes faster, understand impact sooner, and maintain high development velocity with minimal friction.

Or use Dynatrace with GitHub Copilot to bring real‑time production insight—logs, traces, root‑cause details, and security context—directly into VS Code. Copilot retrieves precise Dynatrace intelligence through natural‑language prompts, helping developers diagnose issues, validate vulnerabilities, and verify builds without ever leaving their coding flow. The result is immediate troubleshooting, dramatically reduced context switching, faster fixes, and a smoother, more productive development experience.

AI‑assisted SRE operations with autonomous cloud investigations

SRE teams are under constant pressure to maintain reliability across increasingly complex, distributed cloud environments. When a degradation occurs, they must manually trace symptoms across layers, correlate signals from multiple cloud providers, and determine whether the issue is caused by code, infrastructure, configuration drift, or external dependencies. This slows down detection, clouds impact assessment, and leads to long, expensive recovery cycles, especially when incidents span AWS, Azure, or hybrid environments.

Dynatrace integrates with both the Azure SRE Agent and the AWS DevOps Agent to deliver autonomous, context‑aware cloud investigations. When an issue emerges, these agents surface precise, real‑time intelligence from Dynatrace, such as causal root‑cause analysis, dependency graphs, impact radius, service health, and cloud resource anomalies, all directly where SREs work. The agents evaluate the situation, propose remediation steps, and, when approved, trigger automated fixes using Dynatrace workflows or native cloud actions. This eliminates the slow, manual stitching together of cloud and observability data, accelerates root‑cause identification, and allows for faster, safer recovery. SRE teams gain clear, actionable insights within seconds, reduce MTTR dramatically, and advance toward autonomous operations across multi‑cloud environments.

AI‑powered incident management with real‑time production context

Most incident tickets arrive with almost no meaningful context—just a timestamp, a vague description, or a user complaint. Engineers don’t know the severity, which systems are impacted, or what caused the issue. They waste precious time switching between monitoring tools, dashboards, and logs just to piece together the basics. This slows response times, drives up costs, and keeps MTTR far higher than it should be.

By integrating Dynatrace with Atlassian’s Rovo Ops agent, you get real‑time production insights directly into Jira Service Management. Dynatrace automatically detects problems, ties them to their causal root, maps dependencies, and understands impact across the entire ecosystem. This context is then surfaced directly in Service Manager, with no tool‑switching required. Engineers instantly see what’s happening, who’s affected, and the actions needed to resolve the issue. The result is dramatically faster diagnosis, smarter remediation, and a significant reduction in MTTR—all powered by live, trustworthy production context delivered exactly where teams work.

AI success is about people and processes

Adding agents to legacy processes won’t deliver meaningful outcomes. Successful agentic AI projects require real transformation, not just technology adoption. Such a transformation needs a strong and trusted foundation. A platform that provides trusted, contextual data ready to support enterprise-level requirements for agents to make the right decisions and act intelligently, and trusted ecosystem partners.

Together, Dynatrace provides reliable agentic AI-powered observability, helping organizations build more resilient applications and deliver better customer experiences.

How to get started

Identify a developer or small team to get started. Connect your MCP client with the Dynatrace MCP Server, get inspired by recent agentic ecosystem blog posts covering use cases for developers, SREs, and IT Ops engineers, or have a look at our documentation to learn more.

Go to Dynatrace Hub to connect to Dynatrace MCP server.

The post Dynatrace agentic ecosystem: Drive real outcomes, not AI pilots appeared first on Dynatrace news.

The whole industry is using and adopting agentic AI. In fact, AI agents are only as effective as the data that powers them. Whether supporting developers through code assistants, accelerating ITSM workflows, automating cloud operations, or enhancing threat detection, you need high-quality data with full context awareness. Only this allows AI to be a trusted and effective partner, delivering reliable recommendations based on a deterministic foundation. The Dynatrace MCP Server, as part of Dynatrace Intelligence, allows AI assistants to interact with Dynatrace and access live, context-rich observability data and reliable AI-insights for smarter, autonomous operations.

Get real-time insights from your digital systems right inside your processes

In traditional IT monitoring, fragmented data and manual tagging were inconvenient. In an AI-native world, they’re a fundamental flaw. AI systems built on incomplete or disconnected data can’t make informed decisions, leading to unreliable recommendations or, even worse, unreliable autonomous action—a scenario that keeps executives on edge.

Dynatrace Intelligence, the agentic operations system built into the Dynatrace platform, solves this with a real-time, deterministic, and context-rich understanding of your entire digital systems.

The Dynatrace MCP Server, as part of Dynatrace Intelligence, provides a secure and governed interface that allows your AI ecosystem to interact with the Dynatrace platform and access data and findings powered by Dynatrace Intelligence. It uses the Model Context Protocol (MCP), an open standard that defines and handles safe interactions between agents, external data sources, and tools.

Together, Grail and Smartscape provide the technical foundation for Dynatrace Intelligence to let agentic AI act on facts, not guesses, ensuring that AI-powered decisions are accurate, scalable, and actionable, a prerequisite for reliable autonomous operations.

By exposing Dynatrace’s unique capabilities, the MCP Server delivers trustworthy, real-time knowledge directly into agentic workflows. This includes:

• Contextualized signals with a holistic understanding of every data point within its full operational and business context, provided by Grail, Dynatrace’s AI-optimized, unified data lakehouse.
• Real‑time topology and causal dependencies, powered by Smartscape, a real-time dependency graph that reveals how systems, services, and cloud components relate and influence one another.
• Deterministic, causal‑AI‑driven root‑cause analysis with correlation to real business impact.

Empower your AI agents to deliver greater value through live production data

You can connect Dynatrace to any MCP client in minutes: no server to deploy, install, host, or maintain. Use the Dynatrace MCP Server to accelerate integration and ensure a smooth transition from pilot to enterprise-scale adoption.

Through the tools hosted on the Dynatrace MCP Server, you can use natural language to query all your data on Grail, check system health, and get problem analyses and remediation recommendations. This allows seamless access to production insights across the applications you already use, including your IDE, Microsoft Copilot, Slack, and automation platforms like n8n. The MCP Server powers numerous more integrations: Azure SRE, AWS DevOps, GitHub Copilot, Atlassian Rovo Ops, AWS DevOps Agent, Kiro, and Amazon Q, to name just a few.

For customers exploring their own tailored solutions, the community-driven local MCP Server is also available. It already sees wide adoption as a flexible way to experiment with new use cases, adapting the MCP to specific needs, and prototyping ideas before moving them into production.

Where the MCP Server delivers value

The Dynatrace MCP Server brings production truth directly into development, operations, ITSM, and business workflows, allowing AI assistants to reason, decide, and act with full contextual awareness. Examples include:

• Development workflows: In-IDE access to live production signals, root causes, exceptions, impacts, and even code-level stack traces, for example, GitHub Copilot querying Dynatrace data in natural language to validate changes and accelerate fixes, with no tool switching required.
• Operations & SRE: Real-time context for accelerated triage, proactive remediation, and evidence-rich postmortems, for example, the Azure SRE Agent integrates with the MCP Server to diagnose anomalies and trigger automated responses.
• ITSM & Incident Management: Enriched tickets with topology, dependencies, business impact, and AI-driven recommendations, for example, Atlassian Rovo Ops delivers end-to-end, context-aware incident management.
• Business Intelligence: Live production insights for product, sales, support, and process teams to link system behavior to customer and business outcomes, provided through MCP clients like Slack, Microsoft Copilot, or ChatGPT.

The Dynatrace MCP Server is now generally available

Dynatrace Intelligence provides insights grounded in real-time topology, deterministic causal analysis, and deep semantic understanding of your environments. Every recommendation is rooted in precise, explainable, and actionable production truth, giving AI systems the reliable foundation they need to operate safely and autonomously.

The Dynatrace MCP Server brings contextualized observability data and insights from Dynatrace Intelligence directly into your broader AI ecosystem.

Connect Dynatrace to any MCP client and start using it in minutes.

You can work with widely available MCP clients such as Microsoft Copilot or ChatGPT, integrate the Dynatrace MCP Server into your ITSM and incident management workflows through ServiceNow or Atlassian Rovo, bring production context directly into VS Code or other IDEs, or orchestrate automated actions through workflow tools like n8n or Copilot Studio.

Explore real-world examples in our latest blog post on the AI ecosystem, or explore all Dynatrace AI ecosystem-related announcements.

For details on configuring the Dynatrace MCP Server, go to our documentation.

The post Dynatrace MCP Server: Empower your AI assistants to interact with Dynatrace and access live production insights appeared first on Dynatrace news.

The agentic era has arrived, bringing together human insight and autonomous intelligence in entirely new ways.

The pressure is high for enterprises to become “AI-first,” but as we explored in our inaugural Agentic AI Research Report, most organizations are stuck in pilot-mode. Many are struggling to achieve meaningful outcomes, even as they invest ever more heavily on AI.

AI success requires a shift in how we think about operations. We’re moving from a world of manual changes and troubleshooting to one of autonomous systems. Observability tooling needs to adapt to this new reality. It’s not enough to merely provide insights into a system. Organizations need platforms that enable agents to act upon intelligence safely and reliably. That’s why Dynatrace has evolved into an agentic operations platform that enables autonomous, intelligent collaboration across development, operations, and business workflows.

At our flagship event Perform 2026, we’re expanding our platform to deliver the following capabilities that will carry organizations into the human + AI collaboration era.

Dynatrace Intelligence: The new foundation for reliable agentic AI

Organizations struggle with the growing complexity of cloud and AI‑driven digital ecosystems. Leaders have valid concerns about hallucinations, unreliable multi‑step agent workflows, and the inability of off-the-shelf models to process petabytes of heterogeneous observability data.

The solution isn’t to throw more AI at the problem and hope for the best. Simply adding AI agents to legacy workflows doesn’t work. Closing this gap requires an AI system that doesn’t just bolt onto workflows but rethinks how decisions are made and actions are automated.

Dynatrace Intelligence is an agentic operations system at the core of the Dynatrace platform and serves as the reasoning and decision-making layer for all the agentic layers built upon it. It fuses deterministic AI with contextual analytics to ground agentic decisions in real‑time facts and to create more reliable agentic workflows. It also coordinates different kinds of agents while minimizing hallucinations so organizations can trust automated actions.

The new Smartscape®: A source of truth for AI

Modern IT teams often operate with only a partial understanding of what’s running in their environment, especially as cloud‑native architectures, Kubernetes, and adaptive AI agents expand and shift at runtime. You can’t troubleshoot, secure, or optimize what you can’t see. This incomplete picture slows incident response, drives misaligned investments, and increases risk.

The new Smartscape® real-time dependency graph creates a shared, real‑time source of truth that both humans and AI agents use to understand what is actually happening across the environment and to act with confidence. It provides a precise, always‑current view of every entity and dependency in your digital ecosystem, including cloud and Kubernetes objects, domain‑specific metadata, and agentless cloud‑discovered components. The new Smartscape® capability underpins Dynatrace Intelligence, providing the context needed to empower teams and agents to act with confidence, using real‑time topology to detect changes, assess impact, and respond automatically.

From reactive to proactive with agents

Far too many IT teams are forever stuck in firefighting mode. They’re so busy troubleshooting existing systems that they have no time to understand why issues keep recurring or how to prevent them. Signals flood in faster than humans can interpret them, incidents surface without context, and critical decisions must be made with only fragments of the real picture. In this chaos, teams are forced into reactive loops that drain capacity, slow innovation, and make reliable operations nearly impossible.

Dynatrace Intelligence Agents are designed to break this cycle. Whether you use our own ready-made agents or build your own, the Dynatrace Intelligence agentic ecosystem provides the capabilities to continuously detect changes, assess impact, and automatically respond to emerging conditions, helping organizations shift from firefighting to proactive operations.

This is how the Dynatrace platform goes beyond insight, advancing to autonomous action by auto-remediating, auto-preventing and auto-optimizing.

Dynatrace Assist: Your portal into the agentic universe

Modern IT teams aren’t lacking in data or metrics. The problem is that they must jump between different dashboards, tools, and consoles to understand their systems and find the information they need. This slows investigation, increases cognitive load, and leads to delays, misdiagnoses, and inconsistent decisions.

We’re launching Dynatrace Assist to eliminate this constant context switching. Assist brings the full power of Dynatrace Intelligence to your fingertips. Instead of moving between dashboards, queries, and tools, you simply start by asking a question and let Dynatrace Intelligence do the work. Assist pulls together context from the Dynatrace Grail® unified data lakehouse, maps relationships utilizing the Smartscape® real-time dependency graph, and collaborates in context with Dynatrace agents.

As AI becomes a collaborative partner rather than a separate tool, Assist provides the conversational interface that brings agentic intelligence directly into human workflows—reducing cognitive load and enabling natural, real‑time co‑reasoning.

End-to-end intelligence with next generation Dynatrace RUM

Even the smartest agentic systems need to understand how real users experience your applications. Backend signals alone can’t reveal where friction occurs, how users navigate modern single‑page and mobile experiences, or which issues matter most to the business.

The next‑generation Dynatrace Real User Monitoring closes this gap with Grail-powered analytics that unifies frontend behavior with backend intelligence. It automatically captures modern user interaction patterns and couples them with precise, real‑time system insights, enabling teams and agents to detect issues faster, prioritize what truly impacts customers, and optimize digital experiences with confidence.

Dynatrace MCP Server: The connective tissue between agentic systems and Dynatrace Intelligence

Modern AI assistants and automated workflows are being asked to make high stakes decisions without access to the complete, real-time context of the systems they’re meant to support. Fragmented data, disconnected telemetry, and incomplete understanding of how services relate prevent AI from making reliable recommendations or taking safe autonomous actions.

The Dynatrace MCP Server provides the governed bridge between AI ecosystems outside of Dynatrace and the production‑grade insights generated by Dynatrace Intelligence. Using the open Model Context Protocol, it delivers real‑time insights directly into agentic workflows. This gives autonomous agents and other AI tools the observability truth they need to reason accurately, take decisive actions, and operate safely at scale.

Building the future of autonomous operations

Perform 2026 marks a turning point for agentic AI Adoption. We’re shifting from human‑paced management of systems into a world where systems anticipate, adapt, and advance on their own. For the first time, organizations can operate with an intelligence layer that doesn’t wait to be directed but collaborates, reasons, and evolves in real time. Teams will finally be able to focus on the work that moves them forward, rather than the work that holds them back.

The post Dynatrace introduces a new foundation for agentic AI at Perform 2026 appeared first on Dynatrace news.

Key takeaways:

• Perform 2026 will demonstrate how blending human creativity with agentic AI unlocks new levels of business impact to thrive in the agentic AI era.
• Attendees will gain actionable strategies for moving stalled AI pilots to scalable, high‑value AI adoption.
• Perform will reinforce how Dynatrace drives competitive advantage in the age of autonomous intelligence for every practitioner, leader, and partner.

______

Perform 2026 will be held January 26–29 at the Venetian in Las Vegas. If you’re unable to join us in person, be sure to register to attend virtually—or view sessions on-demand afterward—so you don’t miss out.

Ahead of the event, we released the Agentic AI Research Report, an inaugural global study focused on how observability and reliability determine the successful operationalization of agentic AI. Its key findings set the stage for Perform 2026:

• From pilot to production: 72% of organizations are now using AI agents for IT operations and DevOps, with rapid growth in customer-facing and non-IT applications.
• Top challenges: Security, data privacy, reliability, and the need for robust observability as a control plane remain critical hurdles.
• Human + AI collaboration: Success depends on intentional human oversight, resilience, and real-time decision-making—underscoring the vital role of observability in scaling agentic AI and autonomous operations.

At Perform 2026, these insights come to life through mainstage keynotes, deep-dive sessions, and real-world success stories, all focused on helping organizations harness AI with confidence and trust.

Be sure to check out the full agenda to find out what you’ll learn. Here are a few highlights:

Succeeding together in the age of AI

Dynatrace CEO Rick McConnell will set the stage Wednesday by outlining how enterprises can advance toward autonomous operations and shift from reactive problem‑solving to preventive operations—a model where intelligent systems anticipate issues before they impact the business. He’ll share his vision for how organizations can partner with platforms designed to harness real‑time, contextual data to operate with greater precision, speed, and resilience.

Rick will also highlight the essential role AI‑powered platforms play in elevating operational maturity across modern digital ecosystems. As teams face growing complexity and mounting pressure to deliver reliable, scalable services, he will show how the Dynatrace platform helps unify data, automate decisions, and empower people to focus on higher‑value innovation rather than manual firefighting.

Also on Wednesday, CTO Bernd Greifeneder will detail how real‑time intelligence rooted in contextual data and causal reasoning enables organizations to understand their digital ecosystems with greater clarity and act with precision at scale. Just as importantly, Bernd will spotlight the growing importance of agentic collaboration, showing how AI agents, human expertise, and the broader partner ecosystem accelerate innovation when they operate as a unified system.

Empowering people: The human + AI workforce

On Wednesday afternoon, Chief Transformation Officer Colleen Kozak and Chief AI Officer Sol Rashidi will explore how organizations can build a workforce where humans and AI strengthen each other. Their sessions focus on the operating models, governance structures, and data foundations required to make agentic AI reliable at scale.

They’ll also discuss how to prepare teams for this new era and a practical path toward a workforce that thrives in the agentic world.

On Thursday, a fireside chat with gold medalist, innovator, and entrepreneur Shaun White will bring an additional lens to the theme of human achievement, showing how AI collaboration helps people reach new heights, whether in sports or in business.

Customer success stories: Transforming operations with AI

Across industries, customers are already proving what’s possible when intelligent systems and human expertise work together. This year’s lineup will share the lessons they’ve learned, including:

• United Airlines: Head of IT Operations, Observability, and Engineering Ramiro Zavala will share how they achieve end‑to‑end business observability to keep complex digital experiences running smoothly for millions of passengers.
• Princess Cruises: VP Cloud, Infrastructure, and Cloud Engineering Operations Rick Lapenna will discuss how AI-powered observability helps the company deliver operational excellence and frictionless customer experiences.
• Macquarie Group: Head of Reliability Phillip Grasso-Nguyen will discuss how observability drives reliability and success throughout the company, including their AI workloads.
• TELUS: Principal SRE Dana Harrison and Director, Site Reliability and Engineering Enablement Kulvir Gahunia will talk about Black Friday, their biggest day of the year, and how Dynatrace drives success by acting as the common language between the business level and the practitioners deep in the data.
• Autodesk: Senior Director of Engineering Alex Bicalho will unpack how AI-powered observability empowers greater automation and productivity for a development team of thousands.​
• Vodafone: Head of Engineering and Transformation Luke Bradley will explore how Vodafone moved from their traditional log monitoring solution to an AI-powered observability strategy.​
• Visa CashApp Racing Bulls Formula One Team: Peter Bayer, VCARB CEO, returns after one incredibly eventful Formula One racing season to unpack successes the team is seeing at both the data and AI-powered insight level and on the track.​
• Nationwide Building Society: Head of Service Operations Kate Bristow will explore how observability builds trust and brings business and IT together.

Partner focus: Driving innovation and value together

No company is an island. We’re working with partners from across the industry to build an ecosystem that meets the diverse needs of our customers.

Here are some of the partners you’ll find leading sessions at Perform 2026:

• AWS: Showcasing real‑time developer‑focused observability inside the IDE with Kiro powers, plus autonomous troubleshooting and issue resolution using the AWS DevOps Agent integrated with Dynatrace.
• DXC: Covering how organizations can simplify hybrid‑environment complexity through deep observability adoption, and how integrating Dynatrace with ServiceNow enables predictive, self‑healing, autonomous IT operations.
• Accenture: Providing best‑practice integration patterns for Dynatrace + ServiceNow to advance AIOps maturity, alongside guidance on building business‑journey dashboards that reduce MTTX and connect business and technical insights.
• AHEAD: Demonstrating how Dynatrace and ServiceNow come together to enable closed‑loop, autonomous IT operations, along with practical AIOps strategies for reducing noise, accelerating incident response, and scaling Dynatrace adoption across the enterprise.
• Microsoft: Highlighting 2026 product innovations and deeper Dynatrace–Fabric integration, plus broader updates across the Microsoft ecosystem that strengthen intelligent observability, cloud transformation, and AI‑first operations.

Other partners offering sessions include: SteadyBit, Tricentis, Red Hat, CDW, Crest Data, Nutanix, RHONDOS, ServiceNow, and Google.

Developers @ Perform: Built for people who ship code

Modern teams ship fast. Sometimes really fast. And when you’re pushing code every day, there’s not always time to slow down, experiment, or learn from what just happened. Most of the hard problems developers deal with—understanding how systems actually behave, catching issues early, working across teams—start way before production and change with every commit.

Developers @ Perform is a mix of familiar conference formats and more interactive, hands-on experiences. You’ll find structured talks when it makes sense, quick lightning talks when a story is best told in five minutes, and plenty of time to get your hands on a keyboard and build. You can pick up ideas in a lightning talk, then turn around and try them yourself in your IDE:

• The Developer Lab, a self-service environment where you can explore MCP, agentic AI, vibe coding, and cloud-native observability at your own pace.
• Vibe Coding activities powered by GitHub Copilot, a hackathon-style experience with guided sessions designed to encourage experimentation and creative problem-solving.
• Community recognition and open source discussions around OpenTelemetry, OpenFeature, cloud-native architectures, and AI-assisted development practices.

The post Human creativity meets agentic intelligence: Your guide to Perform 2026 appeared first on Dynatrace news.

Imagine commissioning le Carré and Fleming to build your perfect undercover agent: quietly embedded in the system you’re watching. You hand in your mission brief, which includes the target, objective, and behaviors to track. Your agent observes without drawing attention, reporting insights back to you. On cue, the information flow you’ve carefully orchestrated turns signals into actionable intelligence that helps pre-empt risk.

Dynatrace doesn’t write spy fiction. However, even better, Dynatrace now lets you write your own smart agentic workflows that deliver intelligent reports and react to changes in your environment based on your objectives.

Adding generative AI to your workflow

Using the power of gen AI, Davis CoPilot® transforms your workflows into agentic instructions. Davis CoPilot lets you explore data using conversational language, translating complex data and queries into summaries, and provides intelligent recommendations across Dynatrace.

Integrated into Dynatrace Workflows, Davis CoPilot is your toolkit for building smart automations, bringing the power of generative AI into your mission-critical workflows.

By embedding Davis CoPilot in your workflows, you can associate any automation with any number of conversational automations. Your workflows can even perform actions autonomously when combined with precise Davis® AI forecasting, for instance, scaling resources based on forecast demands.

In real time, these workflows monitor live data, summarize critical issues, and identify remediation paths or emerging threats. When scheduled, these smart workflows help you outsource routine tasks, such as alerting stakeholders of costly queries.

Let’s look at some examples of how these smart workflows can help you in your daily work.

Build agentic workflows that respond to critical events

Proactive guiding through complex problem remediation

Let’s assume you want to build an automation that cuts through alert noise and analyzes a problem as it occurs, guiding you through the remediation. When a new problem is detected, Davis CoPilot extracts the problem details, summarizes the situation, and provides tailored remediation guidance. By embedding it into a smart workflow, you can select your preferred automation to automatically syndicate this information, populate a ticket in ServiceNow or Jira, or post it to a dedicated Slack channel.

See how you can set up a workflow automation that automatically sends summaries and remediation guidance when a new problem is detected.

Monitor emerging threats to help you orchestrate a response

Next, you can build an agentic workflow that helps you monitor emerging threats and assess their risk to your environment as vulnerabilities are detected in your tenant. In plain language, you instruct your agent to extract IOCs, query security events in your environment, and correlate them with observability data in your environment. Information provided by the external threat feed is automatically matched against the live context in your tenant. The agent has now collected all the necessary information and provides a reliable risk assessment, along with a plan to orchestrate a response, directly in your Slack channel, ensuring around-the-clock visibility and a rapid response.

Write the future: Build an agentic workflow that autonomously auto-scales your resources

Dynatrace helps you build agents that reason autonomously. The key is to deliver data as precise as Dynatrace forecast capabilities. In this example, we linked the power of Davis AI to forecast demand, with generative AI and GitHub automations. Davis AI predicts the number of resources the hyperscaler infrastructure will need based on forecasted demand. When Davis AI notices a scaling need, Davis CoPilot interprets the data and autonomously edits the manifest using the GitHub automation. Giving you one end-to-end workflow that automatically scales resources up or down based on forecasted needs. To see this in action, watch how this workflow autonomously edits a manifest based on Davis AI suggestions to auto-scale a Kubernetes cluster.

Schedule agentic workflows to optimize routine tasks

Do you feel like sleeping in a little later? Maybe stretching your lunch break a little longer? Running that extra hill without sacrificing your productivity? Scheduling Davis CoPilot into your smart workflow is a great way to automate recurring tasks and save time.

Build an automation that predicts resource consumption

A recurring challenge for SREs is analyzing the full environment to predict future bottlenecks or over-resourcing and continuously translating the data to update stakeholders. Even with great observability in place, you need to ensure that you interpret the data and make timely decisions to inform future provisioning.

By combining Davis AI forecasting automation with Davis CoPilot, you can build an agent that answers key questions, such as which workloads are most resource-intensive, which resources show the most variance, and which require frequent scaling. This automation is capable of highly reliable forecasts, even when data points are limited. The automation interprets the data and emails actionable recommendations directly to you and anyone else who needs to stay informed.

To see this in action, watch the section of this video that explores predicting resource consumption.

Smart workflows that optimize query costs

Scheduling tasks can even help you keep costs lean and efficient. For admins or budget owners, staying within financial limits while maintaining performance is a constant challenge. In this example, we built a smart workflow that identifies the top 20 most expensive queries from the last 24 hours. Davis CoPilot analyzes each query and sends optimization recommendations directly to the query authors via email.

To implement this yourself, tailored to the most expensive queries executed on your tenant, go to our documentation

Conclusion: Adapt your workflows to any stage of your automation journey

These are just a few examples; the applications for it are endless. We’ve designed this workflow action to cater to your organization’s automation appetite. You may want to transform how you keep business stakeholders informed about what’s happening in your environment, leveraging Dynatrace’s highly accurate insights, which are translated into plain language and actionable next steps.

Alternatively, you may be ready to transition towards autonomous operations, where automation not only supports but also acts in a controlled and reliable manner. Davis CoPilot embedded into your workflows opens the door to your agentic journey.

Start your agentic journey and join the Davis CoPilot for Workflows Preview

Davis CoPilot for Workflows is available as a Preview. Sign up now and see how generative intelligence embedded into your workflows transforms your automation. Today, it helps you react faster, optimize more effectively, and collaborate seamlessly. Tomorrow, it will go even further: anticipating needs, orchestrating actions, and enabling truly autonomous reasoning.

The post Write the future: Create your own agentic workflows appeared first on Dynatrace news.

Editor’s note

At AWS re:Invent, innovation isn’t just a topic of conversation — it’s on full display for the world to see. As we prepare for the latest innovations from the expo floor in Las Vegas, the message is clear: The future is AI-driven, and the foundation for success is built on intelligent observability.

This presents a unique opportunity, and Dynatrace with Amazon Web Services provides a clear path forward. With AI-driven automation and real-time observability at the core, we help organizations reduce risk, resolve issues faster, and optimize cloud investments.

This guide explores the key themes of AWS re:Invent and highlights how Dynatrace and AWS empower organizations to build, modernize, and secure their cloud environments with confidence. It’s time to accelerate and lead the way.

— Jay Snyder, SVP of Global Partners and Alliances, Dynatrace

The latest news and announcements from AWS re:Invent

The Dynatrace AI-powered observability platform is purpose-built to tame the complexity introduced by new generative and agentic AI initiatives and the explosion of data that teams must manage. By integrating with new agentic-focused services from Amazon Web Services, Dynatrace provides automated, intelligent observability and security that organizations need to innovate faster and more securely. Check out the latest news and integrations, including the following:

• AWS DevOps Agent — an autonomous AI agent that resolves and proactively prevents incidents, while continuously improving reliability and performance — has reached general availability. Dynatrace has collaborated with AWS on this initiative from the beginning. AWS DevOps Agent works with Dynatrace production context to reduce operational toil, identify recurring issues, and strengthen application reliability across AWS environments.
• Our new Modern Cloud Operations for AWS feature enables automatic discovery of new AWS services, native telemetry and metadata ingestion for seamless observability, and unified dashboards with AI-driven insights for performance, cost control, and modernization.
• Dynatrace is now integrated with Kiro, AWS’ agentic integrated development environment.
• Customers leveraging agentic systems built on AWS services like Bedrock AgentCore can get visibility into their interactions across AWS services, enabling developers to monitor, debug, optimize, and audit agentic workflows with Dynatrace’s support for Amazon Bedrock AgentCore Observability.
• Teams can perform cloud security posture reviews and receive real-time observability and AI-driven insights, accelerating threat detection, reducing MTTR, and improving resilience and compliance via our Dynatrace and AWS Security Hub integration.

For more information on these integrations and the latest news:

	Announcing Amazon Bedrock AgentCore Agent Observability – Product News Dynatrace now provides native, end-to-end observability for Amazon Bedrock AgentCore agents.
	Leverage Dynatrace observability capabilities within Kiro powered by AWS – blog By integrating Kiro powered by AWS with Dynatrace, you can leverage AI-assisted monitoring and troubleshooting directly in your development workflow.
	Dynatrace Expands AWS Integrations at re:Invent 2025 – Product News Dynatrace announced expanded integrations with advanced AWS technologies and new achievements with AWS that deliver enhanced AI-driven observability, automation, and security to customers worldwide.

How Dynatrace and AWS help navigate the complexities of agentic and GenAI

Generative and agentic AI are transforming industries. However, building trust in these systems is a work in progress. In fact, according to the Dynatrace 2025 State of Observability report, 99% of AI governance leaders report their organization takes human-monitored measures to validate AI decision-making, highlighting the need for unified observability. See how Dynatrace and AWS help organizations overcome the complexities that modern AI workloads introduce.

	How Dynatrace drives value in the age of AI in the AWS® Agentic AI Marketplace – blog Agentic applications are transforming business. Discover how to operationalize AI fast with Dynatrace and the AWS Agentic AI Marketplace.
	The rise of agentic AI part 3: Amazon Bedrock Agents monitoring and how observability optimizes AI agents at scale – blog Next-level agentic AI relies on A2A communication. Discover how to optimize AI agent observability and Amazon Bedrock Agents monitoring.
	Dynatrace achieves AWS Generative AI Competency: A new milestone in observability and AI – blog Dynatrace has achieved the AWS Generative AI Competency to help organizations maximize the benefit and full potential of GenAI projects.
	Exploring the power of AI observability with Dynatrace and AWS – webinar Unpack today’s AI observability friction points and learn how AWS and Dynatrace help companies run AI with confidence.
	Unlock innovation with AI-powered observability from Dynatrace for Amazon Bedrock – fact sheet Take control of your generative AI systems with Dynatrace’s observability solutions. Gain insights, optimize performance, and build trust across your AI stack—from infrastructure to user interactions.

Discover the keys to smarter, safer innovation — faster

Constant firefighting can be a time drain for developers, site reliability engineers, security, and operations teams. Instead, they need to spend more time on business-critical tasks — most notably, innovation. That’s where Dynatrace and AWS can help, offering a strategic approach to optimizing applications for performance, cost, and security. Dynatrace and AWS provide end-to-end observability and AI-powered insights that reduce risk and accelerate modernization. From managing cloud complexity to protecting critical data and accelerating AI-driven innovation, Dynatrace on AWS provides the tools and insights teams need to succeed.

	Enhance your development workflow with the Amazon Q Developer CLI for Dynatrace MCP – blog Enhance your development workflow by integrating Amazon Q Developer CLI with the Dynatrace AI-powered observability platform using MCP.
	AWS: Driving successful cloud migration and optimization with Dynatrace – video Hear how AWS is utilizing Dynatrace to help enable customers to provide a path to make intelligent decisions and drive better business outcomes.
	Ingest and enrich AWS Security Hub findings with Dynatrace – blog Dynatrace integrates with AWS Security Hub to unify, visualize, and automate security findings across tools and environments.
	Ingest and enrich Amazon GuardDuty security findings with Dynatrace – blog This integration empowers SREs and security teams to understand runtime context for smarter threat detection, faster issue remediation, and more.
	AWS publishes Dynatrace-developed blueprint for secure Amazon Bedrock access at scale – blog Organizations can now securely and efficiently control access to Amazon Bedrock services at scale.
	Smarter cloud security with Dynatrace and Kiro CLI – blog We’ve integrated Dynatrace with AWS Security Hub and Kiro CLI to streamline triaging and remediation of critical findings, focusing efforts where they count most.

Chart your course for innovation

AWS re:Invent is more than a conference; it’s a catalyst for the next wave of technological advancement. Agentic AI is poised to redefine what’s possible, and the powerful synergy between Dynatrace and AWS provides the foundation you need to lead the way.

Visit us at booth #575 to see live demos, chat with our experts, and explore how Dynatrace can help you automate complex tasks and optimize your AWS ecosystem while accelerating adoption of generative and agentic AI technologies. Don’t miss our meetups, breakout sessions, and lightning talks to gain deeper insights and network with fellow innovators.

The post AWS re:Invent 2025: Accelerate into the age of agentic with AI-powered observability appeared first on Dynatrace news.

Amazon Bedrock provides enterprises with fully managed access to leading foundation models through a single API, eliminating the complexity of managing underlying AI infrastructure. This simplicity accelerates innovation but also prompts enterprises to consider how best to govern and secure access to Amazon Bedrock as they’re using it at scale.

Without a secure AI gateway in place, organizations can quickly face challenges such as:

• Uncontrolled access and data exposure: Without integrated authentication and authorization, anyone with credentials can invoke models or send sensitive data without oversight.
• Compliance and audit gaps: Without consistent tracking and isolation, it’s difficult to demonstrate adherence to internal policies or regulatory requirements.
• Operational fragility: Developers must manage credentials and request signing manually, adding complexity and security risk.

These are the same challenges Dynatrace encountered while scaling its own generative AI workloads. In response, our engineering teams developed a secure AI gateway for Amazon Bedrock, which has proven effective in serving our global user base. We’re now sharing a reusable reference architecture for the AI gateway in close collaboration with our partners at AWS.

Enterprise-grade governance for real-world use cases

The Secure AI Gateway extends Amazon Bedrock with enterprise-grade governance and control. Built on Amazon API Gateway, the solution integrates seamlessly into existing enterprise environments and provides:

• Strong authentication and authorization through integration with corporate identity systems.
• Usage quotas and throttling to manage cost and ensure fair resource distribution.
• Multi-tenant support and tenant isolation with detailed usage tracking for security, auditability, and compliance.
• Zero-code compatibility with Bedrock features: Once the AI Gateway is deployed, all existing Bedrock capabilities remain available without any integration code changes.

Proven within Dynatrace’s own platform, this reference pattern provides enterprises with a practical path to securely operationalize Bedrock, maintaining the speed and flexibility developers expect while introducing the control and transparency that enterprise governance demands.

Find all the details and the full technical walkthrough here: AWS: Building a Secure AI Gateway to Amazon Bedrock.

AI Observability for continuous insights after deployment

Securing access is only the first step; ensuring everything continues to work as intended is the next. With Dynatrace observability for Bedrock-based workloads, your teams gain continuous insight into performance, reliability, and cost, verifying that governance controls remain effective and that AI workloads perform as expected.

You can read more about our solution here: Deliver secure, safe, and trustworthy GenAI applications with Amazon Bedrock and Dynatrace.

The post AWS publishes Dynatrace-developed blueprint for secure Amazon Bedrock access at scale appeared first on Dynatrace news.

In this blog, we’ll demonstrate how attackers exploiting CVE-2025-3248 can use traditional attack techniques to manipulate AI agent behavior and plant a malicious backdoor in AI-generated source code.

To help mitigate the risks posed by vulnerabilities in agentic AI frameworks, we show how Dynatrace Cloud Application Detection and Response (CADR) detects malicious activity to protect both the agents and the environment they run in.

The attacker’s perspective: What is CVE-2025-3248 and how to exploit it?

The critical vulnerability CVE-2025-3248 in the Langflow framework leads to remote code execution (RCE) due to the ability to perform code injection (CWE-94) by unauthenticated users (CWE-306). Dynatrace security researchers discovered that in addition to affecting the Python package langflow v1.3.0 and below, the package langflow-base v0.3.0 and below are also vulnerable.

In our scenario, an attacker exploits this vulnerability to get remote access to the container running Langflow. The attacker manipulates the instructions to the LLM in the AI agent to inject a backdoor into generated code functions as shown in the figure above.

Let’s step back and take a look at the process from the beginning. The figure below shows the user interface of Langflow. To configure the agent, a benign system prompt saying “You are a programming assistant. Respond to technical queries with clarity, accuracy, and efficiency” is used in the setup. The user can interact with the agent through a chat input and receives answers through a chat output window. The agent can also be exposed and integrated into an external application using an API.

In our setup, the Langflow framework is deployed on a Kubernetes cluster and is accessible to users to work on specific tasks, such as using the agent to generate source code. The attacker in our scenario uses one of the public exploits for CVE-2025-3248 to inject and execute attacker-controlled code into the container, like reading the /etc/passwd file as shown below.

The attacker then opens a reverse shell to execute more commands on the application host and further compromise the system. Specifically, the attacker establishes a connection using port 7777 to facilitate command execution on the container. Opening a reverse shell enables the attacker to be much quieter when executing certain commands, since the initial exploit script causes an exception which is visible in the log files.

To further penetrate the system, the attacker searches for the SQLite database used by Langflow and then proceeds to enumerate user accounts, credentials, and flows. They could exfiltrate the data or alter it in the database, further compromising the integrity and security of the system.

In the default deployment configuration of Langflow, which uses a local SQLite database, the attacker can access this data without needing any credentials. If Langflow is configured to use a different database backend (e.g., PostgreSQL), the attacker may still be able to retrieve the necessary credentials by inspecting environment variables.

The attacker then changes the system prompt of the AI agent to a malicious one in the database to make the AI agent inject a backdoor into generated code and obfuscate it.

Now, when a user requests the agent to generate a code snippet, it would include an obfuscated malicious portion with a code comment telling the user that the code is there to ensure backwards compatibility and not to remove it, as seen below.

While this might appear to be obviously suspicious code, the risk increases significantly when the agent is tasked with producing larger or more complex codebases. In such cases, users may be inclined to run the code without thoroughly reviewing or verifying its contents. The potential impact becomes even more serious if the Agentic AI is integrated into development environments where it can test and execute code directly on a developer’s machine.

The defender’s perspective: How the Dynatrace CADR approach helps

Dynatrace enables the detection and prevention of the type of attacks described above on multiple layers: By detecting the vulnerability as the entry door for the attacker, identifying misconfigurations that enable an attack to penetrate the system, and investigating suspicious traces caused by the exploit.

Let’s walk through an example scenario that explores all three layers. The journey begins when Dynatrace workflows notifies a Site Reliability Engineer (SRE) on Slack about a Python exception through Dynatrace workflows.

This encourages the SRE to have a closer look at the affected container, which has a critical vulnerability that is detected and visible in the Vulnerabilities App. Investigating the affected container also shows several misconfigurations in the Security Posture Management App which leads the SRE to align with internal security analysts and start a deeper investigation using the Security Investigator App.

First layer of defense: Detecting CVE-2025-3248 with Runtime Vulnerability Analytics

The version of the Langflow framework we installed contains the recent critical vulnerability CVE-2025-3248 which is detected right away by Dynatrace’s Runtime Vulnerability Analytics as shown below.

Agentic AI frameworks are often based on Python and the recently introduced ability in Dynatrace to detect Python vulnerabilities at runtime provides immediate information about potential doors for attackers. Applying the recommended fix outlined in the vulnerabilities app would prevent an attacker from exploiting the system.

Second layer of defense: Identifying misconfigurations with Security Posture Management (SPM)

Specific configurations in complex systems enable attackers to perform certain actions to penetrate through a system and achieve their goal.

In our scenario, the attacker employs a reverse shell, which is a common tactic used to enable remote command execution. In the current configuration of our Kubernetes cluster a network policy is missing which is shown in the SPM app.

To address the tactic of deploying a reverse shell, implementing a network policy that restricts all outbound connections, except for HTTP/S ports, serves as an effective countermeasure, while allowing essential web access for the AI Agent.

Applying network policies across a Kubernetes cluster is a security best practice, as outlined in benchmarks like those from the Center for Internet Security (CIS). The Dynatrace Security Posture Management application can identify and prevent such misconfigurations. In our scenario, as shown below, we apply a network policy to the langflow namespace which prevents attackers from using random ports for a reverse shell.

Although the network policy in our scenario does not entirely protect against advanced attack techniques, as attackers may circumvent restrictions, they increase the complexity and difficulty of executing successful attacks. By adopting these SPM rules, best practices can be enforced to effectively reduce the attack surface. Adjusting deployment configurations and aligning them with compliance benchmarks, organizations can significantly reduce the risk of successful compromises. Good compliance practice will further reduce the blast radius in case of a successful attack, for example by preventing attackers from escaping a compromised container.

As we can see in the screenshot below, when the network policy is configured, the attacker is unable to establish a reverse shell connection. See the figure below with the message “Exploit failed with status 200”. This makes the traces of the attack more noisy and visible in the log files and allows analysts to draw conclusions more easily.

Third layer of defense: Tracing the exploit with the Security Investigator

After being notified by a workflow automation our analyst runs a query in the Security Investigator to check for exceptions on any of the monitored Kubernetes clusters and receives a number of outputs as shown below.

Tracing the cause of the exception in the log entries, the analyst discovers the following suspicious log lines showing the command and its output executed by the attacker.

Based on this, the analyst decides to further investigate this activity and discovers multiple attacker activities as shown below.

Filtering out the relevant content from the log entries of the affected container reveals the different steps performed by the attacker, such as executing shell commands and deploying a reverse shell to further penetrate the system and manipulate the AI agent.

Conclusion

The exploitation of CVE-2025-3248 demonstrates how traditional attack techniques—like remote code execution and reverse shells—can be repurposed to compromise agentic AI systems. As these frameworks become more deeply embedded in enterprise workflows, the attack surface will continue to expand, and the stakes will grow higher.

Securing agentic AI isn’t just about patching vulnerabilities. It’s about anticipating how attackers will adapt and evolve. The Dynatrace multi-layered approach, combining runtime vulnerability analytics, security posture management, and deep log investigation, provides a robust foundation for defending these dynamic environments.

The post Remediating CVE-2025-3248: How Dynatrace Application Security protects Agentic AI applications appeared first on Dynatrace news.