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.

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

Why are MCP applications so valuable to Developers?

A picture is worth a thousand words

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

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

Dynamic visual results

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

Actionability built in

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

Human verification

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

MCP App architecture

MCP extension protocol integration

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

Tool-to-UI binding

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

Data flow

Structured output parsing

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

Real-time client-side rendering

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

Single-file bundling

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

See it in action

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

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

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

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

What about security?

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

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

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

Get started

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

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

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

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

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

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

Your agentic partner helps you gather insights

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

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

Multi-step reasoning that understands your environment

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

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

From incident to remediation in a single flow

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

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

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

Explain raw data with actionable insights

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

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

Identify and respond to critical vulnerabilities

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

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

Prompts used in this use case:

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

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

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

Ask. Analyze. Act.

And start today with Dynatrace Assist.

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

As agentic AI becomes mission-critical, systems that reason, act, and self-optimize introduce new operational challenges. Their dynamic and non-deterministic behavior makes them difficult to debug, they can drive unexpected cost spikes, and they inherently lack the auditability required for reliable, enterprise-grade use. Today, we’re excited to announce expanded support for leading agentic frameworks and protocols, along with a new dedicated AI Observability app. With this support, you can build, run, and debug agentic AI applications with confidence across AWS, Azure, and Google Cloud.

What’s new: Broader agentic technology support

Dynatrace supports a broad and rapidly growing ecosystem of agentic AI frameworks and protocols, unifying telemetry from these frameworks via OpenTelemetry and OpenLLMetry into a single, correlated observability model, delivering end‑to‑end visibility across clouds, models, tools, and agents from one platform.

• Amazon Bedrock AgentCore – Dynatrace offers observability for Amazon Bedrock AgentCore agents by collecting metrics such as token usage, model behavior, latency, and errors. This integration provides unified tracing, cost, performance, and guardrail monitoring, along with ready-made dashboards and intelligent anomaly detection and forecasting, helping teams quickly and effectively monitor, troubleshoot, and optimize complex autonomous agent workflows.
• Amazon Bedrock Strands – Dynatrace supports the Amazon Bedrock Strands Agents SDK, enabling comprehensive visibility into agentic AI systems. By instrumenting Strands-based AI agents with Dynatrace, organizations can monitor agent behavior, tool usage, and dependencies end to end. This helps ensure performance, reliability, and operational insight across distributed environments, supporting the confident development and operation of agentic AI use cases such as chatbots, recommendation systems, and autonomous workflows.
• LangChain Agents – Dynatrace provides observability for applications built with the LangChain framework, enabling the monitoring of performance, cost, and reliability of Large Language Model (LLM) applications and agents.
• Google Agent Development Kit (ADK) – Dynatrace provides observability for applications built with the Google Agent Development Kit (ADK), enabling visibility into agent execution, dependencies, and performance. This helps teams understand runtime behavior and maintain reliability as agent-based applications
• OpenAI Agents SDK – Dynatrace provides observability for observing applications built with the OpenAI Agents SDK, enabling monitoring of agent workflows, model interactions, latency, and errors. This supports improved operational insight, troubleshooting, and performance optimization for agentic AI applications.
• MCP AI Agent–  Dynatrace provides deep visibility into AI agents communicating via the Model Context Protocol (MCP). By observing both AI agents and MCP servers, organizations gain end-to-end insight into execution flows through tracing, enabling data-driven decisions, performance and cost optimization, and governance for complex agent workflows.

This agentic coverage is on top of the 40+ LLM technologies that Dynatrace already supports, including OpenAI, Amazon Bedrock, Google Gemini and Vertex, Anthropic, LangChain, NVIDIA, and more.

We’re working closely across AWS, Microsoft Azure, and Google Cloud ecosystems to ensure you have consistent, enterprise‑grade observability for your multi‑AI and multi‑cloud applications.

See it in action in the new AI Observability experience

The AI Observability app is now Generally Available, delivering a purpose-built experience for observing AI workloads end-to-end from agents and LLMs to orchestration layers, emerging protocols, and tools. It gives engineering teams deep, production-ready visibility into how AI systems behave in real time, allowing them to validate changes faster, reduce risk, and confidently ship AI-powered features at scale.

Unlike generic observability views, the AI Observability app is designed specifically for agentic and LLM-driven systems, making it easy to understand complex multi-step interactions, reason about cost and performance trade-offs, and troubleshoot issues across models, tools, and dependencies.

Key capabilities

• End‑to‑end observability for agentic AI
  • Monitor agent interactions, tool usage, dependencies, latency, and reliability
  • Track token consumption, cost trends, and caching impact
• Tracing and debugging for complex flows
  • Follow prompts, tool calls, and model invocations from the initial request to the final response
  • Jump from high‑level health to prompt‑level traces in a couple of clicks
• Actionable insights at scale
  • Rapid A/B testing across model and prompt variants for faster validation
  • Identify bottlenecks and optimize resource utilization with ready‑made dashboards and drill‑downs
• Security, privacy, and governance
  • Enterprise‑grade controls, auditability, and policy‑aligned routing
  • Guardrail outcomes (for example, toxicity, PII, or denied topics) are surfaced so you can monitor behavior and trends. (Note that guardrail enforcement occurs at the model/provider; Dynatrace captures and visualizes provider‑reported outcomes.)

Who this solution is for and why it matters

The Dynatrace AI Observability solution is for enterprise teams, including developers, DevOps, SREs, and business leaders who need deep, real-time insights into their cloud native  AI-powered applications and customer experience in a single unified view.

Who benefits the most from this solution?

• AI Engineering and Data Science: This group includes practitioners who develop and optimize models. They use LLM observability to track metrics related to model performance, such as identifying hallucinations and biases, validating changes, and improving prompt engineering practices.
• Software Developers: These individuals benefit from observability by gaining insights into application-level performance, which helps them debug and improve overall code quality. Observability tools allow for faster iteration in development cycles.
• Site Reliability Engineers (SRE): These teams ensure the reliability and performance of AI applications in production environments. They use observability to identify system-level bottlenecks and failures, and to respond swiftly to operational challenges.
• Application Security Teams: Although not traditionally the primary users, security teams can leverage AI observability to identify and mitigate emerging threats specific to AI applications, such as prompt-injection attacks and data leaks.
• Compliance and Governance Teams: Responsible for ensuring adherence to regulatory requirements and internal policies, these teams rely on observability to audit model behavior and to identify potential biases or harmful outputs.

What’s next: Agent topology view with Smartscape

We’re committed to further enhancing these capabilities. As agentic systems evolve into distributed networks of models, tools, and decisions, observability must move beyond traces and metrics. Our next focus is the Agentic Topology View, bringing Smartscape-grade visualization to agent execution flows so teams can see how agents interact, invoke tools, propagate errors, and improve performance end to end.

This agentic topology becomes the foundation for a deeper developer experience by connecting production telemetry with prompt management and evaluation workflows. By unifying agent topology, prompt lifecycle, and LLM-as-judge scoring in a single system, we’re helping teams systematically improve the reliability, performance, and quality of agentic AI at enterprise scale.

Get started today

• Install the AI Observability app from Dynatrace Hub
• Instrument your agents via OpenTelemetry/OpenLLMetry
• Start tracing prompts, tool calls, and model invocations—and turn insights into action

The post Announcing agentic framework support and General Availability of the Dynatrace AI Observability app 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.

You know that moment when everything should be working, but it’s just not? Your deployment went smoothly, the pods are running, and yet — errors. Lots of them.

That’s exactly where I found myself recently. The EasyTrade application was throwing fits, and I needed answers fast. What made this debugging session different, however, was the combination of tools at my disposal: Dynatrace intelligent monitoring paired with the raw power of Gemini CLI accessing the Dynatrace MCP server.

The fact that Gemini CLI can communicate directly with Dynatrace through the MCP protocol means I can stay in my flow. I’m not jumping between tools, losing my train of thought, or rebuilding mental context every few minutes. I ask questions in natural language, and Gemini translates that into precise DQL queries against Grail.

Let’s walk through two tales from the terminal: one about an impatient service, and another about a phantom error that taught me patience.

The impatient service that couldn’t wait

When detection meets investigation

I started my day firing up my email and my terminal. Dynatrace flagged the first problem before I’d even finished my coffee. A notification in my inbox let me know the contentcreator service was experiencing a stuck deployment.

Now, here’s where things get interesting. Dynatrace identified what was broken, but I wanted the gritty details and potential solutions. This is where Gemini CLI comes in clutch.

Instead of clicking through UI panels — nothing wrong with that, by the way — I fired up my terminal and started a conversation with Dynatrace via the Gemini CLI. Think of it as having a debugging buddy who speaks fluent Dynatrace Query Language (DQL) and can pull data from Dynatrace Grail® faster than you can say observability.

As you can see, I asked Gemini to tell me more about the problem. The results were crystal clear. Every log entry showed the same error:

"com.microsoft.sqlserver.jdbc.SQLServerException: The TCP/IP connection to the host db, port 1433 has failed. Error: "Connection refused. Verify the connection properties. Make sure that an instance of SQL Server is running on the host and accepting TCP/IP connections at the port. Make sure that TCP connections to the port are not blocked by a firewall."

The race nobody wins

Here’s the thing about microservices: They’re like orchestra musicians warming up. Everyone’s eager to start playing, but if the conductor — in this case, the database — isn’t ready, you get chaos instead of symphony.

The contentcreator service was starting up and immediately trying to connect to the database. However, SQL Server inside the db pod needed a few extra seconds to initialize. Classic startup race condition. The contentcreator service was essentially knocking on a door that hadn’t fully opened yet.

The fix? Kubernetes startup probes. These probes are brilliant; they’re like a bouncer at a club, making sure nobody rushes in before the venue is ready.

Gemini CLI modified the db service deployment manifest to include a readiness probe that would execute a simple SQL query. The container wouldn’t be marked as “running” until it could successfully respond to that query. Simple, elegant, effective.

I went from error to root cause to the recommended solution to fix, all without leaving the terminal.

After applying the updated manifest and restarting the pods, I turned back to Gemini CLI to run the same log query against the fresh manager pod. Just like that, the database connection errors were gone.

The phantom error and the deployment maze

New problem, different beast

Just when I thought I could relax, Dynatrace surfaced another issue. This time, it was the credit-card-order-service showing a failure rate increase. Different service, different problem. Same reliable detection system.

Back to Gemini CLI.

I pulled up a list of current problems. Gemini knew the resource contention issues we were seeing were expected, but Dynatrace flagged something else — a problem with multiple services impacting 98 users. That one needed our attention.

Gemini was able to immediately determine that the issues were caused by a feature flag and recommended we turn that feature flag off and even updated and applied the manifest for us. Easy peasy.

After deploying the updated feature flag, I remained in Gemini CLI to verify the fix. The logs were clean — no more ArithmeticException. Within minutes, Dynatrace had correlated the fix across all affected services and automatically closed the problem. Once again, the whole workflow — from detection, to investigation, to fix, to verification — happened without me leaving my terminal.

A single workflow in a single place

The synergy between Dynatrace and Gemini CLI isn’t just about having two good tools. It’s about having the right tool at the right time in the right place.

Dynatrace excels at the big picture. It detects anomalies, correlates issues across your entire application landscape, and surfaces problems you didn’t even know existed. It’s your early warning system.

Gemini CLI, connected through the Dynatrace MCP server, lets you query Dynatrace without leaving your terminal. Look, the web UI can do all of these same things and then some — dig into logs, build DQL queries, verify fixes, show pretty dashboards. But when you’re already neck-deep in terminal work, staying put is the move. No alt-tabbing. No mental context switching. Just you, your terminal, and your data.

And here’s where it gets even better: Gemini CLI isn’t just passive. It’s agentic. It suggests fixes, modifies manifests, and can even deploy changes on your behalf. You saw this in action with both problems we tackled: Gemini recommended the readiness probe solution and updated the deployment manifest. It identified the feature flag issue and applied the fix.

The takeaway

Both of these troubleshooting sessions taught me something valuable. The startup race condition showed me the importance of proper initialization ordering in Kubernetes.

But the biggest lesson was to trust your tools but understand what they’re doing. When Dynatrace takes a few minutes to close a problem after you’ve verified the fix, it’s not lagging — it’s being thorough. It’s analyzing patterns, checking for recurrence, and making sure you can confidently move on to your next task.

The combination of intelligent monitoring and command-line power creates something greater than the sum of its parts. Dynatrace watches everything, spots the problems, and shows root cause. Gemini CLI lets you investigate and address those problems without breaking your flow. Together, they make troubleshooting feel less like detective work and more like having a conversation with your infrastructure.

And that morning cup of coffee? It actually stayed warm this time.

The post When your service won’t wait: Troubleshooting EasyTrade with Dynatrace MCP and Gemini CLI 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.

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

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

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

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

Enterprise-grade governance for real-world use cases

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

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

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

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

AI Observability for continuous insights after deployment

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

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

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

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.

Teams can transition from setup to insights in minutes using a lightweight OTLP configuration and ready-made dashboards.

Agentic observability is evolving

Agentic AI systems are quickly moving from proof-of-concept to production, giving customers the ability to automate complex workflows, invoke a variety of different tools and APIs, and coordinate tasks across multiple services. However, traditional monitoring overlooks critical AI-specific signals, such as token consumption, model behavior, and guardrail outcomes. Teams struggle to trace non-linear agent flows, establish baselines for dynamic systems, and maintain predictable costs as usage scales. Without purpose-built observability, organizations risk degraded experiences, higher costs, and compliance gaps as agent complexity grows.

As agentic AI moves from pilot programs to production, organizations are automating complex, cross-system workflows with Amazon Bedrock AgentCore. However, most monitoring stacks weren’t designed for emergent, tool-driven behaviors and, therefore, leave blind spots around correctness, safety, and cost. Teams struggle to trace non-linear flows, establish baselines for dynamic systems, build agentic workflows, and keep token-driven spend under control as usage scales.

The observability gap in AI agent deployments

While AI agents offer significant benefits, including improved employee productivity, increased efficiency, and competitive advantage, among others, an observability gap remains, creating the following challenges:

• Complex multi-step workflows
  AI agents run non-linear, multi-system sequences with inter-agent dependencies, making data flow and responsibility hard to trace. This obscures where time is spent and who is responsible for failures in the chain.
• Limitations of traditional metrics
  Basic operational metrics often overlook AI reasoning errors and quality issues that don’t significantly affect CPU or p95 latency. Without AI-specific telemetry, subtle degradations often slip through.
• Continuous underlying agent and LLM model version changes
  Your system might be robust today, but upstream model and version updates can alter behavior, latency, and costs, forcing continuous adaptation to prevent regressions and incidents. Proactive detection of model-induced changes is crucial to maintaining stable quality and safety over time.
• Scalability and quality challenges
  As deployments grow, telemetry volume and coordination overhead surge while token usage and API calls remain untracked. This breaks cost predictability and quality control, leading to issues such as hallucinations and model drift. Multi-agent logic evolves constantly, so “normal” is a moving target. Baselines drift, complicating anomaly detection and root-cause analysis.

Without addressing these challenges, organizations face risks, from degraded user experiences and spiraling costs to compliance violations and reputational damage.

New enhancements for teams building with Amazon Bedrock AgentCore

The new Dynatrace AI Observability app embeds Amazon Bedrock AgentCore observability into a dedicated end-to-end experience, featuring out-of-the-box analytics, auto-instrumentation, targeted GenAI metrics, debugging flows, and ready-made dashboards to address all observability gaps in agent deployments. Support is available for over 20 technologies, including Amazon Bedrock, OpenAI, Gemini/Vertex, Anthropic, and LangChain.

These enhancements enable teams to take advantage of the following benefits:

• End-to-end distributed tracing
  Trace every interaction from user prompt to model reasoning to tool calls, so you can pinpoint bottlenecks, errors, or costly loops in seconds. Filter by model, provider, token usage, latency, and more to accelerate root-cause analysis.
• Enriched GenAI telemetry data, out of the box
  Each LLM and tool invocation emits spans with prompts, completions, token counts (for both prompts and completions), finish reasons, model IDs, latency, and errors, utilizing GenAI semantic attributes. Orchestration layers (for example, actions, HTTP durations, and step names) are captured for the complete workflow context.
• Cost, performance, and safety insights
  Use intelligent forecasting to detect cost and performance anomalies in token consumption and latency. Monitor guardrails for toxicity, PII, and denied topics to build trust and meet compliance requirements.
• Simple OTLP setup, fast time to value
  AgentCore already emits telemetry; simply register the OpenTelemetry export to Dynatrace once. Use your Dynatrace OTLP endpoint and token, and you’re streaming signals into the Dynatrace Grail® data lakehouse with no code rewrites. Ready-made dashboards for Amazon Bedrock let you verify ingestion and gain instant insights.

What’s next

We’re investing in a deeper Amazon Bedrock model and provider insights, expanded guardrail analytics, and additional automation so you can attach remediation playbooks to cost or safety anomalies.

Additionally, we’ll introduce a new agent visualization and topology experience that visualizes your AgentCore agents, LLM services, tool backends, and dependencies, allowing you to understand real-time topology and data flows across the entire stack.

Navigate from the topology map to traces to follow agent behavior step-by-step across services, protocols, and external calls, pinpointing hotspots, ownership, and blast radius more quickly.

Expect tighter integrations with popular orchestration frameworks and more dashboards for common agent patterns, such as retrieval, multi-agent collaboration, and tool-heavy workflows.

Get started with Dynatrace AI Observability for Amazon Bedrock AgentCore agents

Ready to learn more? Have a look at our GitHub repository.

Start instrumenting your agents today. Open the Amazon Bedrock AI Observability dashboard in Dynatrace to verify telemetry and begin your analysis.

The post Announcing Amazon Bedrock AgentCore Agent Observability 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.

Debug, optimize, and secure your AI models with confidence

As agentic AI applications and systems gain traction, delivering reliable, high‑performing LLMs and agents becomes challenging due to heterogeneous stacks, non‑deterministic behavior, and cost sensitivity across multi‑cloud runtimes. Reliable delivery and deployment to production requires end-to-end telemetry across the full chain:
UI/services → orchestration/agents (LangChain, LlamaIndex, MCP/A2A) → RAG pipeline (embedding + vector DB) → model gateway (OpenAI, Azure/OpenAI, Bedrock, Gemini, Mistral, DeepSeek) → GPU/infra. To support deterministic rollouts and continuous model improvement, teams need standardized tracing/metrics, guardrail signal capture, and automated cost and performance governance.

The hidden challenges of AI model management

The invisible bottlenecks

AI models, especially LLMs, are prone to issues like hallucinations, degraded performance, and incorrect outputs. Debugging these problems is often like finding a needle in a haystack. Existing tools fall short in providing a unified view to compare prompts, datasets, or model versions, making it hard to identify regressions or improvements.

Navigating the risks of rapid model evolution

The impact of deprecation and automatic upgrades on cost, performance, and quality

The rapid pace of innovation in the AI space means that providers like OpenAI and Anthropic frequently release new versions of their models, such as ChatGPT 5 or Anthropic Opus 4.1.

While these updates often promise better performance and new capabilities, they can also introduce significant risks for your AI services:

• Deprecation of older versions: Providers may discontinue support for older models, forcing you to adopt newer versions without sufficient time to test their impact.
• Automatic upgrades: Many AI providers automatically update their underlying models, which can lead to unexpected changes in behavior, degraded performance, or even broken workflows.
• Compatibility issues: Changes in model behavior, such as output format or token usage, can disrupt your application’s functionality, requiring adjustments to prompts, configurations, or integrations.

Tracking token usage and managing costs is another uphill battle. Add to this the risk of prompt injection attacks and data leaks, and it’s clear that traditional methods are no longer sufficient

The new AI Model Versioning and A/B testing

Ship better models with confidence. In a single view, compare models and versions to validate improvements and spot bottlenecks across latency, reliability, token usage, cost, and output quality, then drill into prompt-level differences to confirm why a variant wins. When something breaks, follow the request end to end with distributed tracing: from input through orchestration steps and model calls to completion, so you can pinpoint exactly where an error or slowdown originated.

Compare models and versions: Detect bottlenecks and validate improvements in a single view.

Trace prompt failures: Debug errors from input to output with our Distributed Tracing solution.

Monitor costs and token usage: Gain real-time insights into token consumption and cost implications.

Detect security and guardrail risks: Identify and alert on vulnerabilities like prompt injection attacks, toxic responses, or captured PII.

Attach your own attributes like user session, feedback, or dataset ID for additional debugging information.

How it works

With AI Model Versioning, you can track metadata such as model version, dataset ID, and hyperparameters.

A/B testing lets you expose different user segments to model variations, providing data-driven insights into performance metrics like accuracy and cost.

Instrument in minutes: Use the supported OpenTelemetry-based SDK to instrument your service to capture prompts, completions, token usage, errors, and guardrail signals.
You can also enrich spans with attributes like model.version, dataset.id, user/session, and feedback for deeper analysis. (You can read more about this here.)

Start analyzing out of the box: Once data is flowing, the AI Observability app provides ready-made dashboards and distributed tracing so you can compare models/versions, monitor costs and tokens, and debug prompt failures end to end. No extra setup is required; you can try it out on the Dynatrace Playground right now.

By combining observability, AI-driven insights, and organizational knowledge, we’re enabling systems that don’t just react but learn and adapt. Each critical issue or incident you resolve fuels a living knowledge base, paving the way for proactive incident prevention through alerting.

What’s next?

We’re committed to enhancing these capabilities further. Upcoming updates will include a dedicated app experience for multi-model and multi-cloud setups, advanced visualization tools, enhanced security features, intelligent forecasting, and alerting for cost/performance and guardrail optimization.

Get started today

Ready to revolutionize your AI services? Here’s how:

1. Sign up for a free trial.
2. Install the AI Observability app.
3. Explore the AI Model Versioning ready-made dashboard, or check it out on our playground

Together, let’s build smarter, more reliable AI systems.

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 two of the Rise of Agentic AI blog series explores AI agent observability and monitoring, A2A and MCP communications, and how to scale and monitor Amazon Bedrock Agents.
• 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 seven introduces data governance and audit trails for AI services.

The post The rise of agentic AI part 6: Introducing AI Model Versioning and A/B testing for smarter LLM services appeared first on Dynatrace news.

As software systems grow increasingly complex, developers need powerful tools that can seamlessly integrate various platforms and services. Amazon Q Developer CLI has revolutionized AI-assisted development by bringing intelligent code assistance directly to your terminal. Now you can use Model Context Protocol (MCP) to bring real-time observability data directly from Dynatrace into your workflow,

Whether you’re a developer, DevOps engineer, or SRE, this integration will help you make more informed decisions faster. Through simple natural language queries, you can monitor application performance and access logs, identify issues, and automate common observability tasks across both AWS and Dynatrace platforms, without leaving the terminal or your IDE of choice.

Let’s dive in and see how you can leverage the full potential of Amazon Q Developer CLI and Dynatrace MCP server in your development process. Read on to learn how to:

1. Configure Amazon Q Developer CLI to work with MCP servers.
2. Set up the Dynatrace MCP server for real-time observability data.
3. Use natural language queries to monitor and troubleshoot applications across both AWS and Dynatrace platforms.

Breaking down the Amazon Q Developer CLI integration

Setting up this integration typically takes 15 to 30 minutes, with no additional AWS infrastructure required beyond an existing Amazon Q Developer CLI setup.

The architecture diagram below illustrates how MCP enables seamless integration between local development environments and AWS cloud services through Amazon Q Developer CLI. Through standardized MCP communication, a developer can use multiple operating systems to interact with Dynatrace observability tools and AWS offerings.

Before you begin

To complete the walkthrough, teams must first meet the following prerequisites:

• Install Amazon Q Developer CLI.
• Configure AWS CLI with the appropriate credentials (an Amazon Builder account or enterprise license is required).
• Have a Dynatrace account or get a free 15-day trial.
• Have or create a Dynatrace OAuth Client. For the needed scopes, see the Dynatrace MCP readme.

Walking through the Amazon Q Developer CLI installation process

MCP configuration in Amazon Q Developer CLI is managed through JSON files. The interface supports two levels of MCP configuration:

• Global configuration: ~/.aws/amazonq/mcp.json – Applies to all workspaces
• Workspace configuration: .amazonq/mcp.json – Specific to the current workspace

AWS MCP server setup

Once the Amazon Q Developer CLI is installed, configure it to use AWS MCP Server.

1. Open a terminal, and create the following file:
   vi ~/.aws/amazonq/mcp.json
2. Paste the following configuration into the file:

{ 
  "mcpServers": { 
    "awslabs.core-mcp-server": { 
      "command": "uvx", 
      "args": [ 
        "awslabs.core-mcp-server@latest" 
      ], 
      "env": { 
        "FASTMCP_LOG_LEVEL": "ERROR" 
      }, 
      "autoApprove": [], 
      "disabled": false 
    } 
  } 
}

Dynatrace MCP server setup

Add the configuration for the Dynatrace MCP server to mcp.json. Navigate to the Environment Variable section to set up the environment variables for Dynatrace with the needed OAuth Client Scopes. Extending our example from above, the MCP configuration file would look like this:

{ 
  "mcpServers": { 
"awslabs.core-mcp-server": { 
      "command": "uvx", 
      "args": [ 
        "awslabs.core-mcp-server@latest" 
      ], 
      "env": { 
        "FASTMCP_LOG_LEVEL": "ERROR" 
      }, 
      "autoApprove": [], 
      "disabled": false 
    }, 
    "dynatrace-mcp": { 
      "command": "npx", 
      "args": ["-y", "@dynatrace-oss/dynatrace-mcp-server@latest"], 
      "env": { 
        "OAUTH_CLIENT_ID": "", 
        "OAUTH_CLIENT_SECRET": "", 
        "DT_ENVIRONMENT": "" 
      } 
    } 
  } 
}

Verify the MCP server integration with Amazon Q Developer CLI

After configuring both AWS and Dynatrace MCP servers, verify that the integration is working properly. Run the command “q chat” in the terminal to start an interactive session with Amazon Q Developer CLI.

$ q chat 
 
To learn more about MCP safety, see https://docs.aws.amazon.com/amazonq/latest/qdeveloper-ug/command-line-mcp-security.html 
✓ dynatrace_mcp loaded in 3.48 s 
✓ 1 of 1 mcp servers initialized 
 
Welcome to  
 
 █████╗ ███╗  ███╗ █████╗ ███████╗ ██████╗ ███╗  ██╗  ██████╗  
██╔══██╗████╗ ████║██╔══██╗╚══███╔╝██╔═══██╗████╗ ██║ ██╔═══██╗ 
███████║██╔████╔██║███████║ ███╔╝ ██║  ██║██╔██╗ ██║ ██║  ██║ 
██╔══██║██║╚██╔╝██║██╔══██║ ███╔╝ ██║  ██║██║╚██╗██║ ██║▄▄ ██║ 
██║ ██║██║ ╚═╝ ██║██║ ██║███████╗╚██████╔╝██║ ╚████║ ╚██████╔╝ 
╚═╝ ╚═╝╚═╝  ╚═╝╚═╝ ╚═╝╚══════╝ ╚═════╝ ╚═╝ ╚═══╝  ╚══▀▀═╝  
 
╭───────────────────────── Did you know? ─────────────────────────╮ 
│ │ 
│ /usage shows you a visual breakdown of your current  │ 
│ context window usage │ 
│ │ 
╰─────────────────────────────────────────────────────────────────╯ 
 
/help all commands • ctrl + j new lines • ctrl + k fuzzy search 
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

The CLI is now connected to both AWS and Dynatrace MCP servers, allowing you to inquire about functionality across both AWS and Dynatrace platforms.

Testing AWS connectivity

Here are some questions you can ask q chat to verify and the expected result (note they may not be the same for everyone).

Tip: Amazon Q supports just typing “/mcp” or “/tools” and it will show you which servers are available and which tools it can call at a glance.

> Are you connected to AWS?
 
Yes, I am connected to AWS. I can help you interact with AWS services through the AWS CLI. I can make AWS API calls using the use_aws tool, which allows me to perform operations like: 
 
• Describing EC2 instances 
• Listing S3 buckets 
• Managing IAM users and roles 
• Working with other AWS services like Lambda, DynamoDB, etc.
 
Is there a specific AWS task or service you'd like me to help you with? I can run AWS CLI commands on your behalf to retrieve information or make changes to your AWS resources.
 
> Are you connected to Dynatrace?
 
Yes, I am connected to Dynatrace through the Dynatrace MCP integration. I have access to several Dynatrace-specific tools that allow me to: 
 
• Get logs for monitored entities 
• Retrieve entity details 
• List and get details about vulnerabilities 
• Execute and verify DQL (Dynatrace Query Language) statements 
• Send Slack messages via Dynatrace's Slack connector 
• Get ownership information for entities 
• View and manage problem details 
• Work with Kubernetes events 
• Create notification workflows 
 
Would you like me to perform any specific Dynatrace-related tasks for you? For example, I could get information about the connected Dynatrace environment, list current problems, or help you with DQL  
queries.

Now, we’re connected to both AWS and Dynatrace MCP servers, which means you can look at various AWS- and Dynatrace-related tasks, such as checking resources, identifying problems, getting logs, and more. Here are some sample prompts below:

Infrastructure monitoring

"Show me all EC2 instances that have high CPU usage in the last hour and correlate this with Dynatrace performance metrics" 
"List any auto-scaling events from AWS and check if they match performance degradation patterns in Dynatrace"

Application performance

"Compare the response times of our Lambda functions between AWS CloudWatch and Dynatrace monitoring" 
"Show me the slowest API Gateway endpoints and their corresponding service flows in Dynatrace"

Security analysis

"Find all security groups with open ports and cross-reference with Dynatrace security vulnerabilities" 
"Check SSL certificate expiration dates across our AWS resources and validate them against Dynatrace security monitoring"

Log analysis

"Find all error patterns in CloudWatch logs and match them with problem patterns detected by Dynatrace" 
"Show me application errors that appear in both AWS logs and Dynatrace problem detection"

Cost management

"Generate a report comparing our AWS resource costs with their performance metrics from Dynatrace" 
"Identify underutilized AWS services based on both CloudWatch and Dynatrace usage patterns"

If you want to avoid unwanted server activations and unnecessary charges during development, you can clean up with the following:

Open a terminal and navigate to the following file. Remove the MCP configurations you added as part of this setup and save them. This will ensure both AWS and Dynatrace MCP servers are not loaded when you start “q chat”.

vi ~/.aws/amazonq/mcp.json

AI-assisted development is now a reality

The integration of Dynatrace MCP with Amazon Q Developer CLI marks a significant advancement in AI-assisted development. By providing standardized access to external tools and data sources, developers can work with their production environment much more efficiently and with context-awareness. Whether you’re working on remediating problems, database optimization, code analysis, or full stack development, the combination of Amazon Q Developer CLI and Dynatrace MCP offers a powerful platform for modern development and DevOps practices.

Follow the stories: Scaling AI-assisted development with Dynatrace MCP

As the integration of AI tools like Amazon Q Developer CLI and Dynatrace MCP evolves, developers and organizations can expect even greater capabilities to streamline workflows and enhance observability. These advancements not only allow real-time insights but also empower teams to make informed decisions faster, with minimal overhead.

Interested in learning more about how Dynatrace can help you in your AI-assisted development? Check out these resources:

• Part 1 of our agentic AI series introduces MCP, A2A, and the future of automation.
• Part 2 of this agentic AI series explores how monitoring A2A and MCP communications results in better, more effective agentic AI.
• Part 3 of this series covers AI agent observability and monitoring, and how to scale and monitor Amazon Bedrock Agents.
• Full-stack observability for AI with NVIDIA Blackwell and NVIDIA NIM is covered in part 4 of this series.
• Check out Dynatrace MCP and the Dynatrace AI Observability solution for AI agent monitoring and MCP monitoring at scale.

The post Enhance your development workflow with the Amazon Q Developer CLI for Dynatrace MCP 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.