If you want to see them in action, head over to our Release Radar launchpad on the Dynatrace Playground.

Smartscape gets a unified topology view and ad-hoc filters

In a significant Smartscape update, a new All topology view shows every relationship for a given node in a single graph: the infrastructure stack, communication flows, and relationships such as monitoring, load balancing, routing, and API dependencies. Where the existing Vertical and Horizontal views each focus on a subset of relationships, the All view provides a more comprehensive view of relationships, from any node in any app across the platform.

Two changes make these views faster and more focused:

• The AWS and Kubernetes views now use flat layouts instead of nested ones, bringing the same relevance-based edge fetching and priority-driven node loading used elsewhere in Smartscape for more consistent visibility across your cloud landscape.
• New ad-hoc node and edge filters let you narrow any view by node type, cloud and infrastructure labels, team ownership, environment, and other properties.

Filters work alongside segments and are saved in the URL, so you can bookmark and share a focused view with segment, timeframe, and filters all preserved.

Press Ctrl+F (Cmd+F on Mac) in any Smartscape view to find nodes by name or ID. Matching nodes are highlighted in the graph, and the legend is narrowed to matching entity groups.

For broader context on Smartscape, see The new Dynatrace Smartscape improves operational efficiency across clouds, Kubernetes, infrastructure, and more.

AI Observability gains LLM evaluation, OpenInference, and Python instrumentation

AI applications can fail without obvious indicators — returning responses at normal speed with no errors, while delivering answers that are inaccurate, unsafe, or inconsistent. Traditional performance monitoring misses this entirely.

dt-evals is a new open source CLI that closes that gap. It pulls live gen_ai.* spans directly from your Dynatrace environment. Built-in evaluators use an LLM judge to score real production interactions for faithfulness, hallucination, relevance, toxicity, bias, PII leakage, prompt injection, and drift. The judge writes structured results back to Dynatrace as business events. Evaluation scores sit alongside latency and error metrics in the same dashboards. These scores can trigger alert workflows and gate CI/CD releases based on quality thresholds the same way that performance metrics do. For the thinking behind this approach, see Evaluate LLM and agent quality in Dynatrace AI Observability and LLM evaluations as a foundation for trustworthy agentic AI systems.

Dynatrace OneAgent now automatically instruments Python applications that use AWS Bedrock, OpenAI, Azure OpenAI, and LangChain. Dynatrace captures distributed traces, logs, and AI-related telemetry for supported model interactions — provider, operation, model, duration, token usage, and prompt and completion metadata where available. To capture prompt and completion content, go to OneAgent features and turn on Python OpenAI prompt capture.

The same visibility extends to teams using OpenInference with OpenTelemetry (OTel). Dynatrace ingests OpenInference traces and normalizes them to the same gen_ai.* attribute schema — covering model usage, token consumption, prompts, completions, agents, tools, embeddings, and guardrails — so OTel-instrumented applications get consistent telemetry without switching instrumentation frameworks.

As AI adoption grows, evaluation and instrumentation together turn AI services into observable, governable assets rather than black boxes.

Logs gains pattern analysis, Kubernetes insights, and in-context traces

Log analysis gets three meaningful upgrades.

Log pattern analysis (Preview) lets you aggregate query results in Logs into patterns that cluster similar logs together. You can focus quickly on recurring errors, reduce thousands of similar logs to a handful of patterns, recognize the changing parts of a pattern (and their datatypes), and reuse the generated Dynatrace Pattern Language (DPL) for other queries or in OpenPipeline.

In-context trace details mean that when you investigate a log entry with trace context, you can open the associated trace directly inside Logs. A waterfall icon signals that you stay in context rather than navigating away to Distributed Tracing.

Log insights in ready-made Kubernetes dashboards provide built-in log analytics for clusters, namespace workloads, namespace pods, and node pods. Error log counts appear alongside health metrics, with log level distribution and severity trends below. Direct links to the Logs app ensure that a deeper investigation is only one click away.

Faster service investigation with the Services Explorer Preview

The Services app now includes a visual service map that overlays performance and health indicators on service-to-service relationships and messaging flows. It’s the fastest way to understand blast radius during an incident, providing a single view of topology context, performance signals, and bottlenecks without switching views.

You can also filter services directly by primary Grail fields such as k8s.cluster.name, k8s.namespace.name, aws.region, and azure.location — the same attributes that power segments across Dynatrace. Both capabilities are available in the Explorer Preview view and open for feedback before general availability; see the Community post for details.

New security integrations and a Kubernetes security tab

Threat Observability expands its ingestion options with new integrations. Dynatrace now integrates with Checkmarx for software composition analysis and container security findings, and adds CrowdStrike and Kyverno integrations — pulling detection findings and Kubernetes policy compliance data into Dynatrace as security events. For Kyverno, see Ingest Kyverno compliance findings.

Kubernetes monitoring also gets a dedicated security tab (Kubernetes app version 1.42.0+) that replaces the Vulnerability tab in the Explorer, bringing security context into the same place teams already investigate cluster health.

Runtime Vulnerability Analytics now has a native interface, replacing the legacy management-zone-based monitoring rules with a single consolidated workflow.

One change worth flagging for security teams: ingested security.events must now carry a timestamp within −1h/+10min, tightened from the previous −24h/+10min window. Events with older timestamps are dropped, so please review any pipelines that backfill security events.

Performance, drilldowns, and navigation improvements

Improved discovery of ready-made dashboards. Ready-made dashboards deliver instant insights without requiring complex queries. Finding, installing, configuring, and customizing them is now more straightforward — so new users get value faster and experienced users can build confidently on best-practice templates.

Contents tab added to all extension apps. All extension apps in Dynatrace Hub now include a Contents tab that surfaces the extension’s ready-made dashboards, so you can quickly go from installation to insights.

Session Replay has two improvements:

• Full-screen mode is now available, removing viewport constraints during playback.
• Navigating to a session through Error Inspector now opens Session Replay directly in context, keeping the investigation continuous.

Cleaner Smartscape topology. Inactive Synthetic Locations no longer appear in Smartscape, keeping topology views focused on what’s live.

Smartscape navigation for database tables and indexes. Direct navigation intents let you jump from a database node to its table or index detail view in one click.

Filters stay with you. Automated filtering suggestions scope correctly to OR and AND conditions across all apps. Filter state, search terms, and highlights survive page reloads. HTTP Status Filter selections persist through navigation steps in Distributed Tracing.

DQL durations support decimals. Duration literals (h, m, s, ms, us, ns) now accept decimal numbers — for example, 0.5h or .2m. Note, however, that this doesn’t apply to calendar durations.

More headroom in Distributed Tracing. The log viewer no longer caps at 1,000 entries, with full deduplication across trace and span IDs. Span scan limits are configurable from settings (default 5,000, up to 10,000). Field naming is also cleaned up — Smartscape fields drop the redundant prefix, and classic ME fields are clearly labeled.

More allowlist entries for external requests. You can now add up to 100 allowlist entries, double the previous limit of 50, with existing entries preserved across all environments.

Affected entity names enriched in problem records. A new affected_entity_names array is now populated alongside the existing affected_entity_ids and affected_entity_types arrays, index-aligned across all three.

This brings the 3rd-gen platform to parity with classic problem notifications and enables notification workflows and external integrations to reference entity names without additional lookup. The Problems app v1.27 reached General Availability on June 29.

Proactive Cost Intelligence across your entire stack

Dynatrace now makes it easier to understand costs, act before they spike, and optimize with less effort. New Optimize documentation walks Dynatrace Platform Subscription (DPS) customers through the full journey from understanding to optimizing costs, aligned with the FinOps Foundation framework.

The bigger shift is that Dynatrace Assist can now do the cost analysis work for you, designed to reduce the need for specialist expertise. You can ask it to:

• Understand spikes — “I received a notification that costs have increased. Can you find anything notable?” returns the root cause along with a full drilldown into your billing_usage
• Predict costs — “Based on my log ingest usage over the last 90 days, can you predict my usage for the next 30 days?” returns a capability-level forecast based on actual consumption, useful when onboarding new teams.
• Optimize usage — “Are there any log queries duplicated by multiple users?” surfaces overlapping queries with concrete suggestions to improve them.

For more on building cost discipline into your observability practice, see Driving your FinOps strategy with observability best practices.

Why these changes matter

Taken together, the June releases make everyday investigation work feel less fragmented. You get more context in the places where teams already troubleshoot: a fuller Smartscape view, AI quality signals alongside performance data, log patterns that identify root causes faster, service maps for incident response, and security and cost insights that are easier to act on without switching tools or relying on specialists.

These are the kinds of changes that add up across a week of real work.

Check out all these updates in action on our Release Radar launchpad.

The post Dynatrace Release Radar 06.26 appeared first on Dynatrace news.

This edition of Release Radar covers the Dynatrace releases from May, 2026. Here are the changes that should matter right away to practitioners:

• AI tooling
• AI coding agent monitoring
• Jira integration
• Dashboard productivity
• Pipeline grouping

To see them in action, head over to our release radar launchpad on the Dynatrace Playground.

Dynatrace Assist: At your side with more context

Dynatrace Assist gets four upgrades in sprint 1.338 that deepen its usefulness during active investigations.

Side-by-side mode puts the chat interface in a collapsible panel alongside your current view — dashboard, notebook, or any other app page stays visible while you work with Assist. Chat and investigate at the same time without losing your place.

Reference files and skills give Assist access to a curated knowledge base built on Dynatrace documentation and product expertise, following the Anthropic Claude Agent Skills format. Responses are designed to draw on structured Dynatrace knowledge, so answers are grounded in how the platform actually works.

Anthropic Claude Sonnet 4.6 as the foundation model can help bring stronger multi-step reasoning and improved performance on complex, multi-tool investigations — the same model used in the latest Anthropic API and Claude Code.

A purpose-built NL2DQL model makes natural-language-to-DQL generation more accurate. The capability now uses a fine-tuned foundation model based on Llama 3.1 8B, trained specifically on Dynatrace query patterns. Write a question in plain language and get a working DQL query with fewer iterations.

AI coding agents get unified monitoring

Dynatrace now provides observability for five major AI coding agents: Claude Code, Google Gemini CLI, OpenAI Codex CLI, OpenCode, and GitHub Copilot SDK.

As  your team adopts multiple AI agents in parallel, you need shared visibility into what they cost, how they behave, and what they produce. This release gives platform teams, engineering leaders, and security teams a  unified observability across all five agents, all built on OpenTelemetry.

What teams get across the supported agents:

• Adoption and token tracking — session counts, token consumption, and cost trends across agents and teams.
• Tool behavior visibility — which tools each agent calls, how often, and where runs slow down or fail.
• Production context in the IDE — engineers can query live Dynatrace data through the Dynatrace MCP Server without leaving their coding environment.
• Engineering outcome correlation — connect agent activity to downstream delivery signals like commits and pull requests (available for Claude Code).

Pre-configured dashboards are available for each agent. For the full breakdown by agent and setup details, see Dynatrace expands AI coding agent monitoring.

Investigate production problems without leaving Jira

The Dynatrace MCP Server now integrates with Atlassian Rovo, bringing observability context directly into Jira and JSM tickets.

When an incident or issue is open in Jira or JSM, Rovo can now call Dynatrace tools in natural language — querying metrics, traces, logs, and topology — and post the results as ticket comments. Root cause analysis and dependency mapping happen inside the ticket, so engineers stay in context instead of switching between platforms.

Key points for practitioners:

• No context switching — investigate and document findings without leaving Jira or JSM.
• Per-user OAuth 2.1 — every Dynatrace call runs as the requesting user, with a full audit trail across both platforms.
• Admin-controlled tool exposure — administrators choose which Dynatrace tools Rovo can access.
• Included with Dynatrace SaaS — no additional cost, and adding users doesn’t change the pricing.

It’s designed for fast setup: authenticate via the Rovo admin UI, select the tools to expose, and the integration is live across Jira, JSM, and Confluence.

For the full walkthrough, see Dynatrace MCP Server for Atlassian Rovo.

Dashboards: build faster, navigate better

Releases 1.338 and 1.339 bring a focused set of dashboard improvements that add up across a day of analysis work.

Ready-made tiles and sections expand the dashboard and notebook library with pre-configured visualizations and built-in drill-downs to other Dynatrace apps. Browse or search the tile library to find components that are ready to use, and customize from there rather than starting from a blank canvas.

Direct JSON editing lets power users open and edit the full dashboard definition as JSON from the dashboard Actions menu. The format matches the Dashboard API, so configuration changes, bulk tile edits, and version-controlled workflows are all faster in the editor than in the visual UI.

URL-driven variables make it possible to configure hidden dashboard variables through URL parameters, enabling pre-configured views to be linked directly with filters already applied — useful for sharing context-specific dashboards with specific teams or stakeholders.

Launcher link reordering lets users drag links between sections in the launcher, making personal navigation layouts easy to maintain.

Active tile tab persistence keeps the last-active editing tab visible when switching between tiles, so the configuration state is preserved while navigating across a dashboard.

Pipeline groups get a configuration UI

Pipeline groups, which let central teams enforce shared policies across multiple OpenPipeline pipelines, now have a dedicated configuration interface in Early Access (sprint 1.339).

Platform teams can now configure group-level policies in the UI, including cost allocation and sensitive data scanning. Pipeline teams still control their own parsing and extraction logic, so central governance doesn’t come at the cost of local flexibility. No direct API access required.

This UI makes the feature accessible to a wider set of platform operators and can help reduce setup costs for organizations running large, multi-team pipeline environments.

For background on pipeline groups and the governance model they enable, see Pipeline Groups in Dynatrace OpenPipeline.

Latest UX improvements

Investigation workflows in logs get sharper. Join the Log pattern analysis preview and see how selected log patterns now open a dedicated deep-dive panel showing behavior over time and associated records — inspect pattern-level context without losing the overview, and drill into individual log records from the same panel without navigating away. Log attributes open in full-screen mode for reading long or nested JSON in place. When Logs is opened from a contextual link in a dashboard or alert, the query runs automatically — no extra click required.

Navigation, filtering, and performance also improve across several surfaces. In the Session List, a tooltip on the Session Replay icon shows replay availability — full, partial, or none — so you can triage which sessions have usable replay before opening them. The Services explorer gains dynamic tag filters for Kubernetes namespace annotations and labels, expanding filter coverage for k8s-heavy environments. Infrastructure inventory in large network environments now loads in 3–5 seconds in typical environments, with status and reachability columns loading progressively so the view is immediately usable at scale. Press Shift + ? anywhere in the platform to open the keyboard shortcut reference.

Why these changes matter

The May releases extend capabilities across the workflows that practitioners use most. AI tooling stays present during investigations. Coding agents become observable assets, not black boxes. Dashboards get faster to build and easier to manage. Cost data supports annual planning. And pipeline governance reaches more teams through a UI.

These are the kinds of changes that add up across a week of real work.

Check out the updates in action on our Release Radar Launchpad.

The post Dynatrace Release Radar 05.26 appeared first on Dynatrace news.

The April 2026 Dynatrace SaaS releases bring six updates aimed at a familiar problem: too much manual work between a signal and an answer. The updates focus on native cloud visibility, deeper Kubernetes insights, consistent severity handling, faster investigations, and smoother analytics work.

Explore all updates hands-on in the Release Radar launchpad.

A native Azure experience in Clouds

What does Dynatrace add for Azure practitioners?

Dynatrace now extends the enhanced Clouds experience to Microsoft Azure, putting Azure subscriptions on the same footing as AWS. Metrics, logs, metadata, and topology now sit in one managed view, so Azure teams can move from inventory to investigation without stitching the picture together by hand.

What you get out of the box

• Opinionated insights and ready-made dashboards built from enriched Azure telemetry, so investigations start with answers instead of a blank canvas.
• Pre-configured health alerts for Azure, created and managed directly in Clouds, with drill-down, search, and filtering directly in the Clouds app.
• Broad metric coverage for any Azure Monitor native platform metric across Azure services.
• A rich Azure topology inventory that periodically scans Azure environments and enriches resources with native metadata such as tags and subscription IDs, all queryable with Dynatrace Query Language (DQL).
• Simple onboarding and lifecycle management that turns Azure subscriptions into native Dynatrace connections and manages them centrally.

Dynatrace also adds drilldowns from cloud entities into the relevant Dynatrace experiences, so teams can keep moving instead of bouncing between cloud and platform views.

Kubernetes visibility for autoscaling and custom resources

What’s new in Kubernetes observability?

Dynatrace extends Kubernetes visibility to two additional object types that SREs and platform teams rely on daily: Horizontal Pod Autoscalers (HPA) and Custom Resources (CRs).

Horizontal Pod Autoscaler as a first-class object

HPA is now a first-class object in enhanced Kubernetes visibility. You can see when scaling kicked in, what triggered it, and how desired and actual replica counts lined up next to the workloads involved.

Custom Resource insights

You can monitor up to five Custom Resources per cluster, surfaced the same way as built-in Kubernetes objects. This brings CRD-heavy ecosystems such as Argo, Istio, Cert-Manager, Kyverno, and operator-managed databases into the same investigation scope as the rest of your cluster.

For clusters connected through cloud integrations, the Kubernetes cluster details page now exposes the underlying cloud configuration (EKS, AKS, or GKE) in YAML or JSON, making cloud-side and cluster-side state accessible in one place.

A unified severity model for alerts and problems

What is event.severity in Dynatrace?

Dynatrace introduces a standardized event.severity field for alerts and problems, aligned with the ITIL Incident Management framework. Severity is stored in Grail as an integer from 1 (Critical) to 5 (Informational) and is shown as a human-readable label across the platform.

Severity levels at a glance

Severity automatically propagates from correlated alerts to the parent problem, with the highest severity always taking precedence. This gives teams one severity model to filter on, route with, and escalate from.

You can now:

• Filter the problem feed by severity
• Display a severity column with visual icons in problem lists
• Use severity as a condition in Workflows for alert routing and notifications

Faster Investigations with Smartscape navigation

What changed in Smartscape?

Smartscape now offers all six ready-made views, such as vertical topology, horizontal topology, and visual resolution path, just a click away in a persistent side panel. You no longer need to return to the landing page in the middle of an investigation.

The new Recent views section shows your latest investigations, making it easy to reopen them, compare them, and keep working as you test a root-cause hypothesis.

The result is less backtracking in the middle of an incident.

Dashboards and notebooks: productivity improvements

What’s new for dashboard authors and analysts?

The latest release adds several practical upgrades for team members who build dashboards and work in notebooks every day.

• Treemap visualization for identifying dominant categories in hierarchical data, such as requests per service by Kubernetes namespace.

  

• Dashboard variables for dynamic coloring and thresholds, so visual conditions stay in sync with environment or team selectors.

  

• Centralized tile indicator controls, allowing you to show or hide warnings, descriptions, and custom timeframes at the dashboard level.

  

• Direct image upload in Markdown using a built-in image library shared across Dashboards, Notebooks, and the Launcher.

  

• Row marker coloring for tables, making it easier to visually group related rows without sacrificing readability.

  

User experience improvements

Why does the platform feel faster?

This release smooths out the path from the first symptom to root cause analysis. Tracing and services workflows now handle high-span traces more reliably, show timing more clearly, and surface useful sample traces earlier.

Table-first workflows also benefit from richer entity-detail tables, better filtering, and clearer structure, helping teams answer more questions without switching views. Navigation patterns, overlays, and error messaging are now more consistent across the platform, reducing mental overhead when time is tight.

Why these updates matter

Taken together, these updates eliminate inefficiencies in the work that teams do every day. Cloud operations teams, Kubernetes SREs, on-call engineers, and analytics authors get richer context, faster paths to answers, and simpler ways to share what they find. This is where Dynatrace earns its keep under pressure.

Explore the updates live in the Release Radar launchpad.

The post Dynatrace Release Radar 04.26 appeared first on Dynatrace news.

The March SaaS releases, 1.334 and 1.335, sharpen how teams investigate issues, apply business context, handle security findings, and manage governance. The platform gets more useful precisely when the pressure is on.

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

Actionable compliance insights

The Compliance Assistant is now generally available. It shifts compliance from a documentation effort to real-time insights, connecting rules, incidents, risks, and business-critical services while systems run. Validation happens as things move, not after the fact. DORA support comes ready-made. For example, you can:

• Map critical functions to IT assets through Business Flow.
• Track compliance health.
• Classify incidents against regulatory thresholds.

This means less chasing evidence across separate tools and better visibility into how business-critical processes really behave. Read our Compliance Assistant blog to learn how Business Flow and Smartscape® on Grail® tie compliance-critical business processes to the supporting IT components and identify related risks in an operational context.

Vulnerability findings that are easier to trust

Dynatrace now uses a native Dynatrace Vulnerability feed to detect vulnerabilities. The new feed delivers more accurate, transparent, and threat-aware vulnerability data while preserving strong coverage of critical risks.

The Dynatrace vulnerability feed is informed by multiple reputable sources, including OSV.dev, GitHub, NVD, and vendor advisories, and is then curated and enriched with Dynatrace’s own research. The result is better accuracy, clearer remediation guidance, and less noise when teams need to decide what to fix first.

These enhancements also support another March security change: Security Posture Management now uses CCSS-based severity classifications for benchmark rules. Together, these changes improve the quality of the vulnerability data that security teams work with, not just the number of findings.

Lookup tables allow adding more context easily

Lookup tables in Grail are now generally available, enabling teams to build dashboards and queries that reflect how their business works.

A lot of observability data is technically rich but hard to read in operational terms. The lookup tables blog shows exactly where teams feel that pain: dashboards full of cryptic identifiers, while customer, country, or store context lives somewhere else entirely. Joining Grail data with lookup tables at query time turns those IDs into readable business context inside DQL and dashboards.

Results become easier to act on. Spreadsheets, manual mappings, and custom processing outside the platform become unnecessary. Teams ask better questions and get answers in terms they recognize.

Extended Synthetic monitor enhancements

Synthetic monitoring is most useful when it explains why performance is slow and how to improve it. The March Synthetic monitoring blog showcases the updated browser monitor experience, which now includes:

• Richer execution details in Grail,
• DQL access to those events, and
• An enhanced Requests waterfall in the latest Dynatrace experience.

Instead of vague timing summaries, teams can use the new requests waterfall to:

• Inspect every loaded resource.
• See exact load durations.
• Identify initiators such as scripts or XHRs.
• Spot render-blocking behavior.
• Quickly find failed assets or retry attempts.

In practice, this means a slow Synthetic browser run is much easier to explain: Teams can see which resource caused the delay and quickly understand whether the issue lies in frontend code, third-party scripts, rendering, or network behavior.

Just as important, browser monitor executions are now stored as events in Grail and can be explored with Dynatrace Query Language. This gives teams a much better way to filter, aggregate, and correlate Synthetic results with other telemetry, and it opens the door to more useful dashboards, troubleshooting workflows, and automation. Dynatrace also adds support for enriching Synthetic data with primary Grail tags, making it easier to group results by dimensions such as team, application, or environment without additional post-processing.

Easy analytics with dashboards and notebooks

The March updates improve both dashboard creation and day-to-day analysis activities.

On the creation side, teams can resize multiple dashboard tiles at once, add tiles, and duplicate tiles without breaking the dashboard layout. Chart configuration is cleaner too, with a unified color palette and more powerful threshold controls across Dashboards and Notebooks, so teams can maintain visual consistency without extra UI friction.

On the analysis side, practical improvements were made to troubleshooting and data exploration. Dashboards now support annotations on time series charts, so deployments, alerts, problems, and custom events can be overlaid directly on metric trends, without context switching. Table workflows were also improved in both Dashboards and Notebooks: the new details panel lets teams inspect wide rows in a side panel, while pinned columns keep key identifiers visible as you scroll through larger result sets.

For teams watching cost and usage, the new Usage – Logs ready-made dashboard shows log-query consumption across the platform, helps spot spikes, and highlights which dashboards and notebooks are driving the most usage. This gives teams a better way to understand which views are expensive and where optimization work will pay off most.

Closing thoughts

Above all, our March updates make Dynatrace easier to use in real situations.

Compliance is tied more closely to the live operational context. Security findings are supported by stronger signals. Grail can incorporate business metadata more naturally. Synthetic browser runs are easier to investigate. And teams get better access to analytics through a variety of dashboard and notebook enhancements.

Teams will feel the difference when they investigate, prioritize, and decide.

The post Dynatrace Release Radar 03.26 appeared first on Dynatrace news.

The February Dynatrace® SaaS releases continue a clear trend: extending powerful platform capabilities to help practitioners move faster, stay in context, and scale with less friction. This edition of Release Radar focuses on five enhancements that stand out in enabling practitioners to get their data in context autonomously while helping them to better understand their environment and troubleshoot easily.

If you want to see these enhancements in action, head on over to our release radar launchpad on our playground environment.

Bring topology into the natural flow of troubleshooting

Smartscape® is a powerful tool for understanding live dependencies across modern environments. With version 1.333, Dynatrace makes that context easier to access by adding View Topology directly to entity pages in Clouds, Infrastructure & Operations, and Kubernetes.

This is a meaningful refinement because effective troubleshooting depends on staying in flow. When practitioners spot an issue on an entity page, they can now move directly into real-time topology and explore surrounding dependencies without detouring into a separate workflow.

Scale governance without slowing teams down

OpenPipeline® gives teams a flexible foundation for ingest and processing. With version 1.333, pipeline groups are now generally available, giving central teams a way to enforce shared policies across multiple pipelines at once, including security context, cost allocation, and sensitive data scanning, while still leaving parsing and extraction logic in the hands of individual teams.

This is where Dynatrace extends flexibility with cleaner operational guardrails – unlocking a way for safe scaling. Platform teams can standardize the controls that matter most, while application teams keep the autonomy they need to move quickly. For larger environments, especially, such a balance is essential.

Add additional dimensions for OTLP metrics

One enhancement for OpenTelemetry Protocol users is the expansion of OpenTelemetry Protocol (OTLP) metrics ingest so that all OTLP resource attributes are now available as dimensions in Metrics powered by Grail®. Dynatrace also added controls to limit which attributes are carried forward, including a deny list for OTLP sources and an allow list for Metrics Classic.

This update adds richer metric dimensions and stronger controls, making OTLP-based metrics easier to analyze, govern, and own while extending the core strength of Dynatrace Grail and preserving context at scale.

Get sharper answers from synthetic analysis

Synthetic monitoring helps teams catch digital experience issues early. Now, Dynatrace makes that workflow more actionable with the new browser monitor execution analysis page, which helps isolate the specific resources in specific executions that are affecting performance.

Once a run is flagged as slow, the next question is always the same: What exactly made this run degrade? This enhancement gives practitioners a more direct path from symptom to likely cause.

Make Primary Grail tags more useful across the platform

Across the February releases, Primary Grail tags have appeared in more places. In 1.332, Dynatrace added them to Segments, where they now show up in suggestions and autocomplete. In 1.333, they were also added to Synthetic monitor configurations.

This is a quiet but important improvement. The more consistently teams can use the same organizational language across telemetry, filtering, and configuration, the easier it becomes to move between workflows without losing context. Dynatrace already does a strong job of preserving meaning across data; this enhancement makes that consistency even more useful in practice.

Why these five Dynatrace enhancements matter

Taken together, these updates show Dynatrace continuing to strengthen the workflows practitioners already trust. Smartscape is easier to reach during troubleshooting. OpenPipeline becomes easier to govern at scale. OTLP metrics on Grail carry richer, more useful context. Synthetic analysis gets more precise. And Primary Grail tags continue to unify how teams organize and work with data across the platform.

Check out the updates in action on our release radar launchpad.

The post Dynatrace Release Radar 02.26 appeared first on Dynatrace news.

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

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

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

Dynatrace Intelligence

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

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

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

Smartscape: Real-time dependency graph

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

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

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

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

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

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

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

Cloud Operations for AWS

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

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

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

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

Real User Monitoring experience

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

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

AI observability

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

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

Investigations: Transform how practitioners derive actionable insights

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

Improved Dashboards experience

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

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

Where to start this week

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

Get started: SREs

1. Start with Dynatrace Intelligence for faster incident loops

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

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

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

3. Automate closure with agentic workflows (Preview program)

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

Get started: Cloud owners

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

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

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

Get started: Development teams

1. Start from user impact with the new RUM experience

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

2. Connect frontend symptoms to backend issues

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

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

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

The post Dynatrace Release Radar 01.26 appeared first on Dynatrace news.

The next big wave in artificial intelligence is agentic AI, which harnesses autonomous agents to perform tasks by reasoning, learning, and adapting to changing circumstances. The success and efficiency of agentic AI systems depend on how well these AI agents communicate. Facilitating this communication requires monitoring AI agents and their underlying communication protocols, such as Model Context Protocol (MCP).

In this blog post, we explain how to monitor Amazon Bedrock Agents and how observability optimizes AI agents at scale.

Key takeaways

• Effective cross-agent communication requires standardized telemetry. For foundational model-building platforms like Amazon Bedrock, OpenTelemetry-based solutions provide standardization and instrumentation for tracing and logging to debug at scale.
• End-to-end observability is a key best practice for monitoring agentic AI. AI agent observability best practices include using GenAI semantic conventions with traditional logs, traces, and instrumentation.
• Observability helps deliver effective agentic AI results in the context of the whole stack. AI agent observability and Amazon Bedrock Agents monitoring help deliver better performance, ensure compliance, and provide detailed debugging tools.

Cross-agent communication requires standardized telemetry

Given the non-deterministic nature of large language models (LLMs) and dynamic cross-agent communication, organizations need standardized telemetry. OpenTelemetry-based GenAI semantic convention libraries are emerging to unify logging, metrics, and tracing in multi-agent ecosystems. Likewise, these standardized instrumentation libraries let you collect and analyze data from each step in an agent’s decision or communication chain on Dynatrace. Observability of each step lets you monitor the communications among your agents and evaluate their health and performance, regulatory compliance, and debugging.

Scale and monitor Amazon Bedrock Agents with Dynatrace

Amazon Bedrock Agents provide an easy way to build and scale generative AI applications with foundation models.

Amazon Bedrock is a fully managed service that offers a choice of high-performing foundation models from leading AI companies, such as AI21 Labs, Anthropic, Cohere, Luma, Meta, Mistral AI, poolside, and Stability AI—or from Amazon’s own model, Amazon Nova—all through a single API. In addition, Amazon Bedrock Agents also provide the broad set of capabilities teams need to build generative AI applications with security, privacy, and responsible AI best practices.

Dynatrace provides an AI-powered, unified observability and security solution for tracking and revealing the full context of used technologies and service interaction topology. Using Dynatrace for AI agent monitoring and MCP monitoring, teams can analyze security vulnerabilities and observe metrics, traces, logs, and business events in real time—automatically and securely.

“With the rise of agents, the need for deep visibility and real-time insights is more essential than ever. Through this partnership, AWS and Dynatrace are uniquely positioned to deliver performance, cost, and quality insights alongside robust compliance monitoring—empowering customers to innovate with confidence.”
– Atul Deo, Director of Amazon Bedrock

Best practices for Agent-to-Agent (A2A) and MCP monitoring

As with hybrid and cloud-based environments, context-based observability of AI agents and models is essential for efficient and healthy outcomes. Here are some best practices:

• Adopt common semantic conventions. Standardize metrics and trace attributes—for example, gen_ai.agent.operation.name and gen_ai.agent.name—across different frameworks.
• Use logs and traces for Amazon Bedrock Agents. Log critical task lifecycle events—capability discovery, artifact creation, agent collaboration steps, API calls—so teams can replay and debug complex interactions and detect hallucinations.
• Instrument thoroughly. Bake observability into agent frameworks using external OpenTelemetry libraries or by manually instrumenting calls. Ensure each agent’s start, stop, and reasoning steps, like tools, knowledge base, and guardrails, are captured consistently.
• Secure communication. Enforce enterprise-grade authentication and authorization within agent-to-agent traffic. Use well-defined protocols like A2A to avoid unauthorized data exposure.
• Continuous feedback. Feed observability insights into iterative retraining or fine-tuning for improved agent reliability.

With Amazon Bedrock and the Dynatrace AI Observability solution, you can cover the following use cases for agent observability:

Monitor AI agent service health and performance

• Detect bottlenecks by tracking real-time metrics, including request counts, durations, and error rates.
• Manage service costs with automated cost calculations for each request.
• Stay on track with service-level objectives (SLOs).

Monitor guardrails to ensure compliance

• Monitor your safeguards customized to application requirements and responsible AI policies.
• Validate toxicity, filtered content, and denied topics to ensure compliance.
• Prevent leaks of personally identifiable information (PII).
• Prevent quality degradation by validating models and usage patterns in real time.

End-to-end tracing and debugging

• Achieve complete visibility of prompt flows, from initial request to final response, for faster root cause analysis.
• Capture detailed debug data to troubleshoot issues in complex pipelines.
• Streamline workflows with granular tracing of LLM prompts, including response latency and model-level metrics.
• Resolve issues more quickly by pinpointing exact problem areas in prompts, tokens, or system integrations.

Future of AI agent observability and Amazon Bedrock Agents monitoring

We expect to see deeper integrations between agent orchestration protocols (A2A, MCP) and open observability frameworks, delivering end-to-end visibility from data ingestion to cross-agent collaboration. As standards converge, organizations will rapidly compose advanced AI solutions while retaining full transparency and control, paving the way for even greater scalability, resilience, and confidence in autonomous agents.

Read more

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

The post The rise of agentic AI part 3: Amazon Bedrock Agents monitoring and how observability optimizes AI agents at scale appeared first on Dynatrace news.

By now, everyone is aware of generative AI fueled by large language models (LLMs) and generative pre-trained transformers (GPTs). The next level of innovation is agentic AI and the autonomous AI agents that drive it. Using Model Context Protocol (MCP) to facilitate agent-to-agent communication, these systems are revolutionizing how enterprises automate tasks and orchestrate complex workflows.

Powered by LLMs, vector databases, retrieval augmented generation (RAG) pipelines and additional tools, these AI agents are expanding extensively, giving rise to multi-agent systems, cross-agent protocols, and context-sharing standards. But these autonomous agents also introduce new challenges in monitoring, debugging, and security.

We’ll examine in detail the fundamentals of AI agents, models, and the emerging standards that help them communicate, like Agent2Agent (A2A) and Model Context Protocol (MCP).

Key takeaways:

• Autonomous AI agents are the backbone of agentic AI. These services combine to deliver adaptable automated tasks.
• AI agents depend on LLMs and orchestration logic. These technologies maintain the agent’s state, session memory, context, and reasoning strategies.
• Agents depend on protocols, such as A2A and MCP, to effectively communicate. Models and agents need these protocols to manage multi-agent communication.

What is agentic AI?

Agentic AI is an artificial intelligence system made up of independent agents that can take initiative and perform sequences of actions to complete tasks by reasoning, learning, and adapting to changing circumstances.

Dynatrace Chief Technologist Alois Reitbauer described agentic AI this way:

“It’s really delegating a task to software the way you would delegate it to a human. Say if you wanted to do travel booking, give it some complexity and freedom and some decision points it can make. Like, I have to go to Vegas, I need a hotel, I need a couple of good restaurants to go to, we’re going to be 50 people, fix it with my schedule.” – Alois Reitbauer in The New Stack

Agentic AI systems rely on AI agents to perform the tasks that lead to the desired outcome.

What are AI agents?

An AI agent is a self-directed autonomous application that harnesses large language model (LLM) reasoning, tool usage, and context-awareness from numerous data sources to carry out tasks.

Agents can think and act independently without outside intervention. Agents can think through chain-of-thought, plan, execute (Reason+Act=ReAct), and refine their actions as needed. Businesses are looking into adopting these autonomous agents for applications such as customer service automation, supply-chain optimization, and content generation.

How do AI agents operate?

AI agents operate similarly to a Michelin-starred chef in a busy kitchen: They continuously gather information, plan, execute, and adjust to reach their desired end goal.

In the chef analogy, the cook surveys orders and available ingredients, decides on a suitable recipe, and then refines the approach based on feedback or resource constraints.

Agents do the same thing in a computational context. Specifically, they observe the world (for example, a user request or a set of data), perform internal reasoning about the best course of action, then carry out the steps needed to fulfill the request. This cycle allows them to respond adaptively to changing conditions, much as a chef would substitute ingredients or modify a dish mid-preparation.

Underpinning this iterative loop is the orchestration layer, which maintains the agent’s state, session memory, and reasoning strategies (such as ReAct, Chain-of-Thought, or Tree-of-Thoughts). Large language models (such as OpenAI’s GPT, Anthropic Claude, Google Gemini, Amazon Nova) provide the core reasoning capability for the agent. The model “thinks” about the user’s query. But the agent gains its power by incorporating additional frameworks or tools that can fetch external information or execute actions in the real world. One way to fetch and provide tools and information is through a unified protocol called Model Context Protocol (MCP).

Additionally, the orchestration layer ensures that multiple rounds of reasoning, tool usage, and tool outputs are all tracked and synthesized before the agent returns a final response to the user. Agents follow these steps in a structured way, so they can produce more accurate, context-rich answers and easily manage complex tasks.

What is the difference between models and agents?

A model (like a large language model) simply generates outputs based on its training data and the given prompt, typically without any built-in mechanism for session memory, external actions, or complex decision loops and validations.

An agent, on the other hand, includes the model but goes further. It maintains a stateful process (managing multi-turn conversations and thought processes), uses external tools to gather fresh data or perform actions, and follows a defined orchestration logic (such as ReAct and chain-of-thought). Thus, while a model is a core reasoning component, an agent adds the surrounding structure and capabilities needed for autonomous, goal-directed behavior.

What is Agent2Agent (A2A)? How multiple agents communicate with each other

As enterprises slowly adopt multiple specialized agents, interoperability of these services becomes crucial to create reliable experiences. To achieve this, A2A from Google helps to create an open protocol that enables agents—regardless of vendor or framework—to securely exchange information, coordinate actions, and integrate capabilities. By specifying tasks, capabilities, and artifacts in a standardized JSON-based lifecycle model, A2A fosters multi-agent collaboration across otherwise siloed systems.

A2A protocol enables agents to share updates and delegate tasks without overhead. However, direct communication between agents only solves half the problem: These agents also need relevant, up-to-date data and context to drive decisions and be equipped with the right toolset to execute actions.

Without a unified method for accessing diverse data sources, even the most capable multi-agent ecosystem remains limited in scope. The open-source project Model Context Protocol (MCP) fills this gap.

What is Model Context Protocol? How MCPs empower agents

As an open standard, the Model Context Protocol (MCP) connects AI agents to relevant data sources, such as repositories, tools, or external APIs. Instead of the above mentioned integrations for each data silo, MCP provides a universal interface like USB-C to connect multiple relevant sources to feed the right context to the models and agents. This universality simplifies how agents access relevant context, leading to better task outcomes, execution and more consistent performance across complex environments. For managing complex tasks like the ones highlighted above, the Dynatrace MCP server on GitHub helps to get real-time end-to-end observability and MCP data into your daily workflow.

What’s next: Monitoring A2A and MCP for better agentic AI

As these technologies evolve, we can expect deeper integrations between agent orchestration protocols (A2A and MCP) and open observability frameworks, delivering end-to-end visibility from data ingestion to cross-agent collaboration. Likewise, as standards converge, organizations will rapidly compose advanced AI solutions while retaining full transparency and control, paving the way for even greater scalability, resilience, and confidence in autonomous agents.

Read more

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

The post The rise of agentic AI part 1: Understanding MCP, A2A, and the future of automation appeared first on Dynatrace news.

Considering the latest State of Observability 2024 report, it’s evident that multicloud environments not only come with an explosion of data beyond humans’ ability to manage—it’s also increasingly difficult to ingest, manage, store, and sort through this amount of data. According to 85% of tech leaders, organizations also see a substantial rise in complexity caused by increased tool volume. This results in a siloed view of data, hindering team collaboration, making it more difficult to get to the root cause of a problem, and increasing inefficiencies. Teams need a better way to work together, eliminate silos and spend more time innovating.

Enhanced data collection with the Dynatrace Otel Collector

OpenTelemetry has reached broad recognition as open source standard for collecting and transmitting data, but many organizations struggle to fully leverage its capabilities. To strengthen this open standard further, Dynatrace provides a curated and supported OpenTelemetry collector. With the Dynatrace Otel Collector, teams gain a curated, validated integration framework that simplifies data collection and ensures reliability across diverse data sources from Syslog, fluentd^®, Jaeger™, Prometheus^®, StatsD, and more. You can find the list of use cases here.

Understand your applications with ease

Due to a lack of contextual insights and actionable intelligence, application teams often find themselves overwhelmed by data, unable to quickly identify the root causes of performance issues.

For Operations and SREs, the main task is to reduce downtime and service degradations—that is, to remediate issues as quickly as possible. Application teams, however, need more than surface-level data—they need actionable insights that pinpoint the root cause of issues, enabling faster and more effective problem resolution.

Visualize your application data

In complex application environments, visualizing data effectively is key to uncovering hidden performance trends and gaining actionable insight. Dynatrace provides rich visualizations, empowering application teams to interact with data more intuitively and accelerating their ability to identify and resolve issues.

Quickly achieve immediate value out of Dynatrace—new use cases and persona-driven experiences guarantee out-of-the-box value, easy onboarding, dedicated apps, and ready-made dashboards with rich visualizations. Interact with data intuitively and easily and benefit from immediate, AI-supported insights.

Trace your application

Imagine a microservices architecture with hundreds of dependencies. Without distributed tracing, pinpointing the cause of increased latency could take hours or even days. With Dynatrace, application teams can immediately see which services are experiencing delays, reducing the time to resolution and minimizing the impact on users.

Easily understand opportunities for performance optimization and troubleshooting with the new Dynatrace experience for Distributed Tracing. This experience provides visibility into complex, microservices-based architectures, allowing teams to Identify performance bottlenecks and optimize system reliability:

• Use a histogram view of response time distribution to pinpoint slowdowns
• Take advantage of direct interaction with tables for effortless grouping and filtering
• Streamline the feature flag analysis process
• Simplify testing procedures (for example, A/B testing)

Get access to intuitive troubleshooting:

• Simplified error and response time analysis with histograms covering failures and response times alongside dynamic analysis charts.
• Easy access to exception details in the context of a full trace for exception analysis

Expanded log insights for your applications

Only Dynatrace enables true and unified observability across all ingested logs, including infrastructure components and hyperscalers providing backend services or cloud-native frontend applications.

Dynatrace Grail™ data lakehouse is schema-on-read and indexless, built with scaling in mind. There is no need to think about schema and indexes, re-hydration, or hot/cold storage. This architecture also means you’re not required to determine your log data use cases beforehand or while analyzing logs within the new logs app.

The same is true when it comes to log ingestion. It doesn’t matter whether OneAgent^®, OpenTelemetry, or another method is used. Dynatrace Davis^® AI will process logs automatically, independent of the technique used for ingestion.

Speaking of log ingestion and OneAgent, one of the main differentiators compared to other market participants is the automatic detection and integration of technologies and the collection of the corresponding application or backend service logs. This empowers application teams to gain fast and relevant insights effortlessly, as Dynatrace provides logs in context, with all essential details and unique insights at speed. This eliminates the need for swapping tools or manual log correlation. In contrast, threat hunters, developers, or DevOps on the lookout for such a tool are provided the flexibility to manually analyze logs of all sources with the all-new Dynatrace Logs app. All of this without any complexity of re-hydration or re-ingestion of logs.

The benefits reaped are increased productivity and less likelihood of overlooking relevant log lines during timely investigations, as Davis AI automatically surfaces the pertinent details.

Analyze your data exploratively

Gathering further insights and answers from the treasure trove of data is conveniently achieved by accessing Dynatrace Grail with Notebooks, Davis AI, and data in context for advanced, exploratory analytics. Increase productivity and start automating your work with all related data in context.

Avoid flying blind by adopting software development lifecycle events

With the need for increased innovation frequency, having a clear view of the entire software development lifecycle (SDLC) is critical. The SDLC has similarities to the DevSecOps loop as it outlines the various phases a product idea undergoes before it’s released into production. While the lifecycle starts with a ticket specifying a new product idea, an actual code change often triggers various automated tasks kicking off the next phase. These automation tasks process the code change to build a deployable and create new artifacts accompanying the change throughout the delivery process.

Dynatrace defines the semantics of essential data points and stores them in a normalized manner. For instance, the Git commit, ticket ID, artifact version, release version, and deployment stage are data points that require special attention. With the semantics of this metadata, well-defined, stable applications, robust automation, and frictionless collaboration can be achieved.

Try out OpenTelemetry traces and log data analysis yourself

The capabilities highlighted in this blog post will be available in Dynatrace SaaS environments in the coming weeks.

Collaborating with your peers based on your software development lifecycle and all data in context has never been easier.

The post Analyze OpenTelemetry traces and log data at scale to optimize application performance appeared first on Dynatrace news.

The complexity of modern cloud-native environments is ever-increasing. The latest State of Observability 2024 report shows that 86% of interviewed technology leaders see an explosion of data beyond humans’ ability to manage it. On average, organizations have twelve different platforms and services embedded in their multicloud environments.

To avoid drowning in data, it’s critical to ensure that organizations can seamlessly collect data from any source in a single place and in context. Visualizing data in context while supporting and automating decisions with causal, predictive, and generative AI—all while providing a seamless experience—is where the future of cloud-native observability lies.

With new and updated experiences for Ops and SRE teams, proactively managing your cloud environments has never been easier.

Cloud-native observability for monitoring your cloud

OpenPipeline™ is the Dynatrace platform data-handling solution designed to seamlessly ingest and process data from any source, regardless of scale or format. With OpenPipeline, you can effortlessly collect data from Dynatrace OneAgent^®, open-source collectors such as OpenTelemetry, or other third-party tools. OpenPipeline then filters and preprocesses the data.

OpenPipeline also incorporates data contextualization technology, enriching data with metadata and linking it to other relevant data sources. By contextualizing data, OpenPipeline enhances the Dynatrace platform’s ability to offer AI-driven insights, analytics, and automation across observability, security, software lifecycle, and business domains.

Furthermore, OpenPipeline is designed to collect and process data securely and in compliance with industry standards. It features high-performance filtering, masking, routing, and encryption capabilities that are easy to configure and operate.

In the latest enhancements of Dynatrace Log Management and Analytics, Dynatrace extends coverage for

• Native Syslog support: Use Dynatrace ActiveGate to automatically add context and optimize network traffic to your Syslog messages.
• Seamless integration with AWS Data Firehose: address high-impact issues quickly through real-time, high-frequency log analytics. Dynatrace support for AWS Data Firehose includes AWS Lambda logs, Amazon Virtual Private Cloud (VPC) flow logs, Amazon S3 logs, and Amazon CloudWatch.
• Kubernetes log monitoring with Fluent Bit

In an effort to further democratize data, Dynatrace provides a curated and supported OpenTelemetry collector. The Dynatrace Otel Collector includes collector components verified by Dynatrace for seamless operation. This removes the burden of manually validating each component and use case. The list of use cases is actively extended and includes batching and ingesting data from Syslog, Fluentd^®, Jaeger™, Prometheus^®, StatsD, and more.

Understand and secure your cloud

It’s critical to have easy and intuitive access to contextually relevant answers when working within complex cloud-native environments and the gold mine of information they provide. Dynatrace is essential for unlocking that gold mine of data, allowing you to enhance application performance, deliver better experiences, and optimize operational efficiency.

Kubernetes

The Dynatrace Kubernetes experience for Site Reliability Engineers (SREs) and Platform Engineers focuses on providing insights into the health and performance of multicloud Kubernetes environments in the tailor-made Kubernetes app. Powered by Davis^® AI, the Kubernetes app offers proactive monitoring and analysis, allowing automated monitoring and optimization of health and performance and providing simple and easy troubleshooting. In addition, ready-made dashboards are available for a quick and easy overview, allowing you to see the Kubernetes data you want alongside the cloud-native observability data you need, all in one place.

Clouds

Quickly onboard and manage cloud monitoring in one place across different cloud providers and observe multiple cloud environments, including their instances, resources, cost analysis, health, and optimization. Ingest data remotely through cloud integrations covering Amazon CloudWatch, Azure Monitor, Azure Liftr, and Google Cloud™ Kubernetes with GKE™ AutoPilot cluster.

Vulnerabilities

Prioritize and sort vulnerabilities based on Davis Security Score, detection time, or the number of affected entities. Quickly identify if public exploits, internet exposure, or reachable data assets are exposed. Get powerful insights into the true impact of vulnerabilities in your environment. The embedded Davis Security Advisor can help you enhance remediation for third-party vulnerabilities with AI-assisted and precise recommendations on remediation actions, allowing you to address several critical vulnerabilities simultaneously. Davis AI uses security intelligence and runtime context to determine risk and remediation based on criteria like internet exposure and access to sensitive data.

Service-Level Objectives

Measuring a system’s reliability can be complex and overwhelming. Indicators that provide insights into the environment’s health and performance vary across industries, products, and applications. Applying Service Level Objectives (SLO) to track these indicators is a common best practice within site reliability engineering. Still, an SLO’s quality lies in the significance of the underlying service-level indicator.

Dynatrace guides you in quickly setting up the most valuable SLOs—considering the typically used metrics but providing the freedom to use any data stored in Dynatrace Grail™ data lakehouse, such as logs and events.

It doesn’t matter if you need the typically used failure rate or response-time metrics to ensure your system’s availability and performance or if you need to rely on abnormal log drops to gain insights into raising problems—SLOs leveraged with Grail provide all the information you need.

Automate your cloud

Answer-driven Dynatrace Automation is further extended by providing direct interaction with your cloud and cloud-native ecosystem:

• Kubernetes: Read manifests, free up resources (for example, delete failed terminations), and restart deployments.
• AWS: Automate your AWS infrastructure with actions across EC2, S3, Lambda, and more.
• GitHub^®: Integrate with your GitHub repositories. Automate issues and pull requests (for example, to change configuration files for sizing).
• GitLab™: Integrate with your GitLab projects. Automate issues and merge requests (for example, to change configuration files for sizing).

Example: Predictive auto-scaling for Kubernetes workloads

Kubernetes provides flexibility but also introduces complexity. For instance, manual scaling is time-consuming, reactive, and prone to errors. Using Dynatrace Automation and Davis AI helps you predict bottlenecks and automatically open pull requests to scale applications. This proactive, automated approach minimizes downtime, ensures your applications perform at their best, and helps optimize resource utilization and cost.

The Auto-Scaling tutorial provides a step-by-step guide to automatically scaling Kubernetes workloads up or down, horizontally or vertically.

Try out cloud-native observability yourself

Proactively manage your environments to increase performance and reduce cost. It’s never been easier to truly own your cloud!

The capabilities highlighted in this blog post will be available in Dynatrace SaaS environments in the coming weeks.

The post Cloud-native observability made seamless with OpenPipeline and AI-driven observability appeared first on Dynatrace news.

Cloud environments—including multicloud, hybrid, and cloud-native ecosystems—offer unmatched agility, scalability, and cost-effectiveness, though they also present new challenges and complexities that are impossible to manage manually. As cloud environments become increasingly ubiquitous, so does the need for effective and efficient management.

Dynatrace integrates observability and security monitoring while leveraging causal AI to deliver answers and intelligent automation from data at an enormous scale. The Dynatrace platform provides real-time situational awareness of your cloud ecosystem to give you the confidence that your organization is operating as it should. With answer-driven automation powered by the new Dynatrace AutomationEngine, we’re releasing a solution that further extends our platform, putting answers into action, and empowering organizations to overcome cloud management challenges and unlock the full potential of their cloud strategy while reducing manual effort.

Context is king

Many modern enterprises suffer because their top technical talent is consumed with manual toil. According to the Global CIO Report 2022, 71% of CIOs say the explosion of data produced by cloud-native technology stacks is beyond human abilities to manage manually. Building effective and reliable systems is only possible with automation, which, in the past, proved difficult due to the following issues:

• Complexity of systems: The complexity of modern systems makes it difficult to gather all the necessary information to automate decision-making.
• Lack of standardization: The lack of standardization across tools and technologies makes it difficult to handle automation decisions and actions across different systems.
• Lack of data: In many cases, available data may not be enough to make informed decisions due to data silos, distribution, or negligence.
• Incorrect action on unreliable data: Automation systems without context-rich observability and security data often fail in pinpointing the best remediation actions to take, resulting in unwanted or incorrect reactions, as well as false-positive and false-negative alerts.
• Evolving threats: New security threats and vulnerabilities are constantly emerging. This makes it difficult for pure rule-based automation systems to adapt to new threats and vulnerabilities in real time.
• Primitive safety nets: Having no real-time automation feedback loop results in additional toil and escalation actions.

With the introduction of AutomationEngine, the Dynatrace platform has overcome these automation challenges

Dynatrace enables full observability by supporting open-source tools, as well as Dynatrace OneAgent and other data-ingest methods in enriching the classic observability pillars of metrics, traces, and logs with topology, user behavior, security, metadata, and network data. Dynatrace Davis® AI integrates all this context-rich data to provide answers within complex, multi-level systems and environments.

Extending the platform with Dynatrace AutomationEngine unlocks the power to combine observability, security, and business data with causal AI to easily automate BizDevSecOps workflows at enterprise scale.

Automate what matters

Extending the Dynatrace platform natively with AutomationEngine leads to causal-AI-powered, answer-driven automation. This helps organizations to achieve proactive prevention, efficient operation, faster remediation, strong protection, and business acceleration. Use cases include but are not limited to:

• Targeted notification and collaboration: connect the right teams and equip them with answers in real-time
• Closed-loop remediation: automatically remediate problems and vulnerabilities
• Quality and security gating: block vulnerabilities and regressions before they reach production
• Continuous vulnerability assessment: detect zero-day vulnerabilities
• Predictive automation: take maintenance measures before risking a potential failure
• Progressive delivery orchestration: orchestrate releases based on user and system feedback
• Intelligent infrastructure and application orchestration: auto-scale and resize smarter load distributions
• Preventive security configurations: block malicious IPs based on known attack patterns

Dynatrace Workflows, powered by AutomationEngine, puts automation use cases at your fingertips. Every automated workflow consists of easy configuration, extensive trigger options, out-of-the-box actions and integrations, and unprecedented extensibility by leveraging webhooks, JavaScript code, and application actions powered by AppEngine.

Easy workflow creation and maintenance

Workflow creation and maintenance at scale

Another way to ensure always up-to-date workflows and automation at scale, teams can use the automation-as-code approach available with Dynatrace’ own configuration as code solution named Monaco. By shifting your automation configuration left, Monaco moves automation definition closer to not only your source code, but also your testing, observability, security, and remediation capabilities. Automation-as-code allows for powerful and concise automation across the full software development lifecycle. Another big advantage of automation-as-code is the scale at which automation is enabled. By following a programmatical approach, developers, DevOps and SREs benefit from a single source of truth and streamlined collaboration. This helps to eliminate outdated manual runbooks, which are inevitably fail.

Proactive automation

You can configure a variety of event triggers  to initiate custom workflows based on your needs:

• On-demand trigger: manual execution of an otherwise tedious chain of tasks, for example, audit automation
• API-based trigger: direct calls embedded into existing toolchains, for example, pipeline integration
• Schedule-based trigger: scheduled execution of recurring tasks, for example, reporting
• Problem, security, or Davis event-based trigger: Davis causal-AI triggered actions that reduce mean time to repair (MTTR), for example, problem remediation
• Dynatrace Query Language (DQL) event-filter trigger: results of event filters applied to the observability, security, and business data in Dynatrace to trigger actions based on certain event types, for example, deployments of a specific service

Boundless automation

Every workflow consists of several tasks that can be executed or skipped based on the conditions of previous tasks, retried based on error logic, or looped to iterate over lists. To enable this, workflows are aware of variables and context and can execute DQL queries in real-time. Besides executing actions within the Dynatrace platform itself, Dynatrace AutomationEngine allows the safe triggering of actions to both cloud services and—by leveraging Dynatrace EdgeConnect—on-premises services. Dynatrace provides an ever-growing ecosystem of deep, out-of-the-box, third-party integrations that connect automation with collaboration, ITSM, AIOps, DevOps, and security tools.

For truly limitless automation capabilities, Dynatrace Workflows can issue HTTP requests to any API and execute custom Javascript code. By leveraging Dynatrace AppEngine, any application can publish universally-available actions for all workflows, thereby extending custom logic to automated workflows. This automation context, embedded into every app, unlocks even more automation use cases.

Dynatrace AutomationEngine leverages platform-wide event triggers and timezone-aware schedules with dynamic recurrence rules. It allows custom flow logic and parallel task execution with automatic retry, and can be configured-as-code, all to accommodate the complexities of global enterprises.

What’s next?

Interested and want to learn more? The new Dynatrace user experience, including the newly developed AutomationEngine, will be available within 90 days. In the meantime, watch out for upcoming Dynatrace Observability Clinics and live “Ask me anything” sessions covering the main topics of this blog post. You can see a list of the next webinars on our website or follow us on LinkedIn to stay up-to-date with upcoming announcements and activities.

The AutomationEngine actions and integrations ecosystem are being continuously developed and extended. If you’re looking for a certain third-party integration for automation that is currently missing, let us know by posting to the Dynatrace Community.

The post AutomationEngine tames cloud complexity with answer-driven automation appeared first on Dynatrace news.

While development teams focus on innovation and quick release cycles, operations teams and Site Reliability Engineers (SREs) focus on stability. Of course, your customers expect both fast innovation and reliability.

Dynatrace Cloud Automation lets you track your most critical SLO). Further, it enables you to release with confidence by catching poor quality code before it reaches production. Now, we’re happy to extend our Cloud Automation offering with automated problem remediation.

The costs of downtime

Surveys suggest that a single hour of downtime can cost an organization from $1 million to over $5 million. For Fortune 1,000 companies, the average costs of unplanned application downtime per year are $1.25 billion to $2.5 billion.

Beyond extensive financial costs, broken SLOs lead to customer dissatisfaction, and customers might look elsewhere for similar services. A tarnished brand reputation might discourage prospects from trying your services, slow down your customer growth, and even hinder your talent recruiting.

Root cause-based automated problem remediation

What are the requirements for rapid problem remediation that prevents downtime? When looking at reports such as the DevOps Automation report 2021, it becomes clear that the most significant challenges during remediation are manual toil (lack of automation) as well as challenges related to communication, for example, reaching the right people, using the right runbooks, and ensuring that decisions are based on reliable data.

Dynatrace Davis AI detects problems, underlying root causes, business impact, and SLO impact across your full-stack production deployments. Dynatrace Cloud Automation uses this information to trigger and execute remediation actions and observability-based validations.

Based on data insights and customer research, we’ve identified the top five use cases for automated problem remediation:

• Feature flag settings—Observe application and service behaviors, identify error-causing feature flags, and switch them accordingly to guarantee stable environments.
• Process restarts (for example, JVM memory leaks)—Trigger a service restart or related actions for applications with underlying bug fixes that have been deprioritized or delayed.
• Kubernetes resource adoption—Act on external, holistic, and customer-centric behavior observations—rather than on only internal parameters—and automatically roll out Custom Resource Definitions (CRDs) to designated environments.
• Deployment and rollback—Trigger predefined rollback or roll-forward actions when a faulty deployment violates SLOs or decreases your error budget above the target.
• Targeted notifications—Based on the auto-detected details of underlying root causes, keep your business and technical users, SREs, and Operations team updated regarding ongoing remediation actions and escalate if the situation requires higher visibility.

Take out the guesswork

Let’s look at an example scenario where automated problem remediation is applied. Consider that Davis AI has detected that turning on a particular feature flag leads to a failure rate increase and raises a problem. While this information is used to alert Operations or SREs, Dynatrace now allows you to link root causes to freely configurable runbooks. In this scenario, the runbook can turn off the failure-rate-increasing feature flag while checking the system’s health to see if the remediation action fixed the problem. Once the problem is fixed, Dynatrace Davis AI closes the problem. Otherwise, the next escalation level of the runbook is executed, for example, sending a notification to a human operator.

What’s next

This blog post is the first in a series of publications centered around different problem remediation use cases and exemplary toolchain integrations. Check out further information in our SLO documentation.

Stay tuned for the next blog post in this series to learn how to extend problem remediation beyond the feature flag mechanism and level up your software delivery by integrating Cloud Automation into your existing DevOps toolchain. Then you can orchestrate the software development lifecycle and remediate issues automatically. Reach out to us today for a demo.

The post Level up your production resiliency with automated problem remediation appeared first on Dynatrace news.