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.

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.

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.