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.

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 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.

We kicked off the new year with our annual customer event, Dynatrace Perform, and many new announcements. If you weren’t able to join us in person, you can watch all the mainstage keynotes, innovation sessions, and breakouts on demand on the Dynatrace Perform 2026 webpage.

In this blog, we’ll focus on brand-new product enhancements that accelerate service troubleshooting, provide richer cloud context for AWS, and deliver meaningful improvements that reduce friction in daily workflows.

If you want to jump straight to our curated sandbox environment for the capabilities mentioned below, head over to our dedicated playground launchpad.

Dynatrace Intelligence

Our biggest news is that Dynatrace Intelligence is now available. It’s the industry’s first agentic operations system that effectively fuses deterministic insights with agentic action to deliver reliable outcomes with autonomous prevention, remediation, and optimization at scale.

Here are the new features and capabilities now available in Dynatrace Intelligence:

• Dynatrace MCP Server: In addition to the local MCP server that was launched in May 2025, our remote MCP server is now generally available.
• Dynatrace Assist: The evolution of Davis CoPilot puts Dynatrace Intelligence at your fingertips. Dynatrace Assist pulls context from Grail, maps relationships using Smartscape – our real-time dependency graph – and collaborates autonomously with Dynatrace agents using the tools provided by the Dynatrace MCP server.
• Agentic ecosystem: Whether you aim to level up collaborative operations with SRE agents, enjoy closed-loop autonomous operations with ITSM agents, or want AI-powered code repair with developer and coding agents, we’ve got you covered. Maximize the value of your tool landscape by leveraging our agentic integrations.
• Agentic workflows: Turn your workflows into agentic automations leveraging Dynatrace Intelligence. This program is currently available in a Preview program.

Smartscape: Real-time dependency graph

The new Smartscape experience delivers a real-time dependency graph that helps practitioners move from “watching signals” to understanding true entity health and cause-and-effect across fast-changing cloud, Kubernetes, on-premises, and hybrid environments. It adds major new capabilities:

• An all-new Smartscape app with powerful visual analytics and domain-specific views,
• Fully native cloud entities with complete metadata (including raw cloud/Kubernetes object JSON),
• and agentless cloud data ingest for automatic enrichment of dependencies and policy context.

This allows teams to diagnose faster, reduce MTTR, and make better architectural and operational decisions with real production context.

Smartscape enables exploration across millions of relationships, strengthens incident collaboration via in-context workflows like Visual Resolution Path and “view topology” actions, and improves security and governance by visualizing exposure and attack paths with real blast radius and enriched cloud native semantics like tags, ownership, cost centers, and compliance attributes.

The new Smartscape extends far beyond a standard topology; it offers domain-specific views tailored to the unique requirements of your use cases—whether application performance, cloud infrastructure, or essential business services. The following pre-configured views are now available.

• Smartscape on Grail: discover all entities and relationships in your environment
• Infrastructure overview: gain insights into which components are running and how they’re connected
• Service dependency graph: see how your services are connected
• Problem graph: understand problem impact and blast radius
• Kubernetes overview: map your Kubernetes environment, from clusters to components
• AWS EC2 ecosystem overview: understand your entire EC2 ecosystem and resource relationships

Have a look at our recent Smartscape blog post to learn how these enhanced views help solve real-world challenges.

Cloud Operations for AWS

Dynatrace enhanced Cloud Platform Operations expands AI-powered observability into an operations-first experience for practitioners (cloud ops, SRE, and platform teams) by unifying cloud metrics, logs, and events across AWS, Azure (see Preview program), and Google Cloud (see Preview program) in a single platform, enriched with topology-aware context for faster troubleshooting and safer automation. It introduces:

• fully managed cloud connections with a guided wizard (no extra infrastructure),
• expanded ingest that captures more cloud service metrics plus richer cloud events (including hyperscaler-native security alerts),
• and automatic reuse of existing cloud tags to drive access control, ownership, cost allocation, alert routing, and preventive workflows—so teams can move from fragmented signals to clear, actionable answers at enterprise scale.

This allows users to shift from reactive monitoring to proactive cloud operations built around three outcomes: prevention (predict anomalies and trigger workflows before user impact), remediation (AI-driven RCA plus self-healing automation to cut resolution time), and optimization (continuous cost and performance efficiency via real-time insights and recommendations).

For platform teams, the big win is operational simplicity: the onboarding flow is GitOps-ready and removes the need to maintain ActiveGates for CloudWatch ingest on this path. For practitioners, the win is troubleshooting speed: reimagined exploration, resource-rich metadata, and opinionated insights reduce the time from “something’s wrong” to “here’s why.”

Real User Monitoring experience

The new Real User Monitoring (RUM) experience adds modern frontend signals that match how today’s web and mobile apps behave—for example, soft navigation for Single Page Apps (SPA), user interactions (clicks/taps/scrolls), and background requests—alongside Core Web Vitals and key mobile performance signals (including troubleshooting enhancements like application not responding and symbolication). Out of the box, teams get task-focused workflows and dashboards that connect frontend symptoms to backend reality, so you can pinpoint what’s slow or broken and shorten the path from user complaint to verified cause and fix.

Achieve faster validation of real user impact and clearer prioritization: Users & Sessions grounds investigations in actual sessions, Error Inspector groups and prioritizes errors with the right context, and Experience Vitals helps identify which requests/assets drive slowdowns using redesigned analysis views—so teams can reduce friction, resolve complaints with confidence, and connect experience trends to business outcomes via custom dashboards, notebooks, and DQL exploration, with built-in privacy/permission controls, and optional extended retention for deeper historical analysis (currently available in a Preview program).

AI observability

Dynatrace has expanded agentic AI observability with a broader framework and protocol support, so teams can build, run, and debug autonomous agent systems with confidence across AWS, Azure, and Google Cloud. Support now includes popular agentic ecosystems such as Amazon Bedrock AgentCore, Amazon Bedrock Strands, LangChain Agents, Google Agent Development Kit (ADK), OpenAI Agents SDK, and Model Context Protocol (MCP)—with signals unified via OpenTelemetry and OpenLLMetry into a single correlated observability model for end-to-end visibility across agents, tools, models, and dependencies.

Alongside this expanded support, the new AI Observability app delivers a purpose-built experience to observe AI workloads end-to-end—from agents and LLMs to orchestration layers and tools—so practitioners can validate changes faster, reduce risk, and ship AI features at scale. Key capabilities include end-to-end monitoring of agent interactions and tool usage, prompt/tool/model tracing and debugging across multi-step flows, cost visibility (token consumption, cost trends, caching impact), actionable dashboards and drill-downs (including faster validation via A/B testing across model/prompt variants), and enterprise-grade security, privacy, and governance views such as surfaced guardrail outcomes for auditability and trend monitoring.

Investigations: Transform how practitioners derive actionable insights

The Investigations app provides a central starting point for exploring analytical insights across Grail data. It gives practitioners immediate access to essential investigation capabilities—such as analyzing large DQL results, pivoting queries based on metadata, reviewing investigation history, and connecting logs, metrics, events, and traces—helping practitioners quickly uncover root causes and accelerate complex investigations.

Improved Dashboards experience

We’ve enhanced several ready-made dashboards that improve your dashboard experience and make insights clearer, faster, and more consistent. You can duplicate and adapt them to kick-start your own dashboards.

• The Getting started dashboard demonstrates the major types of visualizations you can use and provides example tiles and layouts.
  
• The Page performance & errors dashboard serves as a starting point for investigating page performance and web front-end navigation. It surfaces the most important web performance and reliability KPIs at a glance, highlighting key metrics such as page load time, error count, navigations, LCP, INP, and CLS.
  
• The XHR & fetch performance dashboard includes core KPIs such as request duration, time to first byte (TTFB), and fetch failure rate. These help you quickly spot slow or failing back-end calls that affect the user experience.
  

Where to start this week

We encourage you to take advantage of all the efficiencies and insights these new Dynatrace capabilities provide. Depending on your role, here are the recommended next steps for SREs, Cloud Owners, and Development teams seeking faster service troubleshooting loops, richer AWS cloud context, and other meaningful improvements that reduce friction in their daily workflows.

Get started: SREs

1. Start with Dynatrace Intelligence for faster incident loops

1. 1. Open Dynatrace Assist during an active issue to pull context from Grail and map relationships via Smartscape, then let it collaborate with Dynatrace agents/tools (via MCP) to accelerate triage and next steps.
   2. If you use chat/agent tooling internally, connect via the Dynatrace MCP Server (remote if you want centralized access) to make Dynatrace context available in your agentic workflows.

2. Make Smartscape your default “blast-radius + causality” view

1. 1. Use the new Smartscape app and Visual Resolution Path/view topology actions to validate true upstream/downstream impact and shorten MTTR.
   2. Leverage native cloud/Kubernetes metadata (including raw object JSON) to quickly confirm “what changed” vs. “what broke.”

3. Automate closure with agentic workflows (Preview program)

1. 1. Convert recurring remediation steps into agentic automations by combining Dynatrace Intelligence with Workflows for closed-loop operations (start with a high-confidence, low-risk runbook).

Get started: Cloud owners

1. Onboard AWS with enhanced Cloud Operations first
   1. Use the fully managed cloud connection and guided wizard to bring in unified metrics, logs, and events with richer AWS context, without maintaining ActiveGates for CloudWatch ingest on this path.
   2. Ensure your cloud tags are clean and meaningful, because they’ll automatically drive ownership, access control, cost allocation, and alert routing.

2. Operationalize outcomes: prevention, remediation, and optimization
   2. Set up alerting and dashboards around the three outcomes:
   3. Prevention: anomaly prediction + proactive workflows
   4. Remediation: AI-driven RCA + self-healing actions
   5. Optimization: continuous cost/performance efficiency using context-rich insights
   6. Use Smartscape to validate dependencies and impacts across accounts, regions, clusters, and services.

3. Plan for multicloud setup
   3. If you’re also on Azure or GCP, use what you learn on AWS to establish a standard operating model, then extend to preview programs when ready.

Get started: Development teams

1. Start from user impact with the new RUM experience

1. 1. Use Users and Sessions to reproduce issues from real sessions, then jump to Error Inspector and Experience Vitals to identify which requests/assets/interactions drive pain.
   2. For SPAs and modern apps, validate soft navigation, user interactions, and background requests alongside Core Web Vitals to quickly pinpoint frontend bottlenecks.

2. Connect frontend symptoms to backend issues

1. 1. From a slow, erroring session, follow the workflow to backend services and dependencies (Smartscape helps confirm causality), shortening the path from complaints to verified root causes.

3. If you ship AI features, instrument them with AI Observability

1. 1. Adopt the AI Observability app for end-to-end tracing across agents, tools, and models; use cost visibility and A/B validation to safely iterate on prompts/models.
   2. Standardize telemetry via OpenTelemetry and OpenLLMetry, and if you use agent frameworks (LangChain Agents, OpenAI Agents SDK, Google ADK, Bedrock, or MCP), start by observing one representative production flow before scaling coverage.

The post Dynatrace Release Radar 01.26 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.

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.

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.