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.

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

Ground every Port AI conversation in live production data from Dynatrace

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

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

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

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

Incident triage from a single Port AI prompt

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

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

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

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

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

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

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

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

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

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

Roll it out across teams, govern centrally

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

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

Get started: connect Port with Dynatrace

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

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

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

For full setup walkthroughs, see Port documentation

Port MCP Connectors documentation: connector setup and admin configuration

Triage incidents with AI: full skill walkthrough

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

In May 2026, OpenTelemetry (OTel) officially graduated from Cloud Native Computing Foundation (CNCF). This milestone marks the cloud native ecosystem’s achievement of production readiness and maturity, thanks to the efforts of hundreds of companies and thousands of developers who believed in an open standard for observability and built it together.

OpenTelemetry was already the standard. Now it’s official.

If you’ve been shipping production code over the last few years, OpenTelemetry has almost certainly touched your tech stack, whether through its SDKs and collectors, or traces, metrics, and logs. For many teams, OTel has quietly become part of the default toolbox for building and operating modern applications. It solves a real problem: the industry needed a common language for telemetry data, and OpenTelemetry became that language.

CNCF graduation reflects the strength of the ecosystem: a diverse contributor base, widespread vendor support with proven production readiness, comprehensive security audits and a governance model built by the community, for the community and for future sustainability.

Why a shared standard changes everything

Graduation formalizes OpenTelemetry as the common protocol and shared language for observability:

1. A standard protocol allows different tools, open source and commercial, to work together.
2. Semantic conventions define how telemetry is named and structured. When all systems speak the same language, correlation becomes possible at scale.
3. OpenTelemetry decouples instrumentation from backend analytics, enabling teams to export telemetry data to any backend system and switch analytics platforms without rewriting code.
4. Standardized, high-quality telemetry data allows automation, anomaly detection, and AI-driven insights. A consistent protocol becomes critical as systems grow more complex and autonomous.

Dynatrace loves OpenTelemetry and open source

Dynatrace has been involved in shaping OpenTelemetry from its early days, contributing to the specification, semantic conventions, Collector, and many other areas, ensuring the standard works at enterprise scale. With over 46,000 contributions and 54,000 commits, Dynatrace is one of the top contributors to the project.

Our focus has always been clear: make OpenTelemetry production-ready without compromising its open, vendor-neutral model.

Beyond OpenTelemetry, Dynatrace actively contributes to over 30 open source projects, including W3C Trace Context, and integrations with Kubernetes, JMeter, and more.

Frequently asked questions

Is OpenTelemetry stable after CNCF graduation?

Yes. Graduation confirms that the core specifications, APIs, and data model are stable and suitable for long-term production use. Teams can adopt OpenTelemetry with confidence across environments and use cases.

Does OpenTelemetry lock teams into a specific vendor or backend?

No. OpenTelemetry decouples instrumentation from backend analytics. Teams can export telemetry data to any backend and switch platforms without rewriting instrumentation code.

How does Dynatrace support OpenTelemetry?

Dynatrace supports you wherever you are. You can ingest pure OpenTelemetry data natively; no proprietary agents are required. From there, you can query billions of spans in seconds, correlate metrics, logs, and traces automatically across petabytes of data, and get the full observability context.

Want to see OpenTelemetry in action?

Learn more about OpenTelemetry at Dynatrace Hub.

The post OpenTelemetry graduates: A milestone for the observability Open Source community appeared first on Dynatrace news.

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

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

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

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

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

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

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

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

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

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

How to roll out the Dynatrace MCP Server in Atlassian Rovo

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

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

Security, governance, and cost stay under administrator control

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

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

Get started with the Dynatrace MCP Server for Rovo now

The integration is generally available. To connect it:

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

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

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

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

Dynatrace helps you answer these questions by extending AI observability for a new wave of coding agents, including Claude Code, Google Gemini CLI, OpenAI Codex CLI, OpenCode, and GitHub Copilot SDK. Together, these integrations give engineering leaders, platform teams, and developers a consistent way to understand agent activity, token consumption, costs, tool behavior, and runtime impact: without forcing teams to stitch together fragmented telemetry across terminals, SDKs, dashboards, and development workflows. Dynatrace public AI agent instrumentation examples on GitHub demonstrate how to provide industry leading observability that drives performance, cost efficiency, and governance across complex, distributed AI-driven systems—all through a unified Dynatrace platform experience that developers can access directly via MCP without leaving their IDE.

From agent activity to engineering insight

As organizations adopt multiple coding agents, new adoption challenges emerge. One team might use Claude Code in the terminal, another may build internal tools with GitHub Copilot SDK, while others experiment with Gemini CLI or Codex CLI. Platform teams want visibility into usage, availability, and costs. Engineering leaders want to know whether agents improve delivery. Security and governance teams want confidence that all prompts, tool usage, and actions can be monitored appropriately.

Dynatrace provides a practical answer to these challenges: a single observability layer for agile development workflows. For agents that emit OpenTelemetry directly, such as Claude Code, Gemini CLI, and Codex CLI, Dynatrace can ingest telemetry related to sessions, tokens, costs, tool executions, errors, and performance. For GitHub Copilot workflows, Dynatrace adds production context, software delivery automation, and GitHub-based integrations that connect agent activity to real engineering workflows.

The payoff is clear. Developers gain visibility into how agents behave in real work. Platform teams can track adoption, usage trends, and cost signals. Engineering leaders can correlate agent activity with commits, pull requests, and delivery outcomes. And with an MCP-enabled production context, teams can connect coding-agent actions to what is happening in production.

“Before we instrumented Claude Code, we had no easy way to break down how our engineers actually used AI, which models, for what tasks, and at what cost. Now we can pinpoint inefficient model use and guide usage toward better cost-performance tradeoffs.”
— Markus Heimbach, Senior Director Software Development

Multiple coding agent experiences, one observability strategy

Each coding agent has a different operating model, which is why a common observability layer matters.

Claude Code

Claude Code already supports built-in OpenTelemetry, making it easy to send metrics and logs to Dynatrace with no code changes. Teams can track sessions, tokens, costs, tool activity, API health, and engineering output such as commits and pull requests. Logs, dashboards, and alerts help teams investigate failures, spot latency spikes, and catch unusual spend or error patterns early.

Gemini CLI

Gemini CLI includes OpenTelemetry-based observability and preconfigured dashboards, making it a strong fit for Dynatrace AI observability. Teams can correlate agent activity with broader platform signals and move quickly from raw telemetry to action. This includes debugging failed runs, identifying slow or error-prone tool calls, and alerting on cost or reliability regressions.

Codex CLI

Codex CLI supports opt-in OpenTelemetry monitoring, giving teams a path to audit usage and strengthen governance across CLI, IDE, and app experiences. With Dynatrace, logs and traces help investigate request flows, delays, and failures across agent workflows. Alerts can flag degraded reliability, unexpected behavior, or rising token consumption before they become larger issues.

GitHub Copilot SDK

GitHub Copilot SDK lets teams embed agentic workflows directly into applications, while Dynatrace adds live observability and security context. This matters because embedded agents become part of real engineering and production-adjacent workflows. Dynatrace helps trace execution paths, use logs for debugging and auditability, and set alerts for failures, latency, or policy-relevant events.

OpenCode

OpenCode is a terminal-based AI coding agent that helps developers work through coding tasks directly from the command line. Because OpenCode ships with native OpenTelemetry support, teams can route telemetry to Dynatrace without code changes by setting standard OTLP environment variables. With Dynatrace, teams can track LLM call volume, session activity, tool usage, request latency, and workflow behavior across real developer sessions. Traces help teams inspect LLM requests, tool executions, session lifecycle events, message processing, file snapshots, or diff operations.

Across all operating models, the value is the same: one strategy for monitoring adoption and impact, understanding costs, logging and tracing agent activity, alerting on reliability issues, and debugging real-world workflows as coding agents scale across the enterprise.

Why this matters now

Teams are no longer asking whether coding agents are useful. They’re asking how to drive adoption, scale them safely, govern them consistently, and prove their impact. That requires visibility into usage, cost, reliability, and engineering outcomes across teams and tools. Dynatrace helps organizations make that shift with the observability and production context needed to expand coding-agent adoption with confidence.

The coding-agent market is moving fast. Claude Code, GitHub Copilot SDK, Google Gemini CLI, and OpenAI Codex CLI each represent a different path toward agentic software delivery, from terminal-based workflows to embedded SDKs and governed local execution. At the same time, Dynatrace has been expanding its developer-facing AI surface with the Dynatrace MCP Server, GitHub Copilot integrations, and AI observability capabilities built to connect agent behavior with real production systems. The timing matters because teams are no longer evaluating whether coding agents are useful. They’re deciding how to drive adoption, scale up usage safely, govern usage consistently, and measure real impact.

Ready to see AI coding agents through a Dynatrace lens?

With Dynatrace, teams can understand adoption, spend, reliability, tool behavior, and engineering outcomes in one place, while giving agents access to the live production context they need to make better decisions.

Whether your developers are working in Claude Code, building on GitHub Copilot SDK, experimenting with Gemini CLI, or adopting Codex CLI, Dynatrace helps bring observability, governance, and production awareness into the heart of agentic software delivery.

Public examples already demonstrate this approach for Claude Code, and the broader Dynatrace MCP and AI observability ecosystem provides the foundation to extend the same value across the next generation of coding agents.

Ready to learn more?

In our Git repository, you’ll find step-by-step examples for supported coding-agent workflows, including how to configure OpenTelemetry export, send telemetry data to Dynatrace, and use the provided dashboards to analyze the activity of your AI coding agents.

The post Dynatrace expands AI Coding Agent monitoring for Claude Code, Google Gemini CLI, Codex CLI, OpenCode, and GitHub Copilot SDK appeared first on Dynatrace news.

Editor’s note

At Google Cloud Next 2026, the future of digital operations and artificial intelligence is on full display. The mandate for enterprises is clear: Successfully scaling AI requires a foundation of intelligent observability.

The momentum behind the Dynatrace collaboration with Google Cloud has never been stronger. That’s why we’re proud to be a Velocity sponsor for the event. We are working with Google Cloud to help organizations accelerate AI adoption through deep trust, robust automation, and unified observability. By transforming operational complexity into a strategic advantage, we empower DevOps, SREs, and platform engineering teams to innovate faster and secure their cloud environments.

As Google Cloud Next kicks off in Las Vegas, read our guide for the latest insights on how Dynatrace and Google Cloud are helping to shape the future of autonomous operations.

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

The latest Dynatrace news and announcements from Google Cloud Next

The rapid rise of generative and agentic AI is reshaping how teams build, run, and scale applications—and it’s adding new layers of complexity along the way. Dynatrace helps teams make sense of that complexity by providing clear, automated insights across their Google Cloud environments, built on top of Google Cloud’s secure-by-design infrastructure.

Here’s the latest news from Dynatrace at Google Cloud Next:

• The Dynatrace for Gemini Enterprise Agent is now live on Google Cloud Marketplace. This agent provides a clear, efficient way for enterprises to discover, evaluate, and deploy validated AI agents at scale. This means teams can bring Dynatrace Intelligence into their Gemini agents faster, with less friction and without custom integration work.
• Dynatrace and Google Cloud Assist Investigations now work together to enable autonomous, end‑to‑end incident response. Dynatrace detects issues, understands their root cause through deterministic AI, and automatically triggers an Assist Investigation with comprehensive production context — topology, traces, dependencies, and business impact. Google Cloud’s agent then correlates this with its own telemetry and change history to pinpoint the failing component and recommend the next best action, all surfaced directly in Dynatrace. The result is a more seamless path from symptom to fix without war‑room back‑and‑forth or tool‑switching.
• The Dynatrace enhanced Clouds App gives teams instant, unified visibility across their entire Google Cloud environment through a fully managed, agent-free integration that automatically ingests metrics, logs, and events without custom pipelines or extra infrastructure. It also supercharges the tags organizations already use in Google Cloud, applying them automatically to drive cleaner ownership, smarter routing, and reduced operational noise. This helps teams move from reactive firefighting to proactive, preventative operations: detecting issues earlier, automating root-cause analysis, and powering self-healing workflows while optimizing resources and infrastructure over time across the entire Google Cloud ecosystem.

“Google Cloud is advancing a new era of agentic operations, and partners like Dynatrace are essential to making that vision real for customers. Together, we’re enabling enterprises to scale AI responsibly, optimize operations, and accelerate their journey toward autonomous cloud environments.”

- Satish Thomas, Vice President, Applied AI & Platform Ecosystem, Google Cloud

The rise of the AI workforce

Enterprises are rapidly shifting from localized experimentation to scaled AI adoption across their entire organization. However, operationalizing these advanced AI workloads introduces unpredictable costs and dynamic behavior that traditional monitoring tools simply can’t manage.

To safely deploy an AI workforce, teams require stringent observability, governance, and automation. Enter Dynatrace, offering AI-powered observability that tracks every input and output to help ensure compliance and reliable decision-making.

	The rise of the AI workforce: Enterprises need a new operating model – Blog
	The latest Dynatrace AI-powered observability features are now on Google Cloud – Blog

Powering autonomous cloud ops with real-time intelligence, context, and agentic AI guardrails

For agentic AI to function reliably, observability, real-time context, and deep intelligence are essential. Without these guardrails, organizations risk model drift, hallucinations, and degraded service quality.

Dynatrace directly supports event-driven preventive operations and AI-driven decisioning. By automatically discovering and continuously mapping all components in real time, Dynatrace Intelligence empowers teams to achieve safe, autonomous cloud operations.

	Enhance Healthcare Operations with Dynatrace & Google Cloud – Fact Sheet
	The pulse of Agentic AI in 2026 – Report
	Dynatrace Intelligence: Fuse deterministic and agentic AI for autonomous operations – Report

Accelerating cloud native innovation for modern cloud architectures

Dynatrace helps DevOps and platform engineers standardize, automate, and optimize complex cloud-native environments. By providing instant insights and proactive risk mitigation across Google Kubernetes Engine (GKE) and beyond, Dynatrace improves the developer experience and accelerates release cycles.

	Five real-world lessons for building developer workflows in the agentic era – Blog
	The top 7 Kubernetes challenges and how to solve them – Blog

Chart your course for cloud innovation

Dynatrace is collaborating with Google Cloud to help organizations scale AI responsibly, efficiently, and confidently. We aim to deliver AI-powered observability, automation, and precise analytics across your Google Cloud ecosystem. That’s why now is the time to optimize your Kubernetes clusters, automate your security pipelines, and deliver exceptional software.

The post Google Cloud Next 2026: A look into the autonomous future of cloud operations appeared first on Dynatrace news.

A profound shift is underway in enterprise software delivery.

Developers can now generate, modify, and deploy systems faster than ever using AI. But understanding what those systems are doing in production is getting harder, not easier.

What began as simple prompt and response interactions with LLMs has evolved into something far more powerful: a distributed system of humans and AI agents working together to build, run, and adapt software. This isn’t a theoretical future. It’s happening now, and it’s reshaping how organizations must architect, operate, and govern AI at scale.

The industry has moved beyond monolithic LLMs. According to Merlin Yamssi, AI/ML CoE Lead for Partner Engineering at Google, who spoke at Dynatrace Perform this year, the early era of “LLM + prompt” model broke down quickly in real systems: no context, inconsistent behavior, and no way to act safely. That drove a rapid evolution toward retrieval, tool use, and ultimately agents that can plan, act, and collaborate across systems.

Today, AI systems behave less like single models and more like teams: one agent retrieves context, another writes code, another validates changes, and another evaluated impact in production. This shift is redefining enterprise expectations. AI is no longer here just to respond. It’s here to work.

Three forces reshaping enterprise AI

Three major trends are accelerating this transformation.

1. Inputs are no longer just text, systems must interpret complex signals. As Yamssi put it, “You can show an image to a model, and then it will understand the image … and think on the image.”
2. Execution is no longer linear, systems coordinate across agents.
3. Data is no longer static, systems operate on constantly evolving context. “Essentially, [this turns] all the vast enterprise data into an active conversation,” Yamssi said.

Together, these forces are creating not just better models, but an entirely new AI operating model.

Why traditional AI architectures can’t keep up

Legacy architectures weren’t designed for distributed, autonomous AI systems. Single model approaches are rigid, difficult to debug, and prone to hallucinations. As organizations adopt multiagent systems, complexity skyrockets.

These are not only model problems; they are also distributed systems problems.

Emerging risks include the following:

• Agents lose context as they hand tasks to one another.
• Infinite loops occur where agents trigger each other endlessly, consuming tokens and budget.
• Opaque decision chains can make it difficult to understand why an agent acted.
• Token usage explodes without visibility or guardrails.

“You cannot really go into production with something that looks like a black box,” Yamssi added.

Enterprises should treat AI like a distributed system, not a chatbot.

What modern AI applications require

To support an AI workforce, organizations need a vertically integrated stack that spans five foundational layers: infrastructure, data, models, platform, and applications. Google Cloud is one of the few providers offering all five layers in a unified architecture, with hooks for observability at each layer.

On top of this foundation, a new class of agent specific tooling is emerging:

• ADKs for building reasoning capable agents
• MCP for standardized access to tools and enterprise systems
• A2A protocols enabling seamless agent-to-agent collaboration across environments
• Agent engines capable of running thousands of agents at scale

This is the new AI application stack, and it calls for a new operational model.

The missing layer: Observability for the AI workforce

Observability is increasingly about decisions, not just systems. As multiagent systems scale, observability can serve as a control plane.

Without deep visibility, enterprises face black box behavior, unpredictable costs, and operational risk. Dynatrace and Google Cloud are working to address this gap, including integrating observability capabilities with Gemini Enterprise, A2A, MCP, and other parts of the AI stack.

Modern AI observability should help reveal:

• How decisions are made
• How agents coordinate
• How costs and behavior evolve in real time
• Where failures originate across reasoning

This is a shift from monitoring applications to monitoring reasoning, decisions, and collaboration. Enterprises often need visibility from the infrastructure all the way to the data, the LLM, the agent, and the application.

For developers, this changes the job entirely. You’re no longer debugging a service. You’re debugging a system of agents, decisions, and interactions across code, cloud, and runtime behavior.

From insight to action: The path to autonomous operations

According to recent Dynatrace research, 50% of respondents have agentic AI projects in production for limited use cases, and 44% have projects in broad adoption. Further, 72% of respondents have 2-10 agentic AI projects. With agentic AI already in production and growing, observability becomes essential. Once organizations can observe their AI workforce, they can begin to automate operations.

Observability must surface not just what happened, but why. Dynatrace and Google Cloud are already enabling this through integrations with Gemini Cloud Assist, which can recommend infrastructure or application changes based on observed issues.

This unlocks a new operational loop:

• Observe systems behavior across code, runtime, and agents
• Diagnose causal relationships, not just symptoms
• Recommend changes grounded in runtime context
• Remediate automatically or in collaboration with developers and agents

The result can be faster recovery, lower cost, and safer AI deployment at scale.

Accelerate your AI workforce strategy with Dynatrace on Google Cloud

At Perform, this shift was clear: The challenge is no longer generating code or deploying models. It’s understanding and controlling how these systems behave once they’re running.

The organizations that solve this will define the next generation of software delivery. If you want to go deeper, watch the full Perform session: The AI workforce: Advancing agentic collaboration through observability.

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

The post The rise of the AI workforce: Enterprises need a new operating model 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.

In January 2026, I ran an experiment: I published one blog post every single day for 31 days about building production software with AI. Not toy demos. Not “hello world” chatbots. Real, shipped, supported product. The whole series was built around one project: collectyourcards.com, a sports card collection app I built entirely with Claude Code over three months of nights and weekends. 1,000,000+ cards, an achievement system, universal sub-200ms search, Excel exports. All of it.

I called it 31 Days of Vibe Coding. “Vibe coding” is the increasingly common practice of describing features to an AI assistant and iterating on generated code instead of writing every line manually.

I documented my journey on a website and newsletter that covered my learnings in bite sized chunks. Check out the full series. If any of these lessons resonated, the detailed posts have the code, the prompts, and all the messy parts I couldn’t fit here. I also appeared on the PurePerformance podcast to discuss my learnings. Writing about and discussing my work helped me better understand what I learned. Here are a few important insights I gleaned from my work.

1. You’re the architect. AI is the junior developer.

This is the framing that makes everything else work. You decide what to build, how it should be structured, and what trade-offs are acceptable. AI helps you build it faster. When you flip that relationship and start expecting AI to make design decisions for you, things go sideways fast.

I learned this the hard way when I described a notification system to Claude and asked it to “figure out the best approach.” It picked polling every 30 seconds. That works fine for 10 users. At 10,000 users, that’s 333 requests per second hitting your server for no reason. When I instead described my proposed approach and asked Claude to poke holes in it, it identified five real problems I hadn’t considered, including the scaling issue. Same tool, completely different outcome, because I stayed in the architect role.

AI doesn’t replace your judgment. It accelerates your execution.

2. Write specs, not prompts.

Early on, I was typing things like “build me a card search feature” into Claude and getting back something that technically worked but was missing pagination, fuzzy matching, error handling, and observability. The output was exactly as vague as my input.

The fix was treating every feature like a spec. I started writing GitHub Issues as full feature specifications before ever opening a conversation with AI. Context, intent, constraints, examples, and how to verify it works. When I built the achievement system for collectyourcards.com (1,200+ achievements across 14 categories), the entire thing was driven by a single well-written GitHub Issue. AI even helped me write the spec before a single line of code existed, and then created follow-up issues during implementation for database indexes, notification hooks, and edge cases I’d missed.

Vague input gets vague output. Specific input gets production-ready output. Every time.

3. Break every feature into phases.

Never ask AI to build a complex feature in one shot. I tried this exactly once with the achievement system. Forty-five minutes of generated code spread across dozens of files, and none of it worked because everything was interdependent and untestable. I couldn’t even figure out where to start debugging.

I threw it all away and started over with phases.

• Phase 1: core achievement engine with 150 basic achievements. That shipped in one session and worked immediately.
• Phase 2 added categories.
• Phase 3 added the notification system. Each phase produced working, deployable, independently verifiable software. The total time was less than my failed single-shot attempt.

This applies to everything. My universal search feature went from basic text matching to fuzzy search to multi-entity results to filters to autocomplete, each phase shipping on its own. If Phase 1 alone isn’t useful, your phases are too small. If Phase 1 takes more than one session, your phases are too big.

4. Commit before every AI operation.

Git is your undo button. This sounds obvious until you skip it once and lose an hour of your life.

I asked Claude to change a five-word error message in a validation function. Simple, right? When I looked at the diff afterward, it had touched 12 files. It renamed the function from `validateUser` to `checkUserStatus`, refactored the validation logic, and updated three other files that referenced the original function name. The app crashed. Without a prior commit, I spent 50 minutes manually figuring out what had changed and reversing the damage.

Now I commit before every significant AI operation. `WIP: before achievement refactor`. `WIP: before search update`. It takes five seconds. When AI changes something you didn’t ask for (and it will, inevitably), you run `git diff`, see exactly what happened, and revert cleanly. Think of it like saving before a boss fight in a video game.

5. Configure your AI once, not every conversation.

AI has no memory between conversations. Every new session starts from zero. For weeks, I was repeating the same instructions: “Use TypeScript, use Prisma, use the service layer pattern, add structured logging, don’t use console.log.” Every. Single. Time.

The fix was a CLAUDE.md file in my project root that defines my tech stack, coding patterns, and explicit “Always” and “Never” lists. I added annotated pattern files that show, not describe, how services should be structured. I added a common mistakes file documenting errors AI kept making so it would stop making them.

Before configuration, asking Claude to “create an endpoint to update user email” produced JavaScript with raw SQL and console.log. After configuration, the exact same prompt produced TypeScript with strict types, Prisma, a proper service layer, and structured telemetry logging. Same AI, same prompt, dramatically different output, because the context was already there.

6. AI builds for the happy path. You have to demand the rest.

AI-generated code is optimistic. Really optimistic. It assumes your database is always up, your network is always fast, and your users always send valid JSON. It writes code that works perfectly when everything goes right and fails silently when anything goes wrong.

I built a card-fetch endpoint that looked clean and correct. Eight lines of straightforward code. When I ran a security audit (by asking Claude to switch into adversarial “penetration tester” mode), it found four vulnerabilities: no ownership check (any user could fetch any other user’s cards), sensitive data exposure (returning all owner fields including email), no rate limiting, and no access logging. The fix was about 15 lines, but it never would have written them unless I explicitly asked.

Security, operability, edge cases, and test coverage don’t happen unless you ask for them separately. I started using what I call the “3am test” for every feature: if this broke at 3am, would I know it happened? Would I know why? Would I know how to fix it? If the answer to any of those is no, the feature isn’t done.

7. Observability replaces manual code review.

When you’re shipping AI-generated code, you’re not reading every line. You can’t. The volume is too high and the iteration speed is too fast. So how do you know it works? You watch it run.

I add structured logging, metrics, and tracing to every new feature on Day one. When a user gets locked out of their account on collectyourcards.com, I can diagnose why in 30 seconds by looking at the authentication telemetry: user ID, IP, user agent, error message, all structured and searchable. Before I had this, the same diagnosis took hours of guessing.

This isn’t optional when you’re building with AI. It’s the substitute for the line-by-line code review you’re no longer doing. OpenTelemetry with traces, metrics, and logs became the foundation of every feature I built. If I couldn’t observe it in production, I didn’t ship it.

8. Use AI to review AI.

One of the most useful patterns I found was using AI to check AI’s own work. But there’s a trick: run multiple focused review passes, not one general review.

A single “review this code” pass might catch three or four issues. Four separate focused passes (security, performance, edge cases, maintainability) routinely caught 12 or more. I’d ask Claude to review a user registration endpoint once for security vulnerabilities, once for performance problems, once for missing edge cases, and once from the perspective of someone maintaining this code at 3am. Each pass found things the others missed.

I also used AI to write tests for AI-generated code, to refactor AI-generated code, and to find edge cases I’d never think of. A `formatUserName()` function seems simple until AI points out: What about right-to-left text? Emoji in names? HTML injection? A user who entered no name at all (producing “undefined undefined” on the profile page, which actually happened)?

9. Measure whether it’s actually helping.

Here’s the honest part. I spent 31 days writing about how AI makes you faster and more productive. And when I actually measured my output, my features-shipped-per-week, bugs-in-production, and time-from-issue-to-deploy were… about the same as before.

I felt faster. The moment-to-moment experience of coding with AI feels incredible. Code appears instantly. Features take shape in minutes instead of hours. But the total cycle time, including prompt crafting, output review, fixing hallucinations, and debugging unexpected changes, often washed out the speed gains.

Where AI genuinely helped: boilerplate generation, code review, exploring unfamiliar APIs, enumerating edge cases, and writing documentation. Where it consistently hurt: novel problems with no clear pattern, subtle bugs that required deep context, and any situation where it over-engineered a simple solution. If you’re not tracking which category your work falls into, you’re flying blind.

10. Document what you learn, because AI won’t remember (yet).

AI’s context degrades within a single session and vanishes completely between sessions. Around message 30 or 40 in a long conversation, I’d start seeing Claude reference models that didn’t exist, import from paths that were never created, and contradict decisions it made 20 messages earlier.

The fix is aggressive documentation. Progress docs that summarize what was built, what decisions were made, and what’s next. A mistakes file that records patterns AI keeps getting wrong (with “wrong” and “right” examples) so you can reference it in future sessions. Proactive compaction at natural breakpoints, not after quality has already collapsed.

Your configuration files, your mistakes file, and your progress docs are the substitute for the institutional knowledge a human teammate would accumulate over months. AI doesn’t learn from working with you–at least not yet. But your documentation can simulate that learning for every future session.

How I changed over 31 days

After 31 days and nearly 49,000 words, the biggest shift was in how I think about what I’m building. I plan more carefully because the cost of planning is low and the cost of a bad AI-generated implementation is high. I commit more often. I monitor everything. I write better specs than I ever did when I was the one writing every line.

AI didn’t make me a faster coder. It made me a better architect.

The post 10 things I learned writing 49,000 words about vibe coding 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.

AI is compressing attack timelines

The organizations pulling ahead are those with runtime visibility into the applications that directly generate and impact revenue.

What AI is changing

In a report published in November 2025, Anthropic documented the first large-scale AI-orchestrated cyberattack campaign, in which AI autonomously performed 80–90% of attack operations with minimal human intervention. This signaled a turning point.

The threat actors causing the most damage today aren’t traditional nation-state actors or advanced persistent threats (APTs)—they’re financially motivated collectives like Scattered Spider. AI hasn’t invented fundamentally new attack techniques yet, but it has significantly increased attack volume and velocity—CrowdStrike observed an 89% increase in attacks by AI-powered adversaries in 2025 alone.¹ Techniques once reserved for state-sponsored groups are now accessible to cybercriminals through AI-assisted tooling.

The same automation accelerating attacks also allows for faster defense. But with an average time of only 29 minutes from initial access to lateral movement, defenders relying on periodic assessments are structurally disadvantaged. The capability that matters now is continuous exposure assessment—analyzing real-time signals across all cloud assets and acting before adversaries complete their objectives.

Two battlefronts: One adversary

Traditional attack vectors haven’t disappeared—supply chains, endpoints, physical security, and human-targeted attacks are increasing just as rapidly. But business-critical applications have become a focal point of attack operations because lower entry barriers make them accessible to more threat actors. The applications that process transactions, manage customer data, and orchestrate supply chains are precisely where runtime compromise has the greatest business impact.

Organizations must drive parallel initiatives: one focused on people, identity governance, and communications; another on runtime protection, continuous exposure management, and application-layer visibility. These require different tools and skills—but critically, connected processes and connected insights. Siloed security functions are precisely what sophisticated attackers exploit.

Why runtime is the new frontline

Initiatives like Anthropic’s Claude Code Security and OpenAI’s reasoning-based vulnerability detection are collapsing scanning stages and shortening developer feedback loops. This is real progress. But production remains the definitive validation point. AI-generated code and accelerated release cycles introduce risks that surface only at runtime—pipeline scanners offer helpful signals but lack the reliability and context of a unified runtime view.

In an agentic ecosystem, detection and response can’t be focused on the perimeter—they must be intrinsic to the application and infrastructure. Environment-aware malware and prompt injection against enterprise AI agents aren’t visible at the perimeter. They’re visible at runtime. The XZ Utils backdoor (CVE-2024-3094) demonstrated this perfectly: malicious code passed all static analysis, activating only when loaded by sshd on targeted Linux distributions in production.⁷

Autonomous workflows that lack visibility into security risk operate with an incomplete picture. Integrating security context into agentic decision-making—rather than treating it as a separate operational domain—will be essential as enterprises scale these capabilities.

– IDC Link, Dynatrace Perform 2026: From Observability to Supervised Autonomous Operations (Doc #lcUS54307526, February 2026)

Security that’s embedded, not bolted on

The convergence of observability and security isn’t theoretical—it’s operational. IDC analysis notes that organizations expect the next generation of security to be embedded in solutions rather than bolted on. Dynatrace application security capabilities—runtime vulnerability analytics and runtime application protection—operate within Grail alongside observability and business data, sharing the same contextual mapping and causal dependency graph.

Resilience as a competitive advantage

Fortune 500 organizations that embed security into procurement, prioritize supplier maturity assessments, and integrate threat intelligence into operations are positioned to protect both infrastructure and the applications that drive revenue. Forward-thinking organizations recognize the agentic evolution as an opportunity to align security investments with business outcomes and build operational resilience that allows confident growth.

In a world where adversaries move from initial access to lateral movement in 29 minutes or less and autonomous agents make decisions at machine speed, the organizations that thrive will be those with unified runtime visibility.

Clarifying the competitive narrative

There is a prevailing belief that frontier AI labs—Anthropic with Claude Code Security, OpenAI with Codex⁵—are making traditional security tools obsolete. This belief is partially correct, but it fundamentally misunderstands which tools are being displaced.

What frontier labs are changing

These capabilities collapse scanning stages in the IDE and CI/CD pipeline. They find vulnerabilities through reasoning rather than pattern matching, uncovering business-logic flaws that static analysis misses. This is genuine progress—and it is expected to reduce certain vulnerability classes over time. SQL injection, for example, may become less prevalent as LLM-generated code matures and shift-left tools are integrated throughout the agent development lifecycle.

What frontier labs don’t address

Frontier lab security tools operate before deployment. They don’t see how code behaves in production—outside of API integrations that push context to them. They can’t detect configuration drift, environment-aware malware that activates only at runtime, or prompt injection against live AI agents. Anthropic describes Claude Code Security as an evolution of static analysis: rather than matching known patterns, it “reads and reasons about your code the way a human security researcher would.”⁴ Static analysis operates on code before it runs. These tools sit at completely different points in the security lifecycle from runtime protection.

What Dynatrace surfaces today

These capabilities deliver findings that frontier lab tools can’t—evidence of what is actually happening in production, not predictions based on code analysis.

Runtime Vulnerability Analytics

Identifies vulnerabilities in the context of actual execution—not theoretical exposure, but real risk based on how code runs in production.

Runtime Application Protection

Detects and blocks exploit attempts as they happen—the defensive layer that shift-left tools structurally can’t provide.

Security Posture Management

Surfaces misconfigurations and compliance gaps in live cloud infrastructure, including Kubernetes environments.

The evolving threat landscape

The Open Worldwide Application Security Project (OWASP) Top 10 for Agentic Applications (2026) report, provides consensus-based guidance and introduces new categories—Agent Behavior Hijacking, Tool Misuse and Exploitation, and Identity and Privilege Abuse⁶—directly relevant for organizations deploying autonomous agents. For any organization running business-critical applications, runtime visibility remains the validation layer that confirms whether security controls actually work.

What this means in practice

Organizations using Dynatrace already have the core capabilities required for agentic security.

• Security findings flow directly to development and SRE teams through workflows that include clear remediation guidance.
• Natural-language queries on security findings are already available through Dynatrace Intelligence.
• Dynatrace Intelligence allows agentic remediation, allowing automation to act within goals and constraints defined by humans and for humans to retain the flexibility to stay in the loop (see Agentic workflows in Dynatrace documentation).

What sets the Dynatrace approach apart is the combination of deterministic runtime findings with agentic workflows—enabling remediation that is reliable, repeatable, and grounded in real production evidence.

Article citations

1. CrowdStrike 2026 Global Threat Report. Average eCrime breakout time (initial access to lateral movement) fell to 29 minutes in 2025, a 65% increase in speed from 2024. Fastest observed: 27 seconds. CrowdStrike also observed a 89% increase in attacks by AI-enabled adversaries compared with 2024. crowdstrike.com/en-us/blog/crowdstrike-2026-global-threat-report-findings
2. Fortune, “Feds are hunting teenage hacking groups like ‘Scattered Spider’ who have targeted $1 trillion worth of the Fortune 500 since 2022,” January 2026.
3. Anthropic, “Disrupting the first reported AI-orchestrated cyber espionage campaign,” published November 2025. Attack detected mid-September 2025. AI executed 80–90% of tactical operations independently.
4. Anthropic, “Claude Code Security,” anthropic.com/news/claude-code-security, 2026.
5. OpenAI, “Codex,” platform.openai.com/docs/codex.
6. OWASP GenAI Security Project, “Top 10 for Agentic Applications 2026,” genai.owasp.org, December 2025.
7. CVE-2024-3094 (XZ Utils). Backdoor activated only when loaded by sshd on targeted Linux distributions — bypassing all static analysis. Wired, April 2024.
8. Dynatrace Intelligence: “supports in-context natural language for investigation and guided next steps.” docs.dynatrace.com/docs/dynatrace-intelligence

The post The runtime reckoning: How the agentic evolution is reshaping security 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.

A paradigm shift: Moving from signal monitoring to true entity health understanding

Digital systems continuously evolve and adapt. Making effective decisions requires real-time, always up-to-date insights into how everything is connected—from infrastructure to applications—and understanding the impact on users and the business when issues arise. When an anomaly occurs, you need to quickly pinpoint the root cause, understand why it happened, identify exposed components, and determine which critical services depend on them.

Autonomous AI agents raise expectations for speed, precision, and self-healing IT systems, but, like humans, AI agents rely on high-quality data and rich context to operate effectively. Basic observability signals fall short because they lack contextual information and a holistic view of IT entities and their dependencies, making it difficult to derive impact and causality. In a world of AI agents, an accurate, real-time production context becomes non-negotiable, as only then can you trust AI agents to make the right decisions.

Smartscape has been a core part of the Dynatrace platform for years, and it powers Dynatrace causal AI. Smartscape is a real-time dependency graph that visualizes how your IT components depend on each other, continuously updating as your topology changes. Smartscape maintains AI-ready context across ephemeral components in hybrid and multicloud environments. This real-time discovery and updating happens automatically across multiple sources, so the model always reflects reality and serves as your ultimate single source of truth.

^{Figure 1. Explore your IT systems and their dependencies visually with the new Smartscape app.}

The new Smartscape was developed for cloud native, large-scale environments and comes with major new capabilities:

• Powerful visual analytics in the all-new Smartscape app, including domain-specific views for cloud, Kubernetes, infrastructure, and more.
• Fully native cloud entities with complete metadata and raw cloud/Kubernetes object JSON.
• Agentless cloud data ingest that automatically adds all entity dependencies and policy context.

• Exploration at scale with Dynatrace Query Language (DQL). Run native graph queries (for example, traverse) to multi-hop across millions of relationships with full Grail® context.

These enhancements unlock many high-value use cases, transforming the way you and your teams work.

• End-to-end cloud visibility: Close cloud‑console gaps with full relationship context for faster decisions across multi‑cloud and hybrid environments.
• Understand Kubernetes dependencies immediately: Diagnose issues quicker with full‑fidelity objects, YAML context, and cross‑cluster dependency tracing.
• Stronger security posture: Visualize exposure and attack paths, prioritize by real blast radius, and enforce IAM and configuration best practices.
• Accelerate incident response and collaboration: Use the new Visual Resolution Path to see upstream and downstream dependencies and get Dynatrace Intelligence insights in context. Route alerts to the right owners, cut handoffs, and reduce escalations.
• Validate and optimize architecture and cost: Compare intended vs. runtime architecture, align ownership, and reduce costs using real dependency and utilization context.
• Reliable CMDB/ServiceNow enrichment: Export precise, auto‑discovered dependencies with external IDs for accurate ITSM automation.

Spot and understand patterns instantly with the new Smartscape app’s powerful visual analytics capabilities

The new Smartscape app delivers rich, large-scale visual analysis tailored for modern cloud and AI-native environments, with a smooth and responsive experience at scale.

• Explore thousands of entities interactively and quickly drill down into topology and entity details.
• Navigate your entire environment with all dependencies, or use domain-focused, ready-made Smartscape views for clouds, Kubernetes, classic infrastructure, or services.
• Work in context across the platform:
  • The Visual Resolution Path in the Problems app lets you jump directly into the Smartscape Problems Graph to analyze systemic patterns or blast radius.
  • View topology: an intuitive, in-context action that lets you explore vertical and horizontal topologies for any entity without leaving your app or workflow, which is perfect for understanding dependencies and drilling into details.
• Align views to your business context with segments. Focus your analysis on entities by team ownership, environment, business unit, or region to reduce noise during change windows and reviews. This allows you to understand who owns what and accelerate collaboration with a shared understanding of your IT system.
• Analyze patterns from every angle: switch topology layouts to reveal different insights. force exposes hidden clusters and dependency hubs for dynamic microservice exploration; horizontal traces workflows left to right for end-to-end transactions or CI/CD flows; and vertical highlights layered architectures top to bottom for dependency stacks or escalation paths.

Agentless topology discovery from clouds

Dynatrace can now directly discover entities and relationships from cloud environments, including security groups, VPCs, load balancers, subnets, and other network services, providing accurate connectivity, policy, and configuration context, even without deploying OneAgent. In addition to raw topology, Dynatrace automatically ingests, normalizes, and enriches cloud‑native metadata such as tags, labels, ownership properties, cost centers, compliance attributes, and compute metadata, creating a high-quality semantic layer.

All discovered entities and their metadata are unified in the new Smartscape, revealing practical and actionable insights, for example: Which instances are publicly accessible? How is traffic routed across accounts and regions? How do security groups influence exposure paths? And much more.

Experience the new Smartscape, now Generally Available, in your Dynatrace environment

Explore the new Smartscape app, which will be available in your Dynatrace SaaS environments during the first week of February 2026, and begin uncovering dependencies across clouds, Kubernetes, infrastructure, services, and problems.

For a deeper dive, check out our documentation and walk through the Playground notebook, which guides you step‑by‑step in using DQL to query Kubernetes entities.

And stay tuned: our next blog post in this series will take you even further, exploring the new domain‑specific views in Smartscape.

Ready to get started? Start exploring your digital systems now on the Dynatrace Playground.

The post The new Smartscape: Move faster and make better decisions with a real-time dependency graph of all your digital systems appeared first on Dynatrace news.

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

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

Agentic ecosystem as part of the agentic operations system

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

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

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

Ecosystem architecture

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

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

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

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

AI-accelerated troubleshooting and development in your IDE

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

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

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

AI‑assisted SRE operations with autonomous cloud investigations

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

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

AI‑powered incident management with real‑time production context

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

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

AI success is about people and processes

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

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

How to get started

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

Go to Dynatrace Hub to connect to Dynatrace MCP server.

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

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

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

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

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

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

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

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

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

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

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

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

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

Where the MCP Server delivers value

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

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

The Dynatrace MCP Server is now generally available

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

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

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

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

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

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

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

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

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

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

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

Dynatrace Intelligence: The new foundation for reliable agentic AI

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

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

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

The new Smartscape®: A source of truth for AI

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

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

From reactive to proactive with agents

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

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

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

Dynatrace Assist: Your portal into the agentic universe

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

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

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

End-to-end intelligence with next generation Dynatrace RUM

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

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

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

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

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

Building the future of autonomous operations

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

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

Executives are looking for successful ways to run their digital ecosystems with AI as cloud and AI adoption reach unprecedented complexity. Organizations are increasingly recognizing that agentic AI on its own can’t deliver the consistent, trustworthy outcomes they expect. With 65% of enterprises investing in AI‑driven monitoring and automation, leaders now need trustworthy AI‑powered observability to shift from human‑driven operations to human‑supervised, autonomous digital ecosystems.

Key executive insights

• Alongside the rapid adoption of agentic AI, Dynatrace is uniquely architected for powering real‑time autonomous operations across organizations’ digital systems while also integrating seamlessly into broader agentic ecosystems.
• Dynatrace – pioneer of large-scale AI-powered root cause analysis – established predictive operations and now further redefines observability, taking the next step from automation to autonomous action by auto-remediating, auto-preventing and auto-optimizing.
• Dynatrace takes the guesswork out of AI by optimizing the balance between deterministic AI, contextual analytics, and stochastic AI to drive precise agentic answers and reliable actions.
• Dynatrace Intelligence is an agentic operations system in the Dynatrace platform, driving autonomous actions through orchestrating ready-made Dynatrace agents as well as external ecosystem agents.
• AI engineering, AI operations, agentic SRE get enabled by Dynatrace with real-time production feedback-loops from trusted AI.

Minimizing hallucinations and avoiding large language model data processing limits

One of the biggest fears of executives who build agentic frameworks is that generative AI can hallucinate and push their agents off course. CTOs also prioritize ensuring agentic systems have instant access to high‑quality information, so multi‑step agent workflows can execute quickly and reliably.

Hallucinations aren’t minor errors – they can trigger wrong actions leading to outages, security risks, and financial exposure. To make it worse, in agentic processing inaccuracies can accumulate and amplify.

The Dynatrace AI approach reduces the risk of hallucinations by maximizing the use of deterministic AI in its agents, allowing Dynatrace to deliver responses based on real-time data rather than probabilistic guesses. Also, Dynatrace continuously observes, maintains, and enriches this context through real-time dependency graphs, real-world context, and high-performance data lakehouse analytics—fueling precise analytics and real-time answers across the entire digital services and business landscape.

This level of contextual precision is critical because large language models cannot directly process petabytes of heterogeneous observability data. Their context windows are limited, and performance often degrades as input approaches the maximum length.

Dumping large amounts of data into AI requests can reduce quality. Models have finite context windows and can underweight important details in very long prompts. Curating and structuring only the most relevant information generally yield better results than providing everything at once.

To overcome these constraints, it’s essential to rapidly distill vast amounts of data into short, high-quality context—this is where contextual analytics, dependency graphs, and the AI-optimized data lakehouse Grail become critical differentiators.

Real-time analytics with instant visualization of dependencies and interactions

Agentic AI depends not only on the model it runs on but on the quality, context, and immediacy of the data it receives—real‑time, fact‑based inputs are essential to keep pace with agentic decision‑making.

Grail, the Dynatrace data lakehouse, provides this foundation by unifying observability, security, and business data at an exabyte scale. Its schema‑on‑read approach removes indexing overhead and enables any‑question, any‑time analytics of Grail data. Grail processes metrics, logs, traces, user behavior, security events, and business signals alongside directed dependency graphs, delivering deep insights instantly through zero‑latency, always-hydrated storage.

Complementing this, Dynatrace Smartscape continuously refines a real-time dependency graph of real-world dependencies across business, teams, digital services, processes, infrastructure, risks, and more. By dynamically uncovering both vertical and horizontal dependencies, Smartscape enables teams to understand how systems, business processes, and organizational structures interact. The latest generation of Smartscape real-time dependency graph can now also be augmented with custom entities, such as business data types, ownership information, and other meta-data and ownership details, so teams immediately know who to notify for fast, fact-based remediation.

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 pre-requisite for reliable autonomous operations.

Dynatrace Intelligence

Dynatrace Intelligence is an agentic operations system at the core of the Dynatrace platform that fuses deterministic AI with agentic AI to drive a new level of reliability across observability and autonomous operations. It provides a unified intelligence layer where humans define the goals, and AI executes them with precision—guided by policies, context, and guardrails.

At the foundation are deterministic agents that create a highly reliable operational core. The Root Cause Agent, powered by deterministic causal AI, delivers answers with far greater speed and precision than LLM‑only approaches. The Analytics Agent distills petabytes of Grail data lakehouse data into concise, contextual intelligence, while the Forecasting Agent scales predictive capabilities across the environment. An Operator Agent oversees, orchestrates, and coordinates agentic team efforts to ensure optimal outcomes. These foundational agents power every other agent operating on the platform.

Building on this foundation are ready‑made, domain‑specific agents designed to extend and augment the work of Development, SRE, and Security teams. This fusion of deterministic AI, agentic AI, and specialized domain agents enables Dynatrace Intelligence to detect anomalies, predict issues, identify root causes, run complementary investigations, and plan and execute corrective actions—ultimately enabling auto‑prevention, auto‑remediation, and auto‑optimization.

Dynatrace already observes customers’ digital services, end‑user experiences, and AI stacks automatically, making these domain agents immediately impactful. As examples, for developers, Dynatrace detects rising mobile‑app crashes, analyzes the code paths, and produces an immediate fix suggestion—turning what used to take hours into seconds. For security teams, Dynatrace continuously monitors emerging threats and instantly checks the environment for related vulnerabilities or indicators of compromise, helping teams respond proactively before attackers can act.

New Assist Agents simplify the adoption and everyday use of Dynatrace, while Agentic Workflows empower customers to build their own agents.

Dynatrace Intelligence is here not only to remediate symptoms—like a production infrastructure overload—but also to detect the underlying root cause and generate actionable plans to fix the source of the issue.

AI-powered observability from Dynatrace enables the next generation software delivery life cycle process with AI engineering, AI operations, agentic SRE, and AI business analytics, through real-time facts from production systems.

Already today, Dynatrace Intelligence agents collectively power a wide range of real‑world use cases, from mobile app crash inspection and front‑end error explanation to infrastructure optimization, Kubernetes operations, and security‑context insights. They also accelerate tasks like anomaly and log‑pattern analysis, vulnerability validation, timeseries analysis, and even dashboard creation, with extensible workflows that let teams expand these capabilities as their needs grow.

Dynatrace Intelligence also coordinates a bi-directional interaction with the agentic ecosystem like AWS Kiro, GitHub Copilot, ServiceNow, Azure SRE agent, Atlassian Rovo and many others – e.g. submitting tickets, invoking a coding agent, assessing the risk of a new deployment, adjusting infrastructure, informing business workflows. It also responds when other systems request, for example, incident details, performance insights, business impact analysis, or resilience risk assessments.

Along with Dynatrace Intelligence, Dynatrace leads customers on a journey toward fully autonomous operations.

Journey to fully autonomous operations

Each organization goes through their own maturity stages and pace on the journey to autonomous operation; for the majority it can look like this:

Automated – a stage when an organization’s digital system executes pre‑defined workflows and actions automatically (based on AI‑generated answers) to support both reactive and predictive operations. I can say that currently, many organizations are striving to get to this stage or are already in it.

Digital systems must be automatable and observable. To validate this, workflows must be testable:

• Can you automate it?
• Can you observe it?
• Can you understand its behavior in real time?

Organizations don’t need to automate every single workflow. Once it’s possible to confirm that key use cases are both automatable and observable, organizations can progress to the next maturity stage.

Supervised Autonomous – in this stage, AI generates execution‑ready action plans with clear reasoning and acts only after human oversight and approval. In a “crawl‑walk‑run” approach, organizations start with small, repetitive tasks that require agentic AI instead of hard-coded workflows.

Key principles in evaluating ability for supervised autonomous operations:

• Reliability: For reliable decisions and actions, rely as much as possible on deterministic AI and analytics, and leverage generative AI for common sense and learned expertise.
• Transparency: Allow people to set goals and guardrails for AI, validate reasoning, review knowledge graphs, improve real-time feedback loops, and assess explanations to build trust.
• Feedback loop: Agentic AI relies on accurate factual inputs to create actionable plans, as well as precise real-time feedback to investigate plan details, refine them and validate execution.

Once the digital system consistently performs with human‑like review discipline, the organization is ready to move toward fully autonomous operations.

Fully Autonomous – in the future, fully autonomous stage, Dynatrace Intelligence acts independently to fulfill business goals and autonomously operates a wide range of aspects in successfully delivering software that end-users expect, requesting human input only when necessary. As much as Dynatrace uses AI to observe other AI within the cloud- and AI-native services customers run, it also continuously observes itself—to self-optimize, ensure compliance, and provide insights that help people set the goals. People still play a crucial role: they review outcomes, adjust goals, and refine instructions. As a result, organizations deliver and operate software with higher resilience, happier customers, and lower cost.

The fusion of deterministic AI and agentic AI sets Dynatrace apart by providing a reliable agentic AI-powered observability. It is an AI that observes other AI and helps organizations to build more resilient applications and better customer experiences.

The post Dynatrace Intelligence at the core of autonomous operations appeared first on Dynatrace news.

Key takeaways:

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

______

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

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

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

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

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

Succeeding together in the age of AI

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

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

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

Empowering people: The human + AI workforce

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

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

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

Customer success stories: Transforming operations with AI

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

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

Partner focus: Driving innovation and value together

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

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

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

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

Developers @ Perform: Built for people who ship code

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

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

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

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

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.

Modern software teams are shipping faster than ever. With cloud-native architectures, AI-powered development, fast releases, and continuous delivery pipelines, new features flow continuously from commit through development and testing into production in minutes.

While release velocity has accelerated, release risk has not disappeared. As modern software environments grow more complex, releases have become harder to understand and riskier to manage, placing increasing strain on developer experience while forcing organizations to balance rapid innovation with the reliability that customers expect.

That’s why Dynatrace has acquired DevCycle, a feature management platform built on the OpenFeature standard, to help developers, SREs, and platform teams bring progressive delivery for AI-native applications directly into the Dynatrace platform.

Why feature management matters in modern delivery

Feature flags are a core control plane for progressive delivery including:

• Canary deployments
• Blue-green releases
• Experimentation
• Rapid mitigation when something breaks

Feature flags are frequently used as standalone control mechanisms, allowing teams to change application behavior without clear visibility into the consequences of those changes. While teams can toggle features instantly, they lack direct insight into how each decision affects performance, reliability, and user experience in real time.

What DevCycle adds to Dynatrace

DevCycle brings enterprise-grade feature management built on OpenFeature, the open standard that Dynatrace helped establish. Together, Dynatrace and DevCycle will enable teams to:

• Reduce risk: Release features to small cohorts, validating behavior, and scaling gradually based upon real-time performance and error monitoring.
• Experimentation: Compare feature variants, models, or prompts using real traffic and real telemetry instead of offline assumptions.
• Improve MTTR: Use Dynatrace causal analysis to quickly pinpoint when a specific feature is driving an incident, and act immediately.
• Improve developer experience and flow: Give developers a fast, intuitive way to ship, test, and control features with immediate feedback from production telemetry.

Built on OpenFeature

Dynatrace recognized the importance of progressive delivery early by initiating and leading the OpenFeature standard in 2022. It is now a CNCF project and the industry’s open vendor-neutral standard for feature flagging.

Because DevCycle is OpenFeature-native, customers can use Dynatrace with DevCycle or with any OpenFeature-compliant feature flag system. This preserves openness, avoids lock-in, and gives teams flexibility as their platforms evolve.

Feature flags and observability in practice

Dynatrace brings together development, operations, and business teams to deliver software more efficiently, securely, and reliably. By integrating feature flagging, teams gain a single, contextual view of intent, execution, and outcome across the software development lifecycle.

Practical examples include:

• Roll out a new checkout flow only to premium users and immediately observe performance, errors, and conversion impact.
• Automatically disable a feature for a specific region if Dynatrace detects degradation.
• Test new AI prompts to compare latency, quality, and user behavior in real time.

This integration enables advanced use cases such as real-time, health-driven feature control and experimentation while integrating naturally into AI-assisted workflows. For example, an AI assistant can query the Dynatrace MCP Server to understand blast radius and KPI impact, then safely reduce exposure or disable a feature without redeploying code. By unifying feature management and experimentation with real-time observability, AI-powered insights, and automation, teams can make precise changes to application behavior without redeployments or manual intervention.

What’s next

This acquisition further advances observability into an active system of control. By integrating the precise runtime controls and centralized feature concept from DevCycle with comprehensive insights from Dynatrace, we will move closer to realizing our vision of an intelligent resilience platform capable of self-remediation, prevention, and continual optimization.

We are already working to integrate DevCycle capabilities into Dynatrace. Stay tuned for updates, and thank you for being part of the Dynatrace community!

The post Dynatrace acquires DevCycle to strengthen feature delivery for modern cloud and AI-native workloads appeared first on Dynatrace news.

Enterprise automation rarely fails because teams lack ideas. It fails because scaling automation safely is challenging, and conventional workflows often remain static after they ship, while systems and conditions continue to evolve.

The new update to Dynatrace Workflows helps teams accelerate their innovation loop and run automation like production software. Five improvements make it easier to iterate and operate at scale: workflow drafts, sub-workflows, approval requests, persistent execution data, and real-time notifications. Together, they support safer change, reusable standards, built-in governance, and data-driven refinement.

The innovation loop in enterprise automation

The innovation loop is a repeatable cycle for quickly and safely improving enterprise automation that treats workflows as living systems that evolve with your environment, self-improving as systems, teams, and requirements change, rather than remaining static:

• Teams start by designing or updating a workflow and validating it safely before it goes live.
• Next, they standardize the parts that work into reusable building blocks so future workflows are faster to create and more consistent.
• Then they add governance where it matters, such as approval checkpoints for high-impact actions, so speed does not bypass policy.
• After execution, they observe what actually happened using execution records and signals, including errors, latency, and outcomes, to understand reliability and impact.
• Finally, they refine the workflow based on those findings by tuning logic, tightening controls, improving reuse, and adjusting notifications.

The result is a compounding impact: faster delivery over time, fewer incidents at scale, automation that integrates changing circumstances, and greater organizational trust, as transparency, auditability, and tight feedback loops back improvements.

How Dynatrace Workflows accelerates the innovation loop

Dynatrace Workflows helps you accelerate your innovation loop with powerful new features designed for adaptability, collaboration, transparency, and control. Each feature is designed to empower teams to safely iterate on automation in dynamic enterprise environments.

Faster iteration with safer testing and experimentation with workflow drafts

The new workflow drafts feature allows teams to create, edit, and refine workflows in a draft state, allowing them to validate logic and configuration without triggering live automation. Workflows that remain in draft mode don’t consume workflow hours.

Workflow drafts support the first step of the innovation loop: iterate safely. Teams can make changes, review them with peers, and confirm the workflow is ready before anything runs in production.

Key benefits

• Reduce risk by testing configuration changes without production impact.
• Allow faster iteration and cleaner change management.
• Improve collaboration during the design and review stages.
• Control costs with included workflow-hour consumption for draft-only workflows.

Standardize reusable blocks for reliability and speed with sub-workflows

Sub-workflows allow a workflow to be executed as a task inside another workflow, so teams can package repeated logic into reusable sub-workflows and compose larger automations from consistent building blocks.

This supports the “standardize” step of the innovation loop. When teams standardize and reuse proven components, automation becomes more consistent, easier to maintain, and quicker to expand across teams and environments.

Key benefits

• Enhance reliability and consistency by reusing proven workflow components.
• Speed up delivery by composing workflows from standard blocks.
• Simplify maintenance by updating shared logic in a single location.
• Keep complex automations understandable by breaking them down into smaller, manageable units.

Example use cases

• Notification workflows: Automatically send notifications based on incident severity or timing.
• Data processing workflows: Run filter/transform/store stages as distinct sub-workflows, processing large datasets in stages.
• Incident response workflows: Automate repetitive tasks as reusable steps, such as creating tickets, logging incidents, notifying stakeholders, and triggering remediation steps.

Supervised human-in-the-loop control where it matters with approval requests

With Dynatrace Workflows, you can now insert an approval request into a workflow and pause execution until a human reviews and approves the next step.

This feature supports the “governance” step in the innovation loop. Approvals turn your workflows into supervised autonomous operations. This allows the automation of more processes while ensuring strict compliance with enterprise requirements for governance, risk management, and accountability, particularly for high-impact actions.

Key benefits

• Add explicit human control at high-risk decision points.
• Reduce errors in sensitive operations (changes, remediations, escalations).
• Ensure compliance with organizational standards.
• Increase trust in automation across security, ops, and platform teams.
• Minimize operational risks.

End-to-end visibility with an audit trail and persistent execution data

Dynatrace Workflows now persists workflow execution data in DQL. All workflow activities are recorded as system events in the dt.system.events table, creating a queryable execution record for tasks, states, and outcomes as a comprehensive audit trail.

Persisting execution data supports the “observe” step of the innovation loop. When workflow execution is captured as data, teams can troubleshoot failures, provide transparency, prove what happened, and improve automation based on evidence rather than anecdotes.

Key benefits

• Provide an audit trail for enterprise traceability and review.
• Monitor workflow health and reliability through execution outcomes.
• Speed up troubleshooting by pinpointing where failures occur.
• Optimize automation using DQL-driven actionable insights (error rates, trends, hotspots, and more)

Example: Workflow health overview

This example demonstrates how to use execution data to support users in identifying those workflows that need improvement.

The following DQL query…

fetch dt.system.events
| filter event.kind == "WORKFLOW_EVENT" and event.provider == "AUTOMATION_ENGINE" and event.type =="TASK_EXECUTION"
| filter dt.automation_engine.state == "ERROR"
| summarize count = count() , by:{dt.automation_engine.workflow.title}

…counts task execution errors per workflow. Using a honeycomb visualization, it displays error distribution by workflow and provides visibility into those workflows that fail too often.

Instant alerts for failures and workflow changes with real-time notifications

Easily set up and customize real-time notifications by email for all workflow errors or changes made by others, ensuring you’re always informed.

These real-time notifications support the “respond and refine” step of the innovation loop. Proactive alerting allows you to manage workflows effectively, minimize disruptions, and maintain seamless operations.

Key benefits

• Get immediate visibility into failures to address potential issues before they escalate.
• Detect workflow changes early to reduce drift and surprises.
• Improve operational coordination across teams that share workflows
• Ensure uninterrupted operations with timely, actionable alerts.

Empower your team: Build smarter, safer, and scalable workflows today

Scaling automation today is hard, changes are risky to test, automation becomes outdated and buggy as soon as one part of the organization makes changes, and when something inevitably breaks, you’re left hunting for answers across scattered logs and screenshots. But it doesn’t need to be like this.

Are you ready to make things easier, run your workflows like production software, and accelerate your innovation loop? Here’s how you get started:

• Explore our documentation to learn more about these features.
• Join the Dynatrace Community to connect with other users and share your insights in the Workflow and AutomationEngine feedback channel.

The post Reliable enterprise automation at scale: Accelerate the innovation loop with Dynatrace Workflows appeared first on Dynatrace news.

When people first started saying they were using AI to build full apps, I was wildly skeptical. You’ve heard these stories too, right? “I built a complete SaaS platform in one weekend using ChatGPT!” Sure, you did.

But I kept hearing it. Over and over. Whole apps. Entire startups. Just prompts. So, I decided to test the hype. I’ve had the idea to build an app to help collectors track and manage their sports card collections for years. I’ve tried Excel, Google Sheets, Airtable, and even Retool. They are all excellent tools but weren’t the right ones for the job I was trying to accomplish. But after a friend showed me how he was using Claude Code in his CLI, the light bulb went on.

Two weeks later, I had a working site. Authentication. A database. A clean interface. All built with AI tools, a little stubbornness, and an embarrassing number of “let’s try that again” moments.

That’s when it hit me: It’s not vibe coding if you know what you’re doing.

The CLAUDE.md rulebook

The first lesson I learned: AI needs boundaries. So, I made a file called CLAUDE.md. Think of it like an employee handbook for a very confident robot. It spells out how I want things done — naming conventions, frameworks, the tone of my responses; even how to handle uncertainty. Without it, Claude will take creative liberties. With it, it’s like working with someone who mostly listens and only occasionally decides your database schema needs “personality.” You don’t need to go all in on “spec-driven development” when you’re first starting out, you just need some guide rails.

Second, design consistency is not AI’s strong suit. One minute it’s using Material UI, the next it’s gone rogue with pastel buttons and drop shadows from 2007. I started a design guide just to keep it on the rails. It made things infinitely easier to describe and control, all in one place.

An excerpt from the rulebook

# Claude Development Notes

## 🚨 CRITICAL: HOW TO WORK WITH THIS USER (READ FIRST - EVERY SESSION)

### Core Working Principles - NEVER FORGET THESE

1. **BE A SYSTEMATIC CODE ANALYST, NOT A GUESSER**

- ALWAYS search for existing code patterns, dependencies, and conflicts BEFORE attempting fixes

- Use grep, find, and comprehensive code analysis to understand root causes systematically

- Don't apply "band-aid" fixes - identify and solve the underlying architectural issue

- Leverage your file search and cross-reference capabilities instead of making the user debug manually

- This applies to CSS, JavaScript, database queries, API endpoints, configuration - EVERYTHING

2. **THINK LIKE AN EXPERT WITH DEEP SYSTEM KNOWLEDGE**

- Consider how changes affect the entire system: dependencies, imports, inheritance, scoping

- Look for naming conflicts, architectural patterns, and existing conventions

- Analyze the broader codebase structure and established patterns before making changes

- Understand the user is building maintainable, scalable, isolated components

- Apply this expertise to ALL aspects: styling, logic, data flow, security, performance

You can view the full rulebook here.

Don’t give AI the keys to the kingdom

Those initial guard rails will get you started, but they aren’t enough. You’re going to need reliable source control. Badly. AI can (and will) make sweeping changes in seconds. Whole sections of your project — just gone. It’s not malicious, it’s just eager. Commit early, commit often, and keep your fingers hovering over the ESC key to interrupt bad ideas.

Next: Write tests. I know. You won’t want to. Neither did I. But AI code that “works” can still be deeply wrong. I can’t tell you how many times I’ve seen it confidently try to pass data through functions that don’t even exist.

Perhaps most importantly: Never — and I mean never — let AI near your production database or environment. That’s not a metaphor. Twice, my AI coding partner has seen differences in our ORM and our database schema, and twice I have seen it decide to drop all of the database tables to create something that matches the ORM. Thankfully, it was only the development database, but if it had access to production, it would have dropped those tables too.

I have a rule: Staging is for the robots; production is for adults.

“AI forgets. Teammates inherit.”

This is painfully true. AI forgets everything. Context, logic, variable names. All of it. And when you come back to that project later (or someone else does), there’s no memory of why anything was done the way it was. That’s why documentation still matters. Probably more than ever. Because you’re not just documenting for other people anymore — you’re documenting for yourself when your future self wonders, “Why did past me let the robot do this?”

Observability, or “Please tell me what just happened”

This is where tools like Dynatrace come in. I know, I work there, but I’d say this either way. If you’re going to let AI write your code, you need a way to see what it’s doing. Not just logs — observability. Dynatrace tells me what’s happening across the system: slow API calls, inefficient queries, the occasional “why is this endpoint melting the CPU?” moment. It’s not about catching mistakes — it’s about catching surprises. And AI delivers plenty of those.

“Don’t asume corectness”

The typo’s intentional. Mostly. But the point stands: AI code looks right more often than it is right. I’ve had it produce entire components that look perfect and fail silently. It’s confident. It’s articulate. It’s wrong. So, check everything. Run it. Test it. Review it. Don’t just asume corectness.

The big takeaway

Here’s what surprised me the most: Building with AI doesn’t feel like cheating. It feels like collaborating. You’re still making all the decisions — the AI just types faster than you do. It’s like pairing with someone who’s read every Stack Overflow thread but still can’t quite tell when it’s about to create a security hole.

You’re not outsourcing the work. You’re accelerating it. AI doesn’t replace developers. It amplifies them. The people who’ll thrive in this new era aren’t the fastest typists — they’re the clearest thinkers. They’re the best communicators.

I don’t think “vibe coding” is bad. It’s just unstructured. And once you’ve got a plan — a CLAUDE.md file, a solid process, some observability, and a healthy dose of skepticism — it stops being “vibe coding” and starts being modern engineering.

AI can write code. But you still have to lead.

It’s not vibe coding if you know what you’re doing. It’s just engineering with better tools.

The post Is it vibe coding if you know what you’re doing? appeared first on Dynatrace news.