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.

What is the Kiro power for Dynatrace?

The Kiro power for Dynatrace delivers live observability data, root cause analysis, and remediation suggestions directly into the Kiro IDE, with no JSON editing or manual MCP setup.

Kiro is an AI-powered IDE that helps developers move from idea to working code through spec-driven development and an agentic assistant. To make the assistant genuinely useful in unfamiliar domains, Kiro recently introduced powers: curated, partner-validated bundles of MCP servers, steering files, and best practices that install with a single click and load on demand when a relevant task comes up. Install a power, and Kiro’s agent gains specialized expertise the moment you need it.

For Dynatrace customers already working in Kiro, it’s the shortest path yet from code to production insight. For developers new to Dynatrace, it’s a one-click way to ground Kiro’s reasoning in real facts from your environment, not guesses.

Why this matters for developers

Developers have historically been one step removed from production. When something breaks after deployment, the path to figuring out what went wrong usually runs through a Site Reliability Engineering (SRE) or operations team, and AI coding assistants can’t automatically and reliably remediate issues in software they’re unfamiliar with. Agents that can write code are guessing about how their code behaves in production unless they have access to real telemetry data.

The Dynatrace Kiro power for Dynatrace closes this gap through Dynatrace Intelligence, the agentic operations system at the core of the Dynatrace platform. Kiro’s answers are grounded in deterministic, causal AI and real-time production data, not probabilistic guesses.

With the tools provided by the Kiro power, developers can:

• Investigate live incidents and get root cause analysis directly in Kiro chat
• Query metrics, logs, and traces from production using natural language
• Surface security vulnerabilities affecting the code they’re working on
• Get remediation suggestions grounded in what’s actually happening in their environment

“Using Kiro powers for Dynatrace has been a total game-changer in the observability space. Deep-dive root cause analysis of complex system issues that once required lengthy manual intervention now happens in seconds, giving us unprecedented speed and confidence.”

Mike Kobush, Sr. Software Performance Engineer, NAIC

How to install the Kiro power for Dynatrace

Getting started takes only a few steps. Once installed, the Kiro power activates automatically when Kiro detects a relevant task. Mention an incident, a slow service, or anything that needs production context, and the Dynatrace tools and guidance will load in Kiro chat.

Prerequisites

• A Dynatrace account. If you don’t already have one, you can start a free 15-day trial.
• Kiro installed on your system.

Prepare the Dynatrace connection

First, create a Dynatrace Platform Token, which Kiro will use to authenticate. Then add the required permissions for the Dynatrace MCP server.

Install the Kiro power

The power can be installed from either the Kiro IDE or the Kiro powers website. For this walkthrough, we’ll use the IDE.

1. Launch the Kiro IDE.
2. Select the Ghosty icon with the lightning bolt to open the powers panel.
3. Select Dynatrace Observability from the Recommended
4. Select Install. The power is registered with placeholder values for the Dynatrace URL and token. Therefore, Kiro will show an error message that the MCP server can’t be reached.
5. To complete the configuration, select Open Settings and replace the placeholders with your environment details.

Configure your tenant and token

In the settings file, replace the two placeholders:

Start asking questions

Open a new chat in Kiro and start interacting with your Dynatrace environment using natural language. Query active problems or security vulnerabilities, request a root cause analysis to identify critical issues in production, or pull related logs and traces, all without leaving the IDE.

See it in action

The short demo below walks through installing the Kiro power for Dynatrace, verifying the connection, and running a first query against your environment to list the top 10 vulnerabilities detected by Dynatrace.

Get started with the Kiro power for Dynatrace

Kiro powers transform what used to be a stitching exercise (MCP servers here, steering files there, custom instructions somewhere else) into one single, ready-to-use bundle. The Kiro power for Dynatrace applies the same idea to observability: live production insight, causal root cause analysis, and remediation grounded in real telemetry, all available the moment a developer needs them.

The result is a tighter loop between writing code and understanding how it behaves in production. Less waiting for diagnostic data from someone else. Less guesswork from an AI assistant operating without context. And, more time spent on the work that actually matters.

Ready to try it? The Kiro Power for Dynatrace is publicly available: install it from kiro.dev or the Kiro IDE and start asking your environment questions.

The post Dynatrace observability is now a Kiro power 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.

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.

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.

March 31, 2026 update

Today we congratulate AWS on the general availability of AWS DevOps Agent. This marks an important step forward in how teams operate and innovate in the cloud, moving closer to systems that can investigate and respond with minimal human intervention.

At Dynatrace, we are proud to have collaborated with AWS on this initiative from the beginning. Together, we have worked to bring observability, AI, and automation closer together to help customers simplify operations and resolve incidents faster.
Our joint customers are already seeing measurable value, including up to a 70 percent reduction in mean time to resolution, as teams move from reactive troubleshooting to more intelligent and automated workflows.

This work reflects a broader shift toward agentic operations. We are continuing to deepen our collaboration with AWS across DevOps Agent and other AI services as this space evolves. This foundation sets the stage for how the Dynatrace platform and AWS DevOps Agent integration works in practice.

How AWS DevOps Agent and Dynatrace complement each other to resolve incidents faster

It’s late at night, you’re on call, and an alert fires for an AWS application. You need to assess the severity, understand the impact, and quickly notify the relevant teams. Until now, that potentially meant toggling between Dynatrace and the AWS Console to piece together the full picture. With the AWS DevOps Agent and Dynatrace integration, you instantly have all the information you need at every stage of remediation.

AWS DevOps Agent represents a new class of frontier agents: AI that works autonomously for hours or days, investigating incidents without constant human intervention. Dynatrace provides causal and predictive AI that pinpoints the root cause of issues and anticipates problems before they escalate. Together, they create something neither can deliver alone: end-to-end incident resolution that spans from early warning through root cause to remediation.

When AWS announced the DevOps Agent at re:Invent last December, they showcased this integration as a key use case, demonstrating how autonomous investigation becomes dramatically more effective when powered by Dynatrace precise, topology-aware production context. The agent doesn’t just correlate signals; it understands what those signals mean for your business.

Experience topology-aware root cause analysis with guided mitigation

Consider a typical CRM stack: a React frontend on S3 and CloudFront, an ALB routing to Lambda-hosted Python services implementing the CRM business logic, backed by an RDS PostgreSQL. During normal operations, the responses take ~1 ms, but suddenly those degrade to 1 s+. Dynatrace instantly detects the problem with all relevant context, including business impact, and automatically triggers the AWS DevOps Agent to initiate further investigation.

Figure 1: Dynatrace and the AWS DevOps Agent work hand in hand to analyze and mitigate the problem.

• Root cause analysis with causal AI: Dynatrace detects response-time degradation and automatically gathers relevant context, including potentially AWS resources causing the issue, such as Lambda, RDS, and ALB.
• Seamless collaboration with AWS DevOps Agent: Dynatrace triggers the AWS DevOps Agent and passes full runtime context, allowing it to trace the execution path from symptom to failing component.
• Pinpoint the root cause: The AWS DevOps Agent analyzes underlying RDS logs, identifies DROP INDEX commands that correlate with slowdown events, and surfaces the findings directly in Dynatrace, without tool switching. The commands are traced to an input error by a database administrator.
• Recommend and stage a fix: the agent provides a clear diagnosis, recommended remediation steps, and proposed action that’s ready for human approval.
• Prevent recurrence: The agent suggests proactive monitoring of database logs for similar commands to prevent future incidents.

This always-on, on-call workflow accelerates triage, allows topology-aware root cause analysis, guides mitigation, and adds preventative recommendations. It works across a broad set of AWS services, including AWS Lambda function errors, Amazon EKS container failures, Amazon VPC connectivity issues, and more.

Ready to try it out yourself?

With the Dynatrace integration into AWS DevOps agents, you get:

• Fewer handoffs and clearer ownership with a single investigation narrative (no bouncing between teams/tools)
• Less manual correlation as Dynatrace supplies topology, dependencies, and traces as a ready-to-use production context
• Faster “why” analysis as AWS DevOps Agent correlates AWS telemetry with change/deployment history and proposes mitigations
• A more repeatable incident response, including prevention recommendations to reduce repeats

For more details on the preview and how to try it yourself, have a look at this hands-on walkthrough on the AWS Cloud Operations Blog. You can also refer to AWS documentation for instructions on connecting Dynatrace and the AWS DevOps Agent.

For more news on Dynatrace and AWS, have a look at this recent blog post.

The post Integration with AWS DevOps Agent: Autonomous investigations powered by production context appeared first on Dynatrace news.

In today’s cloud-native environments, having real-time observability data at your fingertips is crucial. By integrating Kiro powered by AWS with Dynatrace, you can leverage powerful AI-assisted monitoring and troubleshooting capabilities directly in your development workflow.

Kiro—which recently reached general availability—helps developers by bringing structure to AI coding with spec-driven development. When a developer needs to fix an issue, investigate an error, or optimize resource usage, it’s crucial they can analyze what happened just before the issue occurred and delve deeper into the infrastructure utilization of your applications in your cloud or container environment.

Unlock development productivity with live production insights

Developers typically face restricted access to production environments, being fully dependent on site reliability engineers (SREs) or operations teams to detect and report issues post-deployment, and provide them with the necessary information to fix an issue. This segmented workflow can result in delayed problem identification and resolution, an increased risk of failures in production, and reduced efficiency throughout the development lifecycle.

By connecting Dynatrace with Kiro, developers can access real-time insights from production environments, gain contextual information down to the root cause of an incident, and receive remediation proposals—all within their Kiro environment.

Kiro has a built-in Model Context Protocol (MCP) client that can be used to extend its capabilities to communicate securely and flexibly with external data sources and tools such as Dynatrace.

Let’s dig deeper into how to leverage this capability and provide Dynatrace’s unique insights to your development teams.

Step-by-step integration guide

Prerequisites

• You’ll need a Dynatrace account. If you don’t already have one, you can start a free 15-day trial.
• Kiro must be installed on your system.
• You must have basic familiarity with AWS services and the Dynatrace platform.

Prepare integration with Dynatrace

First, you need to create a Dynatrace Platform Token, which is used to define Kiro access, and then add the required permissions for the Dynatrace MCP server.

Configure Kiro MCP Settings

The Kiro MCP configuration is managed through a JSON file. The interface supports two levels of configuration:

• User-level: ~/.kiro/settings/mcp.json applies to all workspaces
• Workspace-level: .kiro/settings/mcp.json is specific to the current workspace

You can apply the configuration using two different methods:

Method 1: Open the command palette (use Cmd + Shift + P on Mac or Ctrl + Shift + P on Windows/Linux), search for MCP and select Kiro: Open workspace MCP config (JSON) or Kiro: Open user MCP config (JSON), depending on whether or not you want to configure the settings for the workspace or user level.

Method 2: Alternatively, you can use the Kiro Panel. Open Kiro and select the Kiro ghost icon to open the left-side panel. Locate the MCP SERVERS section, select  Open MCP Config, and then start configuring the connection for the Dynatrace MCP Server.

Dynatrace specific settings

Note: Only add one of the following configurations, depending on whether you want to use the remote MCP server or the local MCP server. You can’t use both at the same time.

Using the remote MCP server

Use the following configuration. Replace $TENANT_ID with your Dynatrace environment ID. (You can find your environment ID in the URL of your Dynatrace environment — for example, https://<ENVIRONMENT_id>.apps.dynatrace.com/ui.) Then, replace $DT_PLATFORM_TOKEN with the ID of the Dynatrace platform token you created previously (for example, dt0s16.XXXXX).

{ 
"mcpServers": 
  { 
    "dynatrace": {
      "type": "http",
      "url": "https://$TENANT_ID.apps.dynatrace.com/platform-reserved/mcp-gateway/v0.1/servers/dynatrace-mcp/mcp",
      "headers": {
        "Authorization": "Bearer $DT_PLATFORM_TOKEN"
      },
      "tools": ["*"]
      }
  }
}

Connect the local MCP server

The configuration for the local Dynatrace MCP server can be added to the Kiro IDE using one-click installation or by following the manual configuration as shown below. Don’t forget to replace $TENANT_ID with the ID of your tenant.

{
  "mcpServers": {
    "dynatrace-mcp-server": {
      "command": "npx",
      "args": ["-y", "@dynatrace-oss/dynatrace-mcp-server@latest"],
      "env": {
        "DT_ENVIRONMENT": "https://$TENANT_ID.apps.dynatrace.com"
      }
    }
  }
}

Verify the integration

Once configured, you can use the Kiro chat to interact with Dynatrace through natural language conversations. Simply tell Kiro what you need, whether it’s investigating a critical incident, gaining insights into metrics, logs, or traces from your application, analyzing dependencies, or setting up automated alerts.

In the screenshot below, you can see in the lower left which capabilities are provided by the Dynatrace MCP Server. Beyond the standardized actions, such as listing active vulnerabilities or problems, querying data stored in Dynatrace, or creating a workflow, you can also interact with Davis CoPilot®, the Dynatrace natural language assistant.

Conclusion

This integration isn’t just another feature; it’s a fundamental shift in how Dynatrace integrates with your development workflow. It brings together the power of Kiro’s AI capabilities with the Dynatrace unified observability platform, allowing developers to access critical monitoring data and gain a real-time understanding of their production environments via natural language interaction.

Spend less time context switching and more time creating value for your customers. Start today and benefit from real-time insights, precise root cause analysis based on causal understanding or improved troubleshooting capabilities, and enhanced development workflows.

Explore how Dynatrace can integrate seamlessly into your development landscape using our remote MCP Server. If you’re interested in learning more about Kiro, have a look at their launch blog post or visit the documentation and dig deeper into how to connect with MCP Servers.

The post Real-time insights: Leverage Dynatrace observability capabilities within Kiro powered by AWS appeared first on Dynatrace news.

The integration of Dynatrace with Microsoft Azure SRE Agent establishes a new benchmark for cloud operations by leveraging AI-based root cause analysis and real-time production insights, alongside a comprehensive understanding of complex, large-scale IT environments. You can leverage the combined strengths of Dynatrace and Microsoft, enabling teams to resolve complex problems in large-scale IT environments more quickly and efficiently, and automate incident remediation, moving one step closer to driving autonomous operations across their complex environments.

In today’s cloud-first world, reliability isn’t just a goal; it’s a competitive advantage. As more services move online and LLM-powered assistants evolve into autonomous agents, maintaining the reliability, scalability, and cost-efficiency of critical systems becomes essential.

That’s why Dynatrace and Microsoft teamed up to integrate Dynatrace® AI-powered observability with the Azure SRE Agent. This collaboration allows site reliability engineers (SREs) to ensure seamless operations while proactively planning for future scalability and reliability requirements.

Transform your incident management through the combined capabilities of Azure SRE Agent and Dynatrace AI

Azure SRE Agent, introduced earlier this year, provides SREs and developers with the tools they need to increase the speed and efficiency of incident responses, diagnostics, and collaboration, allowing them to resolve problems quickly.

Seamlessly integrated with incident management tools such as ServiceNow, as well as the developer ecosystem, represented by GitHub Copilot or Azure DevOps, the agent runs in the background 24/7, learning and monitoring the health and performance of your cloud environment.

As a reliability assistant, Azure SRE Agent supports teams by efficiently diagnosing and resolving production issues. You can ask the agent questions in natural language, easily access clear and concise problem summaries, and coordinate incident workflows with integrated human-in-the-loop approvals.

Dynatrace enhances Azure SRE Agent’s troubleshooting and automation capabilities with advanced observability insights. By mapping topology, data, and business context, Dynatrace gains a comprehensive understanding and delivers production-accurate visibility across your entire IT system. This visibility feeds Dynatrace deterministic AI, allowing precise root-cause identification and impact analysis. All these insights are now seamlessly supplied to the Azure SRE Agent, equipping it with real-time production context and reliable root cause analysis.

This allows your teams to move beyond simply receiving alerts; teams are now provided with AI that acts, guides safe mitigations, and accelerates resolution within Azure-native workflows.

Gain efficiency across every stage of the incident lifecycle

Using the Model Context Protocol (MCP), the Azure SRE Agent is securely connected with Dynatrace. Whether a team member uses the agent to ask questions in plain natural language, or the agent interacts with Dynatrace directly—sharing insights, asking for real-time observability data, or root cause analysis, together with remediation steps—the close collaboration supports use cases across every stage of incident management, allowing you to:

• Cut MTTR by automating routine runbooks and diagnostics, with safe, approved mitigation actions based on full context.
• Reduce security risk by triaging vulnerabilities faster with production evidence, triggering guided fixes, and validating outcomes.
• Accelerate delivery with contextual GitHub issues and PRs that include root cause, blast radius, and tests, minimizing issue reproduction time and rework.
• Improve fix accuracy by correlating Azure and Dynatrace telemetry for precise root-cause and impact analysis.
• Prevent incidents before they happen using real-time signals and historical trends to stop regressions and reduce toil.

Illustrating the value: Proactively detect and remediate security vulnerabilities

Let’s take a look at a concrete example, which we presented at Microsoft Ignite. Imagine you run a Java-based payroll app on Azure, and a new security warning (CVE) appears. Every second matters now, and there’s no room for error: you need the issue fixed quickly, without lots of back-and-forth between teams.

• Once the vulnerability is detected, Dynatrace automatically identifies the library that caused the vulnerability, opens a GitHub issue containing all relevant information, such as which parts of your app are affected, and informs Azure SRE Agent.
• The SRE agent reviews the GitHub issue and requests additional information from Dynatrace via the MCP server, such as the number of users affected, how often it happens, which endpoints are involved, or which customers might be affected, to assess the scope and impact of the vulnerability.

• After gathering all necessary details, the SRE Agent synthesizes the information and creates a new GitHub issue, assigning it to GitHub Copilot for remediation.
• GitHub Copilot then takes action by updating the configuration and code in the GitHub repository to resolve the vulnerability automatically.
• The pull request not only includes the necessary version changes but also includes documentation, highlighting all findings as well as how the issue was remediated, along with unit tests, to prevent the issue from recurring.

Try the power of Agentic AI for incident resolution

Dynatrace delivers deep, causation-based insights into your live systems, now seamlessly integrated with Azure SRE Agent to elevate your incident management. With this integration, you can unlock:

• Smarter detection and remediation: Deep contextual observability from Dynatrace, correlated with Azure telemetry, enhances issue identification and resolution across complex environments.
• Automated operations: Routine runbook actions and diagnostic workflows can be automated, reducing mean time to repair and freeing teams to focus on innovation.
• Proactive reliability: Continuous analysis of real-time and historical data identifies leading indicators of failure, allowing teams to prevent incidents before they impact customers.

Azure customers can now access Azure SRE Agent directly in the Azure portal. To connect Dynatrace with the agent and learn how to set up Dynatrace MCP Server, see Dynatrace Documentation.

The post Boost cloud reliability: Dynatrace and Azure SRE Agent unite for autonomous operations appeared first on Dynatrace news.

With Dynatrace, developers can rest assured that everything they need—from development to deployed infrastructure—is available with full context at every touchpoint. Traditionally, developers have had limited visibility into production systems, relying on operations teams to surface issues after deployment. This disjointed approach often leads to delays in identifying and resolving problems, increased risk of production failures, and inefficiencies in the development process

With GitHub’s recent announcement of custom agents, Dynatrace is proud to launch its first custom agent, introducing a powerful new entry point for Dynatrace insights directly within GitHub repositories, where developers can act on them immediately. This integration ensures that developers no longer need to leave their familiar GitHub environment to access critical observability and security data. Whether it’s triaging production errors, validating deployments, or responding to security vulnerabilities

This isn’t just another way to consume observability and security insights from Dynatrace—this is about achieving true end-to-end visibility, from code to production, by combining the capabilities of Dynatrace with GitHub Copilot and its custom agents.

In this blog post, we’ll explore the most prominent use cases offered by this integration and demonstrate how deploying these two tools in tandem can unlock new levels of efficiency, reliability, and security for your software development lifecycle.

How it works

Dynatrace and Git solutions support opposite ends of the Software Delivery Lifecycle: Git hosts your code repository while Dynatrace monitors your production infrastructure. Agentic AI and the MCP protocol allow bridging of this gap, essentially allowing AI assistants to verify their code in production.

Setting up the connection with Dynatrace is simple

We recommend using your local MCP server for prototyping and testing things out. First, follow these instructions to create a platform token with the necessary scopes. Once this is done, install the MCP server in your GitHub repository: you’ll find the configuration in Settings > CoPilot > Coding Agent (an example can be found in the repository linked above).

Finally, you need to set up the custom agent in your repository under .github/agents/Dynatrace.md. For your convenience, we’ve provided an example file that you can simply drag and drop. Update your MCP server’s credentials, and you’re all set.

Tip: Before promotion to production, we recommend switching from your local MCP Server to our remote MCP Server.

Use cases: Unlock the power of production insights

Dynatrace’s custom agent for GitHub Copilot unlocks the following core use cases, each designed to enhance developer productivity and ensure operational excellence:

Incident Response and Root Cause Analysis

Developers can investigate and resolve production failures directly within GitHub by leveraging Dynatrace Davis® AI for real-time problem detection, backend stack trace analysis, and business impact assessment. This provides higher precision in less time, without requiring changes to workflows at other locations.

Deployment impact analysis

The agent validates deployments by comparing pre- and post-deployment metrics, detecting anomalies, and providing data-driven health assessments to ensure smooth rollouts.

Production error triage

Dynatrace systematically monitors and categorizes production errors. Now, with a custom agent, we can prioritize remediation efforts, reduce error backlogs, and improve application reliability directly in GitHub Copilot.

Performance regression detection

Dynatrace continuously monitors application performance baselines, ensuring that any degradation in latency, throughput, or error rates is flagged before it impacts your end-users or breaches service-level objectives (SLOs).

Release validation and health checks

Acting as an automated quality gate, the agent can validate releases, monitor post-deployment stabilization, and ensure compliance with SLOs.

Security vulnerability response and compliance monitoring

Dynatrace integrates security workflows into GitHub, proactively identifying vulnerabilities, mapping them to compliance frameworks, and providing prioritized remediation recommendations

To infinity and beyond

Dynatrace’s custom agent is more than just a tool for many use cases—it’s a powerful toolkit that helps you unlock the full potential of your existing data to uncover the insights you need, precisely when you need them. The use cases we’ve highlighted here are just the beginning. The true power of this integration lies in the dynamic nature of AI, enabling you to search, query, and connect insights across a vast network of agents and platforms. While the journey may take you through uncharted territories of interconnected ecosystems, and it may sound a bit scary at first, there is huge value (and fun!) in turning complexity into clarity and productivity.

Ready to consolidate observability and get answers faster?

Have you already seen the recently launched GitHub custom agents, and are you interested in trying out Dynatrace’s custom agents? Then familiarize yourself with our remote MCP Server and learn how to integrate it into your development landscape.

The post From code to cloud: Dynatrace launches first GitHub custom agent, consolidating observability for developers appeared first on Dynatrace news.

The NVIDIA Enterprise AI Factory addresses the rapidly evolving needs for AI infrastructure to support the rise of agentic AI. Since its launch, customers have leveraged this validated design to build agents by following structured methodology and recommended frameworks, which simplifies deployment and configuration while facilitating the implementation of AI factories in both on-premises and hybrid cloud environments.

Dynatrace has been an integral part of this initiative. Dynatrace full-stack AI and LLM observability helps organizations move forward with confidence in building their AI and agentic AI initiatives.

Observable AI: Turn a black box into a glass box to build confidence

With the publication of comprehensive guidelines, it’s simpler than ever for Dynatrace customers to set up and start monitoring their full-stack NVIDIA enterprise AI infrastructure, including its key tiers and components. Covering the infrastructure layer from GPUs to Kubernetes, NVIDIA NIM microservices, NVIDIA NeMo, and other technologies up to the application layer, Dynatrace observability enables customers to confidently run and operate complex AI workflows on NVIDIA infrastructure.

In parallel, Dynatrace has worked to significantly advance our AI and LLM observability offering by introducing the following:

• A dedicated app experience for AI observability with out‑of‑the‑box analytics, auto‑instrumentation, targeted metrics, a debugging flow, and ready‑made dashboards.
• Data governance and audit trails for AI services, turning governance into a competitive advantage.
• Model versioning and A/B testing to compare model performance across versions.
• Multi-modal agent explainability and tracing throughout RAG pipelines and agentic frameworks.

These improvements address challenges such as missing observability insights, scale, sovereignty, and trust. This empowers organizations to operationalize AI by building trust and monitoring guardrails; providing analytics capabilities to detect user-facing issues; helping SREs and AI-native engineers maintain performance, reliability, and security; and reducing cost across the agentic, AI, and LLM stack.

Privacy and security lead the way to scaling AI with confidence

AI is delivering significant productivity improvements, with 66% of senior executives reporting positive trends in productivity, according to PwC’s AI Agent Survey. This momentum is driving the demand to manage AI expenditures, enhance the decision-making quality of agents, and optimize development through visibility into AI components’ behavior in production environments — from pilot projects to full-scale operations.

However, sensitive data considerations and strict compliance requirements often impede progress, preventing organizations from fully realizing the benefits of AI adoption. As enterprises prioritize data privacy, regulatory compliance, and data sovereignty, there is an increasing need for high-performance NVIDIA AI infrastructure alongside frameworks designed to preserve control, trust, and autonomy in AI development.

In a recent blog on sovereign AI, NVIDIA shares strategies for nations and enterprises to develop AI factories that uphold local governance, security, and cultural values. Combining such factories with the Dynatrace advanced observability solution enables organizations to operationalize AI at scale — building secure and scalable agents, deployed on premises or in hybrid environments.

From privacy needs to public-sector requirements: NVIDIA AI Factory for Government

At NVIDIA GTC Washington, D.C. today, NVIDIA AI Factory for Government was announced, in support of the needs for regulated environments to drive AI initiatives. The U.S. Office of Management and Budget’s decision to establish scorecards for agencies’ AI maturity and management is in line with a 2024 Gartner Research forecast that more than 60% of government organizations will be prioritizing their investments in business automation by 2026 — up from 35% in 2022. The NVIDIA AI Factory for Government is a full-stack, end-to-end reference design that brings the power of reasoning AI to federal organizations. It helps organizations unlock productivity gains just like it does for enterprises, from service delivery to threat detection and day-to-day operations.

Built on the experience of deploying internal AI factories, the reference design offers guidance for deploying agentic AI, physical AI, and high-performance computing workloads on premises and in hybrid cloud environments, while meeting the compliance needs of federal and other secure organizations. The NVIDIA AI Factory for Government reference design includes NVIDIA Blackwell accelerated computing and NVIDIA networking, NVIDIA-Certified Systems, NVIDIA AI Enterprise software, NVIDIA Nemotron open models, and third-party software from AI leaders, all validated by NVIDIA.

Dynatrace delivers trusted observability and automation for regulated environments

Dynatrace has always been committed to supporting the public sector and other industries with regulatory requirements by providing customers with capabilities to control data flow through its lifecycle and manage sensitive data from ingestion to deletion, as well as global deployment options to meet data residency requirements, configurable retention times for different data types and use cases, unique encryption keys for customer’s stored data, and more.

Our dedication is reflected in customers’ success stories from regulated industries, as well as a growing list of global and local certifications, such as ISO 27001, SOC 2 Type II, CSA STAR 2, ENS, Tisax, and others. Find out more about our certifications and supported compliance frameworks in our Trust Center. For organizations also navigating evolving sovereignty requirements, our approach to digital sovereignty demonstrates how Dynatrace combines technical innovation with policy alignment to deliver trusted solutions globally.

Benefit from full-stack observability for end-to-end validated design

Dynatrace observability with the NVIDIA AI Factory for Government reference design enables organizations to accelerate the deployments of their AI agents and applications for federal and enterprise environments, and benefit from real-time, AI-powered insights.

These benefits range from improved scalability and performance to reduced complexity and total cost of ownership by simplifying processes, mitigating deployment risks to improved data security and compliance.

Visit the Dynatrace Playground to experience the possibilities of AI and LLM observability, and discover how Dynatrace is accelerating enterprise AI at scale.

Dynatrace and the Dynatrace logo are trademarks of the Dynatrace, Inc. group of companies. All other trademarks are the property of their respective owners.

The post Unlocking productivity and trust: Dynatrace observability in NVIDIA AI Factory appeared first on Dynatrace news.

The value of automation and agentic AI

The Dynatrace® AI-powered observability and security platform, with its remote Model Context Protocol (MCP) server, revolutionizes this process by integrating observability context into automation and agentic AI-driven workflows. By connecting Dynatrace with GitHub Copilot coding agent, organizations can achieve prioritized and automated vulnerability remediation that not only streamlines security but also maintains system performance and developer efficiency.

Both developers and site reliability engineers (SREs) benefit from this agentic AI collaboration, bringing actionable runtime insights from Dynatrace directly into GitHub and efficiently automating vulnerability remediation.

Automated security remediation with smart runtime verification use case

GitHub Dependabot proactively alerts developers when known vulnerabilities are detected in their projects’ dependencies, helping teams stay secure and compliant. As organizations and projects scale, prioritizing and addressing the alerts becomes a challenge: deciding which vulnerabilities matter most in a given context and streamlining the path to remediation.

Let’s dig deeper into two different scenarios, where Dynatrace can help to improve remediation by automating developer tasks and prioritizing work based on impact.

To optimize remediation efforts and minimize release delays, it’s essential to prioritize vulnerabilities based on their actual impact on production applications.

Dynatrace providing context for automating the remediation of GitHub Dependabot alerts

In a typical environment, when streamlining vulnerability remediation, you might utilize GitHub Actions workflows to regularly poll Dependabot. Once a new alert is detected, the workflow creates a new issue and assigns it to the GitHub Copilot coding agent.

To fully understand the problem and its impact, GitHub Copilot coding agent queries Dynatrace—using the remote MCP server—to get additional runtime data. Dynatrace confirms that the vulnerable library is loaded, and that its own Runtime Vulnerability Analytics (RVA) identifies the same issue and verifies the impact by highlighting if the vulnerable function is used in live environments and if it’s exploitable.

Equipped with the additional context, the coding agent generates a code-level fix. To remediate and prevent insecure code, the fix is added as a pull request to the GitHub repository, awaiting developer review to ensure human oversight.

Once the change is approved and the fix deployed, Dynatrace continuously monitors the environment, verifying the remediation and ensuring the issue is resolved without introducing new problems.

Automate and orchestrate security findings from GitHub Dependabot with Dynatrace Workflows

Unifying and contextualizing vulnerability findings across different tools helps apply prioritization and centralize automation for real-time runtime validation and fix deployment, supporting SREs to minimize potential disruptions to their services.

With the Dynatrace integration for GitHub Advanced Security, you can continuously forward GitHub Dependabot alerts to Dynatrace. Once ingested, Dynatrace uses its capabilities for further analysis, including an RVA verification that provides a contextual understanding of the potential impact on the monitored environment.

The workflow creates a new GitHub issue, including a comprehensive summary of alerts with their confirmation status.

GitHub Copilot Coding Agent automatically picks up the issue and submits the proposed fix for verified alerts as a pull request for a developer to review. This ensures the remediation process remains transparent and allows for human oversight before deployment. Once the pull request is approved and merged, the alert is remediated and the code is secured.

Automated end-to-end security remediation

These two scenarios exemplify how organizations can shift from reactive to proactive security management, automating repetitive tasks and providing actionable insights for developers.

The relationship between Dynatrace and GitHub demonstrates the power of agentic AI in modern software development, where runtime data drives decision-making and empowers coding agents to apply fixes to code environments—all in a standardized way, applying enterprise guardrails.

Reduce your mean time to resolution (MTTR), enhance developer productivity, and ensure robust system security by automating security remediation—all without sacrificing performance or uptime.

The benefits of the coding agent are further amplified with the GitHub announcement of introducing custom agents. Dynatrace has just launched its first custom agent, which seamlessly integrates Dynatrace’s observability and security capabilities into GitHub Copilot, empowering teams to maintain operational excellence, ensure application reliability, and uphold security compliance across the entire software development lifecycle (SDLC).

This allows teams to streamline incident response, perform root cause analysis, validate deployments, triage production errors, and many more use cases—all directly within their GitHub repository workflows.

By delivering real-time insights and actionable data from production environments, Dynatrace extends GitHub’s reach into production, effectively closing the SDLC. Stay tuned for our upcoming blog, where we’ll dive deeper into the powerful capabilities of Dynatrace’s custom agent for GitHub Copilot.

Ready to transform your security workflows?

Explore how Dynatrace can integrate seamlessly into your development landscape using our remote MCP Server and read through our walkthrough documentation.

Sign up for the preview and experience how real-time production context makes your organization more efficient.

The post Hands-free vulnerability remediation with Dynatrace and GitHub Copilot appeared first on Dynatrace news.

The new Dynatrace integration with Atlassian solves this by embedding real-time production insights directly into incident management processes. Teams gain instant visibility into what’s happening, who’s impacted, and the actions required to resolve issues faster — all without the need to switch tools.

Dynatrace uniquely detects problems in real time by understanding topology, data context, and dependencies across your entire digital ecosystem. Incidents are automatically tied to underlying root causes, giving teams a complete, production-accurate, “live” picture of problem details, severity, and impact.

Dynatrace insights are now accessible in Jira Service Management through human-readable summaries generated by Atlassian Rovo. By bringing production context directly into Jira, Confluence, and Jira Service Management, you’ll accelerate response times and significantly reduce mean time to resolution (MTTR).

At Dynatrace, context is our mantra, sitting at the core of everything we do. This means more than just data enrichment: Every piece of data is automatically contextualized, and dependencies are mapped to reveal the full picture. However, context also means delivering the right data exactly when and where you need it. To do just that, Dynatrace is bringing these insights directly into Atlassian. This is not just limited to IT service management (ITSM). You can get access to contextualized insights directly within an IDE as described in our latest blog post about the new Dynatrace  MCP Server.

Diagnose faster with context from production at your fingertips

Most incident tickets land on an engineer’s desk with little more than a timestamp, a vague description, or a user complaint. They rarely reveal the severity of the issue, which systems are affected, or what might be causing it. This lack of context in an ITSM workflow forces teams to spend unnecessary time digging through monitoring dashboards, chasing logs, or switching between tools just to piece together the basics of the problem.

Instead of getting frustrated, you can now instantly ask the Rovo Ops agent to identify anomalies that occurred around the incident timeframe. The agent queries Dynatrace via our MCP Server and returns the findings directly in the same browser window.

Having contextual details and alerts available directly in the ticket context means you gain immediate clarity into health, what’s wrong, the impact, and the evidence. This leads to faster diagnosis and quicker recovery, while also reducing unnecessary escalations of already-known or related issues, ensuring internal resources aren’t tied up with redundant work.

Remediate smarter with AI-driven root-cause analysis and automation

Once an incident is identified, the Rovo Ops agent utilizes Dynatrace production insights, which accelerate triage and root-cause analysis for incident managers, pinpointing the actual root cause in real time and delivering a higher level of insight and accuracy.

Rovo can now pull in Dynatrace Causal AI insights, including the precise root cause and blast radius of the issue, and combines these with Jira Service Management incident and change history. With Dynatrace contextual intelligence, Rovo delivers fact-based, AI-generated problem summaries and clear remediation recommendations, outperforming the guesswork of pure GenAI approaches.

From this point, just follow the remediation recommendation and trigger a suggested automation action in Jira Service Management, or ask follow-up questions for clarification.

Learn for the future with automated post-incident reviews

The job isn’t finished after an incident is mitigated and marked resolved in Jira Service Management, as you still need to capture what happened and determine how to prevent its recurrence. Instead of spending hours on manual write-ups, Rovo automatically triggers the post-incident review (PIR) process.

In the auto-generated PIR, Rovo surfaces all of the relevant details and history, from the root cause to detected anomalies, all of which are enriched by Dynatrace AI-driven insights. This provides a complete, time-ordered view of the incident, which is combined with Jira Service Management context attributes like assignees, tags, outage duration, and related change logs. With this context, the agent generates a draft PIR. Inside the PIR, you’ll find monitoring charts showing the status before, during, and after the incident, a clear summary of the cause, and a pre-filled prevention plan. All that’s left for you to do is review, refine, and finalize the PIR.

The automatically documented PIRs act as built-in retrospectives, helping teams continuously mature their operations. They also feed insights back into Rovo to sharpen its future recommendations.

Transform how you work, beyond incident management

These are just a few examples of what’s now possible through the extended Dynatrace + Atlassian integration. We’ll continue to explore deeper integrations to make your troubleshooting journey even more efficient in the future.

Imagine directly following up on investigations from within Rovo, with seamless drill-downs into Dynatrace® Apps, or surfacing related post-mortem information and runbooks stored in Jira or Confluence to SREs when investigating an issue in Dynatrace.

And the potential impact goes well beyond incident management. By bringing reliable, real-time production truth into daily workflow and connecting that truth directly to business outcomes, more teams and roles can fundamentally transform the way they work, harnessing the full power of agentic AI.

• Get instant release validation: Developers can query Rovo for pre- and post-deployment failure rates, SLOs, and outcome metrics, allowing them to release with confidence, roll back faster when needed, and validate hypotheses with real data.
• Make decisions based on outcomes: Product managers can ask Rovo or Davis CoPilot® to analyze the impact of a new feature or release by investigating KPI shifts such as user engagement or a drop in check-outs.
• Speed up triage based on business impact: Support engineers working on Jira tickets see Dynatrace insights related to the root cause, blast radius, affected applications, and services. These insights are enriched with further details on user and business impact, allowing engineers to perform instant impact analysis before assigning tickets.
• Run smarter daily stand-ups: Development teams receive ready-made summaries, including exceptions, user analysis, and deployment reports from the last 24 hours, providing relevant insights into what’s actually happening in production.

Start benefiting from deeper integrations with Dynatrace as your trusted foundation for agentic AI

Dynatrace delivers a deep, causation-based understanding of your live digital systems, providing the precise, reliable insights that enterprises can trust as a foundation for agentic AI.

Ready to see how Dynatrace and Atlassian work together and benefit from adopting agentic AI concepts? Then dig deeper into the new possibilities using our remote MCP Server and experience how real-time production context makes your operations more efficient.

See our documentation to learn more about how to connect the Dynatrace MCP Server.

The post Dynatrace and Atlassian deliver agentic AI that transforms end-to-end incident management appeared first on Dynatrace news.

Unless you’ve been living under a rock this past year, you’ve heard the buzz about how AI is changing the day-to-day lives of developers, whether it’s using LLMs for vibe coding or adopting agentic AI concepts to improve productivity. In particular, the introduction of Model Context Protocol (MCP) as a standard for connecting AI agents with other agents or tools has led to exponential growth in the number of solutions connecting AI coding assistants with APIs, databases, and more. Last month, GitHub, publisher of the prominent AI coding assistant GitHub Copilot, announced its new MCP registry as a place where developers can find links to MCP servers. This registry solves the challenge of numerous registries, repos, or community threads listing the same MCP servers.

We’re excited to share that the GitHub MCP registry now includes Dynatrace MCP, so developers can integrate Dynatrace observability and security analysis directly into their workflows.

In this blog post, we’ll explore how developers can use Dynatrace MCP together with GitHub Copilot to streamline troubleshooting, enhance security, and boost productivity—without ever leaving their IDEs.

Need to troubleshoot an issue? Dynatrace MCP has the answers

One of the biggest challenges in troubleshooting and observability is knowing where to look for missing data when issues arise in production. It might sound odd, but when you consider the sheer number of tools, applications, environments, and layers of source code developers need to navigate, it’s not at all clear where they should look for quick answers. No wonder onboarding time is such a major factor in engineering productivity.

Your day as a developer might start with a complaint about something not working correctly. You receive a Jira ticket with a cryptic error message that includes a link to a service health dashboard or a notification in the problem list. You start rummaging through the logs and dashboards to find answers outside your IDE, with little context. This greatly increases your cognitive load and delays the problem’s resolution.

Developers who use Dynatrace, though, don’t have to manually dig through logs and dashboards. They get clear summaries, root cause information, and all relevant data in the context of the affected service. Thanks to the updated problem flow, it’s easy for them to identify the root cause and remediate it.

Context is key

Now imagine a scenario in which your DevOps team uses MCP as their standard for integrating external tools and insights. As a developer, your instinct is to jump straight into the source code, so why not share as much context as possible right there? Utilizing GitHub Copilot with the Dynatrace MCP integration in place, you get all relevant data from your production environment and quickly isolate the problem, giving you the ability to:

• Get information on the root cause
• Query related logs, metrics, and traces
• Get real-time data from all environments, including production
• Leverage additional gathered insights, such as CPU and memory profiling, from the affected service
• Get further context using query patterns, such as “group logs by customer impact”

And the best is, you don’t need to know how or where to look—Dynatrace handles all this for you automatically. And there’s more: you can even ask Dynatrace for remediation suggestions.

_{Figure 2. Dynatrace identifies the problem root cause as an arithmetic exception, all via LLM and the MCP protocol in the developer VS Code IDE. (video)}

What’s happening behind the scenes

When you type a natural language prompt into the GitHub Copilot chat, GitHub’s MCP client establishes a connection with the Dynatrace MCP server, which then connects to Dynatrace. The LLM converts the prompt into a context-aware call and ultimately transforms it into a DQL query that it executes on Dynatrace Grail® data lakehouse, which retrieves the necessary data.

Need to fix a security issue? Dynatrace MCP has the answers

By integrating security testing practices earlier in the Software Development Lifecycle, the Shift-left principle has brought security responsibilities into the developer’s world, and they’re here to stay. Developers often find themselves reacting to alerts from SREs, manually auditing code, or relying on static analysis tools that frequently miss context-specific vulnerabilities.

You can instantly access insights like:

• Vulnerabilities in your code, including open source and third party vulnerabilities
• Recommendations for fixing an issue
• Proactive checks tailored to your current coding context

All of this happens without pulling developers away from their flow. MCP allows for a smarter, more proactive approach to security—one that’s embedded in their development process.

Need to create new code? Dynatrace is here to help

Writing new code with Dynatrace allows developers to look ahead proactively. By typing natural-language, conversational questions like “Have I bumped into CPU limits?” or “What is my CPU usage? Is it too high?” developers can identify potential bottlenecks and performance issues before they become real problems, ultimately delivering higher quality code.

Developing new code or optimizing a service in an existing app brings even more complexity. Such work involves identifying inefficient API usage, reducing unnecessary load, improving performance, and assessing the potential impact of the new code so as to minimize deployment issues.

Need to verify recent CICD builds? Dynatrace helps you shift left

As a developer, you want to catch build issues early—before they snowball into deployment delays or production incidents. With Dynatrace MCP, you can type questions like:

• “What failed in the last build?”
• “Are there any performance regressions tied to this commit?”
• “Did this deployment introduce any anomalies?”

By integrating Dynatrace into your CI/CD pipeline, you gain real-time visibility into build health, test coverage, and deployment impact. This means faster feedback loops, fewer surprises, and higher delivery quality. Dynatrace helps you to shift from reactive debugging to proactive delivery assurance—all through natural language interactions.

Get started with Dynatrace MCP

The Dynatrace MCP server is available as a community-supported open source project. To familiarize yourself with all it can do, visit the Dynatrace MCP project. in our GitHub repository. There you’ll find all the necessary documentation to guide you through the setup process and explain all the available capabilities.

The post Sky-high developer productivity with Dynatrace MCP and GitHub Copilot appeared first on Dynatrace news.

Agentic AI is revolutionizing—and dramatically accelerating—how engineering teams respond to incidents and debug use cases. By monitoring how AI agents communicate using standards such as Model Context Protocol (MCP), performance engineers can gain deep insights into how systems and AI models themselves are performing. And crucially, automate incident responses using coding assistants.

The next step in this scenario is to employ some MCP best practices, such as helping full-stack engineers to debug code at runtime without disrupting operations. Fortunately, Dynatrace has the answer with Live Debugger. First debuted earlier in 2025, Live Debugger gives developers instant access to code-level troubleshooting data in any environment, including production, and is now generally available.

With all these capabilities coalesced in an integrated development environment (IDE), developers can interact with AI using natural language to massively accelerate issue resolution.

Key takeaways:

• Unify AI debugging resources in one place. Debugging agentic AI workflows starts with combining Dynatrace features with custom MCPs in an IDE.
• Leverage an AI coding assistant to add context. An AI coding assistant, such as Cline, helps add vital context and improve prompt engineering using natural language queries.
• Use best practices to configure MCPs and Cline. Combining Cline with MCPs and on-the-fly debugging reduces guesswork and manual overhead.

MCP best practices TELUS uses to accelerate incident response

As an early adopter of Dynatrace Live Debugger, TELUS harnessed the power of Davis® AI, MCP, and real-time debug data to gain a deep understanding of their code, enabling every engineer to ask questions in natural language about their code behavior at runtime.

At a recent Dynatrace Guild meeting, TELUS SREs Dana Harrison and Cheng Li demonstrated how they’re combining Dynatrace features like Live Debugger with custom MCPs for the ultimate purpose-built troubleshooting setup in their Visual Studio Code IDE. By integrating multiple resources in one place, the TELUS team can blend next-generation debugging with agentic AI workflows. This integration reduces developer context-switching and enables developers to use straightforward, natural-language prompts.

With a fully instrumented environment that monitors every service end-to-end, the TELUS team leverages Dynatrace Live Debugger for Node.js and Java microservices to monitor running code in real time to reduce mean time to resolution. They initially tested this approach in non-production but are expanding into production with strict auditing and data masking.

The team also uses MCP in tandem with Cline AI, a coding assistant capable of gathering logs, metrics, and trace data through natural language commands. By unifying multiple data sources under MCP, TELUS avoids manually juggling different dashboards and tools. Developers can simply interact with the AI tools, which fetch relevant context on demand, even correlating Live Debugger snapshots with real-time logs. As a result, the entire debugging and incident investigation process remains inside the IDE, which significantly streamlines performance engineering and accelerates issue resolution.

How MCPs empower AI agents for debugging use cases

As an open standard, MCP connects AI agents to relevant data sources, such as repositories, tools, or external APIs. Instead of bespoke integrations for each data silo, MCP provides a universal interface to connect multiple relevant sources to feed the right context to the models and agents. This interface simplifies how agents access relevant context, leading to better task outcomes, execution, and more consistent performance across complex environments. For reference, you can try out the Dynatrace MCP server on GitHub.

MCP best practices: How Cline AI helps to bring in context

Cline AI is a coding assistant in Visual Studio Code that leverages multiple MCP servers to streamline data retrieval from various back-end systems. With plain-language queries (“Search for a specific service,” “Fetch logs from GKE,” or “Investigate errors”), developers can prompt Cline AI to automatically contact the relevant MCP server.

By becoming better at prompt engineering and handling the underlying API calls and correlating responses from Dynatrace MCP, native Kubernetes logs, or even third-party services, Cline AI provides an all-in-one investigation workflow right in the editor. This means developers don’t have to switch among multiple tools or memorize specialized APIs; they simply ask Cline AI what they need in natural language, and the MCP layer manages the rest.

Cline supports MCP-client features, such as dynamic tool discovery, prompt reusability, and adaptive resource access. It also enables powerful features like custom instruction, cline-rule, and memory banks.

TELUS’ best practices for configuring MCPs and Cline

The TELUS team followed these MCP best practices while configuring Cline.

Install Cline AI as VS Code extension

First, the TELUS team installed Cline AI as a VS Code extension, pointing it to their AI proxy, Fuel iX. Fuel iX lets them choose among various large language models based on the user’s requirements and desires.

Use careful prompt engineering and Cline rules to direct specific MCP tools

Cline AI can then interpret a developer’s natural-language prompt—such as “Investigate errors in our Node.js service”, “What is this service about”—and select the appropriate MCP endpoint(s) to gather data. Directing to specific MCP tools for more accurate results can be fine-tuned through careful prompt engineering, creating detailed .clinerules file definitions, and directives built into the MCPs themselves – including predicted requests and response formatting.

Configure each MCP server for a specific data domain

Each MCP server at TELUS is responsible for interacting with a specific data domain: for instance, they have a Dynatrace MCP server to fetch metrics and trace data, a GCP Logs MCP server to pull container and other forwarded logs, and additional servers for services like JIRA issues or PagerDuty.

Rely on centralized agentic AI commands, not vendor-specific APIs

By standardizing how these data sources are exposed, TELUS ensures that Cline AI never has to manage direct integrations or vendor-specific APIs. Instead, the assistant simply issues commands to the MCP servers, which internally handle authentication, query templates, and data normalization. This architecture not only allows TELUS to maintain clear boundaries between data retrieval logic and AI-driven workflows, but also accelerates developer onboarding, making it simple for any team member to debug or investigate issues from within VS Code by asking Cline AI, rather than switching between specialized tools or dashboards.

​​Use MCPs as a standardized endpoint

​In this context, MCP servers act as standardized endpoints, each responsible for a particular data source or application. By relying on Cline for coding assistance, the TELUS team can type a natural-language command (“Investigate issues in our Node.js service”), and Cline will automatically query Dynatrace Grail or GKE logs using the relevant MCP server.

This approach centralizes the complexities of data retrieval in one place and lets the AI assistant produce a consolidated summary or recommended fix, all within the IDE.

Step-by-step guide to set up Cline with Dynatrace

1. Install Cline through the VS Code Marketplace.
   
2. Configure Cline with the required credentials, usually an API endpoint and key.
   
3. Install your MCP. This example uses an internal package, but there are currently many MCPs published for installation.
   
4. Validate that the Dynatrace MCP server is up and running.
   
5. Ask Cline your questions. The agent formats them according to the needs of the MCP(s) you installed.
   
6. Example response of a production authorization service problem pulled and summarized from Dynatrace.
   

The objective of this combined setup (Live Debugger + MCP + Cline) is fast and intelligent troubleshooting. Instead of juggling multiple dashboards and CLI tools, an engineer can see code snapshots, error traces, logs, and even recently created JIRA tickets within one session. As mentioned, MCP standardizes queries across diverse systems, so the AI agents can correlate all relevant information, such as referencing a single trace ID to pull logs from GKE, configuration details from the Kubernetes cluster, or known issues in PagerDuty. This AI agent-powered workflow saves time and reduces context switching.

The TELUS team found that combining these insights with on-the-fly debugging significantly reduces the guesswork and manual overhead that typically slows resolution times.

The road ahead: Developer-first observability and IDE-centric debugging at TELUS with Dynatrace

Although TELUS currently uses Live Debugger in mostly non-production environments, they plan to enable it in production using strict governance. Their upcoming strategy involves role-based permissions for debugging sessions, mandatory security training on data privacy, and well-defined data retention policies to keep snapshots transient.

When combined with MCP’s universal integration points, like Dynatrace MCP, developers can quickly drill down into real production issues, see the exact variables at fault, and either push a fix or revert a misconfiguration with minimal downtime.

Looking ahead, the TELUS team plans to integrate Davis Copilot APIs to further simplify natural language interactions with Dynatrace.

In practice, this would allow an AI assistant to automatically translate human-readable queries into Dynatrace Query Language (DQL), making it even easier to retrieve the right metrics, traces, or logs. By layering Davis CoPilot™ on top of their existing MCP approach, TELUS aims to reduce manual DQL writing while offering developers a powerful yet streamlined way to perform more advanced data analysis through simple, intuitive prompts.

Read more

• Part one of the Rise of Agentic AI blog series covers the fundamentals of AI agents, models, and emerging communication standards such as Agent2Agent (A2A) and MCP.
• Part three explains how to monitor Amazon Bedrock Agents and how observability optimizes AI agents at scale.
• Part four covers full-stack observability for AI with NVIDIA Blackwell and NVIDIA NIM.
• Part five demonstrates how to build a simple agentic application using the OpenAI Agents SDK and instrument the data with Dynatrace.
• Part six explores AI Model Versioning and A/B testing for smarter LLM services.
• Part seven introduces data governance and audit trails for AI services.

More MCP best practices and resources for Dynatrace Live Debugger

• Dynatrace MCP on GitHub
• Dynatrace Live Debugger on Dynatrace Hub
• Dynatrace for Developers Visual Studio plugin on Microsoft Marketplace
• Dynatrace for Developers product page
• Dynatrace Automation Guild on the Dynatrace Community
• 5 powerful use cases beyond debugging for Dynatrace Live Debugger
• Debug complex performance issues in production with ease with Live Debugger, Open Pipeline, and OpenTelemetry

The post The rise of agentic AI part 2: Scaling MCP best practices for seamless developers’ experience in the IDE with Cline appeared first on Dynatrace news.