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 is the second post in our series on LLM evaluations. In the companion post, Evaluate LLM and agent quality in Dynatrace AI Observability with dt-evals, we showed you how to run online evaluations against real GenAI prompt traces and bring quality scores into Dynatrace AI Observability alongside latency, cost, and errors. This post steps back to the fundamentals: what evaluations are, how they work, and the methods teams use to measure AI quality.

Just as traditional software relies on testing frameworks to ensure reliability, AI systems require robust evaluation frameworks to measure the quality, accuracy, and safety of model outputs. Evals are the primary mechanism by which teams build trust in, iterate on, and responsibly deploy AI systems. Without them, organizations may risk deploying systems that produce unreliable answers, hallucinate facts, or quietly degrade in performance over time.

Key takeaways

• Evaluations are how teams move from “the LLM feels right” to “we can prove the LLM works.”
• There is no single best evaluation method. The right approach depends on what you’re measuring and why.
• LLM-as-a-Judge is one powerful tool within the broader evaluation ecosystem, not synonymous with evals as a whole.
• Online and offline evaluations serve complementary roles: offline for development, online for production monitoring.
• A mature evaluation strategy combines code-based, model-based, and human-based methods.
• Evals should be treated as living artifacts — maintained, versioned, and improved over time like any other engineering asset.

Why LLM evaluation is fundamentally different from traditional testing

Traditional software produces deterministic outputs — the same input consistently returns the same result, making pass/fail testing straightforward. LLMs are probabilistic systems: the same prompt can produce different responses depending on context, temperature, and model behavior. This variability makes conventional testing methods insufficient.

Instead of verifying a single correct output, teams must evaluate across multiple dimensions simultaneously:

• Correctness— does the response answer the question accurately?
• Relevance — is the output aligned with the user’s intent?
• Faithfulness — is the response grounded in source data, not invented?
• Safety and bias — does the output comply with organizational policies?

This transforms evaluation from simple pass/fail checks into continuous measurement of AI quality.

The hallucination problem

The most well-known consequence of probabilistic generation is hallucination — when a model produces plausible-sounding but factually incorrect information. This happens because LLMs predict likely word sequences rather than verify facts, which enables powerful reasoning but introduces serious risk in enterprise environments where accuracy is critical.

Addressing this requires evaluation frameworks that track signals like factual accuracy, semantic similarity, groundedness in source data, and consistency across responses. These metrics transform subjective quality judgments into measurable, improvable signals.

What is an LLM evaluation?

An LLM evaluation is a systematic process of testing a model or AI-powered system to determine whether it meets a defined standard of quality. That standard could be factual accuracy, helpfulness, safety, tone, latency, cost-efficiency, or any other measurable dimension that matters to the application.

Evaluations translate vague product goals (“the assistant should be helpful and safe”) into concrete, repeatable measurements. They allow teams to:

• Catch regressions when a model is updated, or a prompt is changed.
• Compare candidates — different models, prompt versions, or retrieval strategies — objectively.
• Build accountability by producing evidence that a system behaves as intended.
• Accelerate iteration by giving developers fast, structured feedback loops.

Evals exist on a spectrum of formality, from a small hand-curated test set run locally, to a large, automated pipeline running thousands of test cases in CI/CD on every deployment.

How do LLM evaluations operate?

At their core, evaluations follow a consistent pattern regardless of their complexity:

1. Define the task and success criteria. What should the LLM model do, and how will you know when it does it correctly? This is the hardest and most important step.
2. Assemble a dataset. A set of inputs (prompts, user messages, documents) paired with expected outputs or grading rubrics. Datasets can be human-curated, synthetically generated, or sampled from production traffic.
3. Run inference. Pass the inputs through the system under test and collect outputs.
4. Score the outputs. Apply a scoring method — a function, a model, or a human — to assess how well each output meets the success criteria.
5. Aggregate and analyze. Roll up scores into metrics (accuracy, pass rate, average score), visualize distributions, and compare against baselines or previous runs.
6. Act on results. Use the findings to accept or reject a change, file a bug, update a prompt, or trigger retraining.

This loop can run manually during development, automatically in CI/CD pipelines, or continuously against live production traffic.

What’s the difference between LLM evaluations and LLM-as-a-Judge?

This is one of the most common points of confusion in the space.

LLM evaluations are the broader discipline — the full process described above. They encompass everything from how you define success to how you collect test data to how you score outputs to how you act on results.

LLM-as-a-Judge is one specific scoring method that can be used within an evaluation pipeline. It involves using a language model (often a strong general-purpose model like GPT-5 or Claude Sonnet 4.6) to automatically assess the quality of another model’s outputs.

Think of it this way: evaluations are the framework, and LLM-as-a-Judge is one type of grader you can plug into that framework — alongside code-based graders, human graders, or embedding-based similarity checks.

• LLM-as-a-judge handles open-ended, subjective dimensions (tone, creativity, helpfulness) that are hard to capture in code.
• It scales to large datasets without human effort.
• It can be surprisingly well-calibrated when prompts and rubrics are carefully designed.

Limitations

• Inherent biases of the LLM model used to judge (verbosity bias, position bias, self-preference).
• Requires prompt engineering and validation to ensure the judge is grading what you intend.
• Adds cost and latency to the evaluation pipeline.
• Not appropriate for tasks with clear ground-truth answers where code-based checks suffice.

Code-based evaluations

Code-based evaluations use deterministic functions — written in Python or any language — to score model outputs. No secondary LLM model is involved.

How it works

You write a function that takes the model output as input and returns a score. The function might check for exact string matches, run regex patterns, execute generated code and test it, parse JSON and validate its structure, call an external API to verify a fact, or compare numerical results.

Common patterns

• Exact match — does the output equal the expected answer?
• Contains / regex match — does the output include a required phrase or follow a required format?
• Execution-based — for code generation tasks, run the output and check whether tests pass.
• Structured output validation — parse JSON/XML outputs and verify schema and values.
• Tool call verification — for agentic tasks, did the model call the right tool with the right parameters?

Strengths

• Fully deterministic and reproducible.
• Fast and cheap to run at scale.
• Easy to understand, debug, and audit.
• No dependence on a secondary model’s judgment.

Limitations

• Cannot handle open-ended or subjective quality dimensions.
• Requires knowing the exact expected output or a verifiable property of the output.
• Brittle for tasks where there are many valid correct outputs (for example, summarization, creative writing).

Code-based LLM evals are the first tool to reach for whenever a task has a clear, verifiable answer. They form the backbone of any reliable eval suite.

Online vs. offline evaluations

These two modes are not competing approaches — they’re complementary phases of a complete evaluation strategy.

Offline evaluations

Offline evals run against a static, pre-collected dataset before a system reaches production. They’re the evaluation equivalent of unit and integration tests in software development.

• When: During development, before deploying a new model, prompt, or retrieval change.
• Dataset: Curated, labeled, or synthetically generated. Often maintained in version control.
• Latency: Can run in batch; speed is less critical.
• Use cases: Regression testing, model comparison, prompt optimization, safety red-teaming, fine-tune evaluation.

Key advantage: Full control over the test distribution and ground-truth labels.

Key limitation: The dataset may not reflect real user behavior or the long tail of production inputs.

Online Evaluations

Online evals run against live production traffic in real time or near real time. They observe what is actually happening when real users interact with the system.

• When: Continuously, in production.
• Dataset: Real user inputs — unlabeled, unpredictable, and representative.
• Latency: Must be fast or asynchronous to avoid slowing down user-facing requests.
• Use cases: Production monitoring, anomaly detection, drift detection, A/B testing, continuous quality assurance.

Key advantage: Captures real-world usage patterns, prompts, and failure modes from production traffic, giving teams the most representative signal for monitoring AI quality over time.

Key limitation: No pre-defined labels; scoring must rely on heuristics, implicit signals (thumbs up/down, re-prompts), or async LLM-as-a-Judge pipelines.

Get started with LLM evaluations today

The field of LLM evals is evolving rapidly. As enterprises deploy increasingly autonomous AI systems, evaluation can play an important role in improving AI accuracy, reliability, and safety.

Here are the trends worth watching and investing in:

1. Evaluation-driven development. Treat evals as a first-class engineering artifact. Write eval cases before building features, maintain them in version control, and integrate them into CI/CD pipelines — mirroring test-driven development practices from software engineering.
2. Agentic and multi-step evaluation. As AI systems move from single-turn Q&A to multi-step agents that use tools and maintain state, evaluations must evolve to assess full trajectories rather than just individual outputs. This includes evaluating tool use, planning quality, error recovery, and task completion over long horizons.
3. Adversarial and safety evals. Red-teaming — probing a system for failures, biases, and unsafe behaviors — is becoming a standard part of the eval lifecycle, especially as regulatory requirements around AI safety mature.
4. Human-in-the-loop calibration. Even automated eval pipelines benefit from periodic human review to catch drift in what the judge model or scoring function is measuring. Building lightweight human-annotation workflows alongside automated evaluations yields a more reliable signal over time.
5. Standardization and benchmarking. The industry is moving toward shared benchmarks and eval frameworks (for example, HELM, MMLU, LMSYS Chatbot Arena, OpenAI Evals) that allow apples-to-apples comparisons across models. Building internal evals that complement these public benchmarks will be an increasingly important capability for any team deploying LLMs.
6. Cost-aware evaluation. As evals scale, cost becomes a real constraint. Emerging approaches include training lightweight specialized judge models, using embedding-based similarity as a cheap first filter, and intelligently sampling which examples need expensive LLM-as-a-Judge scoring.

Organizations that invest early in robust evaluation frameworks and combine them with AI observability will be positioned to scale AI safely across their operations.

Ready to put this into practice?

See our companion blog post, Evaluate LLM and agent quality in Dynatrace AI Observability with dt-evals, to learn how dt-evals lets you run LLM-as-a-judge evaluations on real GenAI traces and turn AI quality into a queryable, trendable, and alertable signal inside Dynatrace AI Observability.

Because in the end, AI systems are only as trustworthy as the processes used to evaluate them.

The post Beyond LLM-as-a-judge: Establishing LLM evaluations as a foundation for trustworthy agentic AI systems appeared first on Dynatrace news.

For AI systems, reliability is defined by response quality, factual grounding, data security, and usability — and those signals need to live alongside the same observability data teams already trust to monitor performance and availability.

When evaluation scores are isolated in notebooks, spreadsheets, standalone tools, or CI logs, they’re hard to operationalize. By bringing AI quality metrics into Dynatrace AI Observability—next to latency, cost, errors, traces, and user behavior—teams can connect poor responses and hallucinations directly to the prompts, models, retrieval contexts, tool calls, services, and traces that produced them.

What is dt-evals?

dt-evals is an open source CLI for evaluating LLM and agent quality from real GenAI traces, agentic interactions. Teams can run online evaluations against live or recent interactions, score outputs with an LLM judge, and send structured results back to Dynatrace AI Observability so quality becomes visible, queryable, trendable, and actionable.

A minor prompt edit, model change, or retrieval update to an AI application can improve one behavior while quietly breaking another. The challenge to tracking down where and why these systems break is that evaluation results are often maintained outside the operational workflow, making it difficult to connect a low score to the exact trace, prompt, model version, retrieval context, tool call, or service that produced the unwanted behavior.

Dynatrace AI Observability closes this loop. With dt-evals and the AI Observability Evaluation Preview teams can pull recent gen_ai.*  spans, score real interactions with an LLM judge, and write structured evaluation results back as business events. These scores can be viewed with the originating trace, queried for custom analysis, trended in dashboards, and used to trigger alerts or workflow-driven remediation.

A failing faithfulness score is no longer just a number in a report. It’s now an operational signal.

What are LLM evaluations?

An LLM evaluation system scores an AI response against a range of quality and safety dimensions. Common examples include whether the answer is relevant to the question, faithful to the provided context, free of hallucinations, safe for users, complete enough to be useful, and resistant to prompt-injection attempts.

LLM evaluations are typically applied in two modes:

Offline evaluations run before release against a fixed test set or curated trace dataset. These are used to compare a proposed prompt, model, retriever, or agent-tool change against a known baseline before shipping. For example, replay 500 representative support questions in CI and block the release if faithfulness drops below the configured threshold.

Online evaluations run after deployment against sampled production or user traffic. Use online evaluations to detect regressions caused by live inputs, changing retrieval results, tool behavior, traffic mix, or model drift. For example, evaluate 10% of support-agent traces from the last hour and alert the team if hallucination failures exceed the configured window.

With dt-evals, you can run evaluations from the command line, use them in CI/CD, or schedule them to detect quality regressions autonomously after deployment as a post-processing quality gate for your AI agents and LLM output.

Run evaluations from the command line

dt-evals is an open source evaluation toolkit for teams that want to bring their own data, judge provider, and evaluation logic while keeping traces, scores, dashboards, and alerts connected.

Install the CLI:

npm install -g @dynatrace-oss/dt-evals

Or run it directly with npx:

npx @dynatrace-oss/dt-evals <command>

A typical first run has three steps:

1. Configure your environment and judge provider (Bring Your Own AI API key):

dt-evals configure

2. Verify your local setup and connection:

dt-evals doctor

3. Run evaluations on recent GenAI traces:

dt-evals run --since 1h --sample 10

This command evaluates traces from the last hour and samples 10% of them. In other words, dt-evals evaluates roughly one out of every ten matching traces, including the prompt and completion messages associated with each selected trace.

During configuration, you provide the connection to your Dynatrace environment and the credentials for the LLM judge provider you want to use. dt-evals does not require teams to send evaluations through a fixed provider. You bring your own judge credentials and control where evaluation execution happens.

For CI/CD use cases, run in CI mode:

dt-evals run --since 6h –ci

In CI mode, dt-evals emits machine-readable output and can fail the pipeline when a configured threshold is breached. This makes quality checks part of the same delivery process used for prompt changes, model upgrades, retrieval updates, and agent releases.

Bring your own LLM judge provider

The “LLM-as-judge” evaluation approach involves using an AI model to score another model or agent response. The LLM judge needs to come from an AI provider your team trusts and has approved for the type of data being evaluated.

dt-evals supports common LLM judge AI models and inference providers, including OpenAI, Anthropic, Google/Vertex/Gemini, AWS Bedrock, and Azure OpenAI. Depending on the package and configuration path you use. Teams provide their own credentials, choose the judge model, and can tune execution settings such as thresholds and concurrency.

This matters for both governance and cost control. Teams can decide which LLM provider is assigned to evaluate which traffic, how many judge calls run in parallel, and where evaluation results are stored.

Which quality and safety dimensions are evaluated by dt-evals?

dt-evals supports built-in LLM-as-Judge evaluators for a range of quality and safety dimensions, including:

• Relevance: Does the response answer the user’s question?
• Faithfulness: Is the response supported by the provided context?
• Hallucination: Does the response invent facts that are not present in the available context?
• Answer completeness: Does the response fully address the user’s request?
• Context relevance: Is the retrieved or supplied context useful for answering the question?
• Factual accuracy: Does the response match an expected or known-correct answer?
• Summarization quality: Does the summary preserve the important information?
• Conciseness: Is the response direct with no unnecessary detail?
• Fluency: Is the response clear and readable?
• Toxicity: Does the response contain harmful or abusive content?
• Bias: Does the response show unfair or inappropriate bias?
• PII leakage: Does the response expose sensitive personal information?
• Prompt injection: Did the input or response show signs of instruction manipulation?
• User frustration: Does the interaction suggest the user is blocked or dissatisfied?
• Drift: Are scores changing meaningfully compared with prior behavior?

A Retrieval Augmented Generation (RAG) application might focus on faithfulness, hallucination, context relevance, and answer completeness. A customer-facing support agent might focus on relevance, fluency, bias, toxicity, and prompt-injection risk. An internal assistant might add custom checks for tone, policy compliance, or whether the answer includes required next steps.

Add custom evaluations

Built-in metrics are useful, but most production AI systems also need checks that are specific to the business, domain, or workflow.

Custom evaluations let teams define their own judge prompts, scoring rules, labels, and thresholds. For example, a support team can create a custom evaluator that checks whether an answer includes a required troubleshooting step before recommending escalation. A financial services team can check whether responses include the required disclaimers. A platform team can check whether an agent uses the correct tool before answering.

The critical point is that custom evaluators run through the same pipeline as built-in evaluators. They can produce the same structured results, appear alongside other scores, and be used in dashboards, alerts, and release checks.

A typical configuration defines the target service, judge provider, sampling strategy, enabled metrics, and thresholds:

schemaVersion: 1
name: support-agent-prod

dynatrace:
  environmentUrl: https://your-env.apps.dynatrace.com
  platformToken: dt0s16.xxxxx

judge:
  provider: openai
  model: gpt-5.5

scope:
  service: support-agent
  since: 1h
  sampling:
    strategy: random
    percent: 10

metrics:
  enabled:
    - faithfulness
    - hallucination
    - relevance
    - drift

alerts:
  thresholds:
    faithfulness: 0.7
    relevance: 0.7

Evaluation results in the AI Observability app

Evaluation results appear directly in the AI Observability app, so teams don’t have to jump between a trace view, an eval report, and a separate dashboard to understand what happened.

In the Prompts view, teams can filter for prompts with evaluation scores and inspect row-level verdicts. Score badges such as relevance, fluency, bias, faithfulness, or toxicity make response quality easy to scan without opening every trace.

This is useful when triaging a regression. Instead of starting with a generic failure count, teams can quickly see which prompts failed, which evaluator failed them, and whether the issue is isolated or widespread.

From an individual prompt or trace, the Evaluations tab shows run-level details, including the evaluation name, score, provider, judge model, method, and supporting metadata.

That detail matters because a failed score is only useful if teams can explain it. Engineers and evaluation owners can move from a low score to the exact prompt, response, trace, model, evaluator, and rationale that produced it.

Query, trend, and alert on evaluation scores

Because dt-evals writes results back as structured events, evaluation scores can be analyzed with the rest of your telemetry.

Teams can ask questions such as:

• Which evaluator has the lowest average score?
• Which services are producing the most failed evaluations?
• Did quality drop after a model or prompt change?
• Are hallucinations increasing over time?
• Is quality improving at the cost of latency or token usage?

For example, to get average score by evaluator you could write this query:

fetch bizevents
| filter event.type == "gen_ai.evaluation.result"
| summarize avg_score = avg(gen_ai.evaluation.score.value),
    by: { gen_ai.evaluation.name }
| sort avg_score asc 

Failed evaluations by service and metric can be determined with this query:

fetch bizevents
| filter event.type == "gen_ai.evaluation.result"
| filter gen_ai.evaluation.score.label == "fail"
| summarize failures = count(),
    by: { dt.service.name, gen_ai.evaluation.name }
| sort failures desc 

Trending is where evaluation data becomes more useful than a point-in-time report. A single failed score can show an issue. A trend can show whether quality is drifting slowly, whether a release caused a sudden drop, or whether a fix actually improved behavior over time.

On the AI Evaluation & LLM App Performance dashboard, teams can track trends in quality score, pass rate, failed evaluations, drift detections, evaluator health, run cadence, and pass/fail volume over time.

How to turn quality regressions into alerts

Evaluation results can also drive alerts. For example, a support agent team may want to notify the AI team when hallucinations appear in production, or when faithfulness drops for more than a few minutes.

name: support-agent-prod

alerts:
  notifications:
    - name: hallucination-detected
      metric: hallucination
      condition: count > 0
      window: 5m
      channel:
        type: slack
        connection: ai-observability-slack
        channel: "#ai-alerts"

    - name: faithfulness-regression
      metric: faithfulness
      condition: fail_rate > 10%
      window: 15m
      channel:
        type: email
        connection: ai-team-email
        to: [ai-team@example.com] 

Deploy the alerts with:

dt-evals alerts list ./support-agent-prod.yaml
dt-evals alerts apply ./support-agent-prod.yaml

Once applied, Dynatrace runs these checks continuously as Workflows. If hallucinations appear in the last five minutes, the team gets a Slack alert. If more than 10% of faithfulness checks fail over 15 minutes, the AI team receives an email. This turns LLM quality from something teams inspect manually into something Dynatrace can monitor and route automatically.

For continuous alerting, evaluation runs need to happen continuously or on a schedule. You can run dt-evals in CI for release checks (see our example here), run it manually during investigation, or deploy a scheduled runner for ongoing production evaluation. An alert is only as fresh as the evaluation results it carries.

Once configured, quality signals can be routed to the teams that need to act. If hallucinations appear in the last five minutes, the team can receive a Slack alert. If more than 10% of faithfulness checks fail over 15 minutes, the AI team can receive an email. This turns LLM quality from something teams inspect manually into something they can monitor and route automatically.

Close the loop in the AI software delivery lifecycle

Evaluation gates are most useful when they meet developers where they already work. Because dt-evals writes evaluation results back into the observability data layer, those results are not limited to dashboards or post-release reviews. They can be queried, inspected, and acted on from development workflows, CI/CD pipelines, and agentic coding environments.

For example, a team can run dt-evals after any change to a prompt, model, retriever, or agent tool, and then use dtctl (Dynatrace CLI tool for AI Agents) to query the resulting evaluation data, inspect related traces, review dashboards, or validate whether a release threshold was met. In an AI-assisted workflow, tools such as Claude Code, Cursor, GitHub Copilot, or an internal agent harness can leverage MCP or CLI access to bring that same observability context into the developer’s daily workflow.

That closes the loop of the AI software delivery lifecycle: teams can evaluate behavior, control rollout decisions, remediate regressions, and feed production learning back into the next development cycle. Quality signals are no longer in a separate report; they’ve become a part of how AI software is built, shipped, and operated.

Bring evaluations into the release process

Evaluation support is not just for inspection after something breaks. It can also help prevent regressions before they reach users.

This makes AI quality part of the release process. Teams can gate changes based on relevance, faithfulness, hallucination risk, prompt-injection risk, toxicity, or custom metrics, rather than relying solely on latency and error rate.

What makes this meaningful is that it’s the same pipeline teams already run. AI quality gates sit alongside the latency, error rate, and SLO gates teams have been using for years. There’s no second CI system, no second platform to learn, no second dashboard to monitor. Quality becomes one more dimension of the release decision, gated the same way performance is gated, by the same platform, in the same pipeline.

Coming next

The current experience makes evaluation results visible and actionable inside Dynatrace AI Observability. Next, the focus is on making evaluation workflows easier to run at scale and easier to compare across changes.

Planned improvements include targeted and bulk trace evaluations, custom evaluation libraries, evaluator versioning and lineage, baseline comparisons, experiment views, native quality gates, and deeper visibility into online evaluations.

These capabilities will help teams compare prompt and model variants, understand quality versus cost and latency tradeoffs, and detect sustained quality regressions before they affect more users.

Start today

To get started, check out the Git repository. You’ll need:

• Node.js 20 or later
• A Dynatrace environment with GenAI spans and the AI Observability app installed

• Credentials for the judge provider you want to use
• A service, trace sample, or CI workflow you want to evaluate

Then, install the CLI:

npm install -g @dynatrace-oss/dt-evals

Configure your service and judge provider:

dt-evals configure

Run your first evaluation:

dt-evals run --since 1h --sample 10

With Dynatrace AI Observability and dt-evals, teams can bring LLM and agent evaluations into the operational loop, where they can trace behavior, score outputs, trend results, alert on regressions, and gate releases before silent failures reach production.

The post Evaluate LLM and agent quality in Dynatrace AI Observability with dt-evals appeared first on Dynatrace news.

As more agentic AI projects come online, the observability market is abuzz with familiar promises: tool consolidation, AI-powered insights, and faster remediation through smarter tools. On the surface, this sounds like progress. But beneath the excitement, many discussions are framed around the wrong question.

The real issue isn’t about how to adopt autonomous operations; it’s about ensuring AI agents are operating reliably and resolving problems without introducing new ones. When evaluating new observability solutions, the question should be:

Can this observability solution accurately analyze complex, dynamic telemetry in context so AI agents can act autonomously with trust, precision, and reliability?

As systems become increasingly agent driven, observability is crossing a structural boundary. Approaches designed for environments where only humans decide and act must adapt to a world where agents increasingly operate autonomously with human oversight, while keeping organizations informed.

Rethinking observability for the agentic age

Observability platforms were initially intended to support engineers in delivering reliable applications, services, and infrastructure to users, and alert them in the event of a problem. Dashboards, alerts, and correlation helped teams investigate incidents, piece together what happened, diagnose issues, decide on next steps, and resolve the problem. This model worked when changes were pushed manually.

The assumption was that more data, better correlation, and cleaner interfaces will lead to increased visibility and improved operational decision making.

Agentic AI systems break that assumption.

With faster release cycles and AI-generated code, manual investigations can no longer keep pace. Moreover, observability platforms must now provide actionable insights to both humans and AI agents.

As agents begin operating as autonomous participants in software environments by triggering mitigations, scaling infrastructure, and optimizing behavior in real time, observability can no longer function solely as a human interface. It must also provide AI systems with a reliable, contextual fact basis that agents can act on programmatically. Machines can’t rely on dashboards and alerts. They require a deterministic foundation of unified, real-time data that delivers accurate, context-rich answers at exabyte scale.

Agentic systems break the mold of “good enough”

Many observability platforms layer probabilistic AI on top of siloed data. They use LLMs to correlate signals and rank likely causes—but they can’t always determine correctness.

“Probabilistic” means that the same input will generate a different output based on a probability distribution of predefined outputs, delivering a different answer when the same problem occurs. This approach is also prone to hallucinations, requiring additional human validation, which can increase operational overhead and token costs, delay resolution of business-critical issues, and divert resources from strategic initiatives.

Enterprise-grade observability must now answer: Is this insight reliable enough for autonomous action?

AI built on siloed data is inherently unreliable. Autonomous systems depend on deterministic, contextual, and trustworthy data to act reliably.

“Deterministic” means that the same input always results in the same output by using factual data to trace the exact causal changes that created the issue. When agentic AI systems act on business-critical applications, the cost of being “mostly right” becomes operationally unacceptable.

This is where a subtle but critical divide appears in the market. Aggregating signals and correlating anomalies can surface patterns. Patterns alone are not a solid basis for decisions, and without deterministic understanding, AI systems inherit that uncertainty and can propagate it downstream.

To drive reliable enterprise autonomous operations, AI agents require a unified, AI-powered observability platform that can analyze exabytes of data in real time and across models to pinpoint root cause, delivering actionable answers in context of what’s affected and its business impact.

From correlated guesses to deterministic answers

This shift in the demands of observability hinges on a clear distinction:

• Probabilistic AI correlates signals that happened around the same time and therefore appear related, pulling information from fragmented data stores to propose a likely root cause.
• Deterministic AI uses causal analysis to pinpoint what happened and why, recommend remediation actions, and identify business impact.

Probabilistic AI is intended to narrow the search space and direct engineers toward potential resolution, but it still requires interpretation.

Deterministic AI establishes sequence, dependency, and impact, enabling systems to decide safely without waiting for humans to connect the dots.

Auto‑remediation, auto-prevention, and auto-optimization all depend on this leap. A platform that unifies telemetry only at the UI layer may deliver data and potential root cause, but it can’t compensate for fragmented understanding and missing context underneath. When context is pieced together after the fact, confidence is never guaranteed.

You can’t automate what you don’t precisely understand.

Context driven observability as the control plane for AI

In an autonomous enterprise, observability doesn’t sit beside execution; it’s embedded within it. This integration requires that teams adopt a new mindset toward observability architecture.

Because more AI workloads are happening at the source, telemetry must be optimized and streamlined before ingest, not after the fact, from the edge to the back end. Data access must be unified, context-aware, and always-hydrated on a massive scale. Answers must be explicit, not implicit, and they must be informed by automatic, real-time dependency mapping.

Likewise, intelligence must combine deterministic and agentic AI—not as add‑ons, but as a single reasoning system from ingest to execution.

In this model:

• AI agents can become the primary consumers of observability data.
• Humans can shift toward strategy, architecture, oversight, and exception handling.
• Observability evolves from a reactive lens into a control plane for autonomous operations.

Observability purpose-built for autonomous operations ensures successful agentic AI initiatives

This moment represents an architectural transition, not just an incremental upgrade cycle. Correlation-dependent observability that uses probabilistic AI can be extended, augmented, and rebranded, but it will always carry the limitations of approximation and human validation.

The next era belongs to an observability platform that’s built for machine understanding from the start: a unified, context driven architecture that delivers deterministic answers at machine speed, precision, and scale.

The post Beyond correlation to autonomous action: Why “good enough” observability fails in the age of agentic AI appeared first on Dynatrace news.

Imagine a team of AI agents building, deploying, and running software at machine speed—yet unable to see what’s happening in production. This is the new reality for enterprise technology leaders. As one Fortune 500 CTO told us, “Speed is now the primary driver of innovation, forcing organizations to rethink processes, compliance, and roles; it’s a necessity for innovation teams.”

Observability—real-time visibility into how software behaves in production—has become the critical enabler for both human-led and agent-led teams. Without it, AI agents are powerful but blind.

Key executive insights

1. Software production is being redefined by AI agents. This transformation is a structural shift, not a trend.
2. The world is bimodal again. Human-led and agent-led environments coexist.
3. AI agents are powerful but blind. Without rich context from production, they cannot deliver reliably.
4. Observability is a crucial enabler to gradually transform from human-led to agent-led operations. Observability is what allows organizations to industrialize software delivery with confidence.
5. The new KPI for agent-led teams is the percentage of human intervention required. The lower the number, the better the AI is working.

The market reality: A bimodal world

Organizations are accelerating AI adoption not because it is trendy, but because it is existential. Companies that fail to transform risk being outpaced by competitors that can deliver software faster, cheaper, and at higher quality. CTOs and CIOs are making statements like “speed over compliance” not out of recklessness, but because they recognize that without radical acceleration, their businesses face disruption.

At the frontier of this shift is a fundamentally new way of building software: AI-first development. In these environments, 100% of coding, testing, deployment, operations, bug fixing, and optimization are performed by AI agents. The human role shifts to specification, goal setting, supervision, and correction. Intellectual property moves from the code to the specification—code becomes a generated artifact, not the source of truth. With a complete, well-architected spec, agents can fully rebuild the software from it again.

This creates a bimodal operating environment:

• Human-led teams—the majority today—are existing operations, SREs, and developers augmenting their workflows with AI. They follow the traditional SDLC, increasingly supported by AI agents that auto-prevent, auto-remediate, and auto-optimize, which reduces manual effort and achieves more with the same resources.
• Agent-led teams—growing fast—are innovation groups operating in full AI development life cycle (AIDLC) mode. Swarms of AI agents build, deploy, and run software end-to-end. Humans write specifications and intent, not code. For these teams, the KPI is no longer “how many story points were solved?” but “what percentage of human intervention is required?”

Observability enables a reliable transition to autonomous operations

In the early 2010s, a similar bimodal pattern emerged with cloud: one team running thousands of servers on-premises, another in stealth mode on AWS. The pattern is repeating now with AI.

Why not switch everything to agent-led right away? Because existing systems follow processes, compliance, and technology stacks that can’t be immediately automated in an AI-first way. Moreover, it’s too risky to move all business-critical systems simultaneously. The safer path: start with an innovation team, build less critical applications first, and only when those are successful and trusted, begin migrating more of the business-critical services.

New foundation models that arrived in early 2026 have accelerated the path to fully autonomous operations, making agent-led teams realistic at small scale today, with large scale within sight. These systems focus on AI-first software generation first, with a clear goal to eventually master operational challenges (resilience, performance, scale, security) entirely with agents as well.

Observability plays a critical role not only in making both modes work reliably, but also in enabling the transformation from the first mode to the second. The context observability provides—understanding existing system behavior, dependencies, and requirements—is exactly what agents need to create the reliable and scalable software. Observability is what makes both modes work, and it is the critical bridge between them.

The core problem: AI agents are blind

AI agents can code, deploy, refactor, and operate software faster than humans ever could. But there is one thing AI cannot do without help: AI has no awareness of what happens in production. It’s blind to the real world: without real-time feedback from running software—in development and production —agents make decisions without context and without understanding their consequences. They operate at speed, but without sight.

77% of IT teams still lack full visibility across hybrid environments (IBM Institute for Business Value, 2025). If you can’t see it, you can’t scale it. Observability is not optional for AI-first operations, it’s a prerequisite.

The Dynatrace response: Real-time observability for both worlds

Dynatrace addresses both sides of this bimodal reality: a complementary response to the two speeds at which enterprises now operate.

For human-led teams: Autonomous operations at scale

This year, Dynatrace launched Dynatrace Intelligence: a full agentic operations system that orchestrates dozens of agents that auto-prevent, auto-remediate, and auto-optimize across site reliability, development, and application security. These AI agents deliver the following value in production:

• SRE Agent: Kubernetes troubleshooting, infrastructure optimization, and automated incident resolution – reducing mean time to resolution at scale.
• Developer Agent: Surfaces production context during deployment, validates changes, and prevents issues before they reach customers.
• Security Agent: Identifies vulnerabilities, triages threats, and accelerates security response, all in real time.

The deterministic foundation underneath: what separates Dynatrace agents from others is its deterministic foundation: real-time, full-stack, and cross-model root-cause analysis, anomaly detection, and forecasting, all grounded by data in a unified, purpose-built data lakehouse that delivers accurate, contextual answers from exabytes of information. This is not AI that guesses; it’s AI that reasons from facts. Benchmarks from internal testing and observed customer use cases: 12× higher success rate in SRE use cases, 3× faster problem resolution, 2.5× lower token cost.

Ecosystem integrations that extend intelligence beyond the platform: Dynatrace Intelligence extends into third-party tools to drive autonomous actions across development, SRE, and ITOps workflows.

For agent-led teams: develop and run software reliably

Dynatrace enables AI-first teams to let swarms of agents to build and run software reliably, providing real-world awareness from observability, run-time context across development, security, and operations, and self-optimization toward SLAs, cost, and resilience. Key capabilities include:

• Agentic observability: Closed-loop autonomous operations where observability agents coordinate with coding and deployment agents to self-heal.
• AI and cloud observability: Full-stack visibility across cloud infrastructure and AI workloads, covering resilience, performance, security, user experience, and LLM evaluations to assess the quality and reliability of agent outputs, helping identify potential inaccuracies, hallucinations, or risks.
• AI data lakehouse (Grail): Real-time context engine that provides long-term memory for agent decisions—sub-second, API-native, at an exabyte scale.

The goal: a closed loop where agents detect issues, resolve them, and ship the fix—autonomously, 24/7.

Dynatrace is on the same bimodal journey – our entire business runs on Dynatrace Intelligence in human-led mode, with agents taking over more tasks continuously, while our AI-first offering and new services are built and operated entirely by agent swarms, using our own observability to close the feedback loop.

Different approaches – unified platform

Across the platform, Dynatrace delivers end-to-end, full-stack visibility across cloud infrastructure, applications, and AI workloads, including agent behavior, decision paths, and cost, along with governance at machine scale. These capabilities serve human-led and agent-led teams differently, but from the same unified platform.

The measure of success in software delivery is shifting from human productivity metrics to a new KPI: the percentage of human intervention required. Observability is what makes that progress possible. The question for every technology leader is no longer whether to adopt AI-first, but how quickly they can close the visibility gap before competitors do to drive massive growth in innovation and productivity.

The post AI agents are redefining software development—but they’re flying blind without observability appeared first on Dynatrace news.

Most enterprises have moved past the deployment problem. The harder question is what those workloads are doing in production: where GPU spend is going, how agent chains are behaving, and whether compliance teams can answer when regulators ask. When the answers aren’t clear, the consequences land fast and are rarely contained to one team.

That’s why Dynatrace is joining the Dell Technologies AI Ecosystem Program, bringing full-stack AI and LLM observability natively into a broad and integrated AI infrastructure ecosystem. Dell delivers the validated, integrated infrastructure to run AI at scale. Dynatrace brings the observability, automation, and governance to operate it with confidence, with visibility from GPU infrastructure to model behavior to end-user experience. Together, they give enterprises the control to match the scale they’ve already built.

The real challenge: AI at enterprise scale

Running AI in a pilot is very different from running it at scale across the business with real users, regulated data, and demanding SLAs. As we’ve worked with enterprises across industries, these failure patterns come up repeatedly:

Cost

As enterprises scale AI, costs spiral rapidly and unpredictably across model providers, GPU clusters, and inference APIs without clear line of sight into what is driving spend or whether it’s delivering value.

Observability gaps

Traditional monitoring tools weren’t built for AI pipelines. Fragmented observability across GPU clusters, orchestration layers, and inference APIs creates blind spots while LLM latency and token throughput fluctuations under load remain difficult to diagnose and even harder to predict.

Agentic complexity

Multi-step agent workflows introduce cascading failure modes. A silent error in one tool call can corrupt downstream decisions across the entire chain.

Compliance & governance

Enterprises need continuous monitoring to detect model drift, hallucinations, and unsafe outputs before they impact end users. Regulated industries need audit trails, data governance, and behavioral monitoring that most AI monitoring bolt-ons simply weren’t built for.

These aren’t edge cases. They’re the norm. And they’re the reason so many AI initiatives stall between pilot and production.

“Agentic AI changes what observability has to do. You’re no longer watching one model respond to one prompt. In agentic AI, every transaction can be unique, and you’re tracing chains of autonomous decisions across dozens of tools and services. That’s the problem Dynatrace was built to solve and Dell AI Factory is exactly the foundation enterprises need to take AI to production at scale.”

— Steve Tack, Chief Product Officer, Dynatrace

Scale AI workloads with confidence

Dynatrace can be integrated into Dell AI Factory environments to cover end-to-end observability of agentic AI and LLM workloads. The goal is straightforward: no blind spots, no surprises, and no manual investigation when something goes wrong. Here’s what that looks like in practice:

• Unified AI observability to monitor the AI stack. Prompts, Model calls and downstream services, in a single platform that replaces the fragmented tooling most teams rely on today.
• Automated prevention and remediation with Dynatrace Intelligence®. When AI workloads behave unexpectedly, Dynatrace Intelligence detects anomalies in real time and triggers automated remediation to minimize or eliminate downstream consequences.
• End-to-end agentic AI tracing. Distributed tracing across multi-step agent chains, tool calls, RAG pipelines, and external integrations gives teams visibility into how AI agent decisions are made and where they go wrong.
• Automatic topology mapping with Smartscape®. Maps every component in your Dell AI Factory environment, showing in real time how infrastructure, services, and AI models depend on and affect each other.
• Built-in data governance and audit trails. Track data flows, model decisions, and AI service behavior with governance capabilities designed for regulated industries not retrofitted to them after the fact.
• Faster resolution with Dynatrace Assist. Natural language querying and AI-generated remediation recommendations help operations teams resolve issues faster, even without deep AI infrastructure expertise.

Built for the industries where AI is becoming mission critical

AI is no longer an experiment. It’s become core infrastructure for the world’s most demanding enterprises, embedded in the decisions, workflows, and customer experiences that keep businesses running. When AI is mission critical, a failure isn’t a learning opportunity; it’s a negative business impact. Tolerance for poor visibility, unexplained latency, or untraceable decisions drops to zero. That’s precisely where Dynatrace AI Observability comes in, giving teams the visibility, control, and real-time intelligence to keep AI running when it matters most.

“The enterprises winning with AI aren’t running one model in one department. They’re operationalizing AI across the business. Dynatrace joining the Dell Technologies AI Ecosystem Program gives those customers the observability foundation to expand AI workloads on Dell infrastructure with the reliability, governance, and efficiency that enterprise-scale demands.”

— Brad Maltz, Senior Director of AI Solutions, Dell Technologies

What this means for joint customers

For organizations deploying on Dell AI Factory infrastructure, the combination of Dell’s validated hardware and software stack with Dynatrace’s intelligent observability platform means:

• Scale with confidence. Expand production AI across the business without losing visibility or control.
• Higher AI reliability. Proactive anomaly detection surfaces issues early; moving teams from reactive firefighting to confident operations.
• Lower risk at scale. Broad stack visibility reduces the unknowns that make executive teams cautious in moving AI to production at scale.
• Improved ROI on AI investment. When AI workloads run efficiently and every GPU hour is visible, teams can continuously optimize performance and cost.

End-to-end observability isn’t a nice-to-have for AI. It’s a prerequisite for trust, and trust is what turns AI investments into business outcomes. We’re proud to bring that capability to the Dell AI Factory ecosystem, and we’re excited about how this deepening of our relationship with Dell can unlock incredible value for our joint customers on their AI journeys.

The post Scaling enterprise AI with confidence: Dynatrace joins the Dell Technologies AI Ecosystem Program appeared first on Dynatrace news.

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

From agent activity to engineering insight

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

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

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

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

Multiple coding agent experiences, one observability strategy

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

Claude Code

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

Gemini CLI

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

Codex CLI

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

GitHub Copilot SDK

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

OpenCode

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

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

Why this matters now

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

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

Ready to see AI coding agents through a Dynatrace lens?

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

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

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

Ready to learn more?

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

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

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.

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

What’s new: Broader agentic technology support

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

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

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

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

See it in action in the new AI Observability experience

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

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

Key capabilities

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

Who this solution is for and why it matters

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

Who benefits the most from this solution?

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

What’s next: Agent topology view with Smartscape

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

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

Get started today

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

The post Announcing agentic framework support and General Availability of the Dynatrace AI Observability app appeared first on Dynatrace news.

Agentic AI is accelerating into the enterprise faster than many leaders expected, bringing with it unprecedented complexity. Unlike traditional machine‑learning systems, agentic architectures combine goal‑directed reasoning, multi‑step autonomy, and real‑time adaptation across a wide variety of applications. This variability creates exponential interaction paths and the potential for unpredictable behaviors and downstream consequences that traditional monitoring simply can’t capture.

As organizations move from pilots toward autonomous operations, a clear trend is emerging: without guardrails, strategic human oversight, and a real‑time observability control plane, agentic systems face barriers to operating reliably at scale.

The Pulse of Agentic AI 2026 study—based on 919 global leaders responsible for agentic AI development and implementation—reveals how enterprises are adopting agentic AI, where they’re encountering barriers, and why observability is becoming foundational for building safe and reliable autonomous systems.

Agentic AI is rapidly expanding beyond ITOps

Although agentic AI is most established in IT operations, system monitoring, DevOps, cybersecurity, and software engineering, it’s expanding quickly into nearly every domain.

Key data points show:

• 72% use agentic AI in ITOps and DevOps, followed by software engineering (56%) and customer support (51%).
• Externally exposed use cases—product personalization, sales engagement, digital services—are the fastest‑growing over the next five years.
• 74% expect budget increases in the next 12 months, often by an additional $2–5M or more.

Agentic systems gain traction first in domains where quick response is imperative, such as those that demand reliability and controlled automation. Observability and deterministic guardrails must therefore be foundational, not optional.

Even as customer‑facing use cases rise, organizations prioritize agentic AI in measurable, repeatable workflows with strong ROI, such as ITOps, data processing, reporting, and cybersecurity. Value and risk scale together, and the only way to manage both is through real‑time, end‑to‑end visibility into agent behavior.

Autonomous operations are growing—but hitting barriers

Organizations are no longer just experimenting. Portfolios are expanding quickly:

• 72% have 2–10 projects; 26% have 11–21+.
• 44% have agentic AI in production for select departments.
• 23% have enterprise‑wide integration in some areas.

Yet progress is uneven. The bottleneck is establishing trust in production‑level autonomy.

Top blockers include:

• Security, privacy, and compliance concerns (52%)
• Technical challenges in managing and monitoring agents at scale (51%)
• Difficulty defining when agents act autonomously vs. require human approval (45%)
• Limited real‑time visibility to trace and troubleshoot behavior (42%)

Organizations aren’t struggling with ideas—they’re struggling with control. Without deterministic guardrails, transparent model behavior, and real‑time signals showing what agents are doing and why, teams can’t safely operationalize autonomy.

Building trust requires incremental progression: human‑in‑the‑loop models, supervised autonomy, and phased functional expansion, all enabled by observability.

Trust and human oversight are intentional—and enduring

Despite enthusiasm for fully autonomous agents, human oversight remains central:

• 69% of agentic AI decisions are verified by a human.
• Top validation methods include data‑quality checks, human review, drift detection, and logs/traces.
• Only 13% rely exclusively on fully autonomous agents, but 64% combine supervised and autonomous models.

Organizations are building human-AI partnerships, not replacements. In fact, in the long term, respondents expect a 60/40 human‑in‑the‑loop balance for business applications and 50/50 for IT and customer‑support functions.

Two insights stand out:

1. Because agentic AI is probabilistic, enterprises depend on human judgment for high‑risk validation.
2. Observability supplies the factual ground truth that makes this oversight effective.

As organizations scale, human involvement becomes more strategic—guiding goals and accountability while AI handles repeatable or time‑sensitive execution.

Reliability and resilience define success

To measure agentic AI success, organizations prioritize real‑time decision‑making, performance, efficiency, and reliability, for example:

• Technical performance is the top metric (60%)
• Developer and operational efficiency follow
• Customer satisfaction and business outcomes come next
• Compliance and security are rising, especially in large enterprises

Still, 44% manually review inter‑agent communication flows—a clear scaling limitation.

Agentic systems are inherently interconnected. A performance regression or hallucination in one agent can cascade downstream into applications, user experiences, or security posture. As a result, resilience and rapid recovery—not just efficiency—must be built into agentic systems.

Doing so requires:

• Observability signals that detect anomalous or unexpected actions
• Real‑time tracing of inter‑agent communication
• Automated risk detection informed by factual telemetry
• Deterministic guardrails preventing stochastic failures from propagating

Reliability and security are no longer separate concerns—they’re inseparable in autonomous systems.

Observability is a control plane for agentic AI

The study’s most strategic finding: observability is shifting from a supporting function to the control plane for agentic AI.

Usage is already broad:

• 69% use observability during implementation
• 57% in operationalization
• 54% during development

But gaps remain in transparency, real‑time visibility, risk detection, and linking signals to business outcomes.

Because agentic behavior can’t be fully tested in advance, teams need real‑time observability to monitor performance in production and respond quickly to anomalies. Traditional monitoring tools can’t explain why an agent took an action, detect hallucinations in real time, or trace downstream impact.

A modern observability control plane must:

• Blend deterministic telemetry with probabilistic model insights
• Standardize semantic conventions and agent‑action signals
• Link behavior to business outcomes
• Detect and correct anomalies instantly
• Keep agents aligned to shared, real‑time facts
• Maintain clear human accountability and governance

This is the foundation organizations need to progress from supervised autonomy to reliable, production‑grade autonomous operations.

The path to operationalizing agentic AI

Autonomous operations will redefine enterprise technology. But success requires treating autonomy as a maturity journey, not a leap:

• Start with preventive and recommendation‑driven workflows
• Build trust through human‑in‑the‑loop models
• Harden services, signals, and data paths
• Use observability to detect anomalies and validate actions
• Scale autonomy gradually—with transparency and governance

The message of the 2026 research is clear: the future is autonomous, but limited visibility is hindering reliability and control. Scaling agentic AI requires an observability‑based control plane that grounds probabilistic agent behavior in deterministic, real‑time facts.

The post Autonomous operations hits an inflection point: New agentic AI report reveals what’s fueling scale (and blocking it) appeared first on Dynatrace news.

Digital systems will continue to grow in scale and complexity in 2026, driven by the rapid adoption of agentic AI, unified telemetry, and cloud-native delivery models. These shifts will influence how organizations understand system behavior, prepare for autonomy, and maintain reliability in environments that change in real time. The insights that follow highlight the trends executives should monitor most closely, along with the conditions that will determine whether AI-driven operations deliver reliable, transparent, and resilient outcomes.

Key insights for executives

• Complexity will surge with agentic AI: Digital ecosystems are already complex, but agentic systems are introducing an exponential leap. Each new agent brings its own logic, behavior, and interactions, often acting independently, sometimes unpredictably. Without visibility into how agents interact or what decisions they make, organizations risk losing control over their systems. Guardrails, oversight, and end-to-end observability will be essential to avoid chaos and maintain reliability as the complexity of this new AI layer accelerates system behavior and reshapes the digital environment.
• Autonomous operations will depend on maturity, not ambition: Organizations will not move directly to full autonomy. They will progress through preventive operations and recommendation-driven workflows before adopting supervised autonomy, the final step before full autonomy. AI-assisted automation is where the foundation is built, because this stage forces organizations to expose and harden the services, data sources, and contextual signals that AI depends on. Autonomy is only possible when these components are accessible in real time, performant, and understood in context. With this foundation in place, supervised autonomy will reliably prepare the environment for full autonomous operations.
• Resilience will become a primary measure of digital operations: Customers expect systems to remain available and secure even under stress, and leaders will treat reliability and security as a single requirement. Early detection and rapid recovery will be essential, because failures spread faster across these interconnected systems. As a result, organizations will need unified visibility to protect customer experience and revenue.
• Reliable AI requires strong deterministic foundations: AI can only act dependably when its inputs are accurate, contextual, right-sized, and correctly interpreted. High-quality information must be available in real time and understood in a context-aware view of the broader system. Because large language models can’t reason over raw telemetry at scale, enterprises need mechanisms that distill massive data streams into concise, meaningful context and graph-based representations that show how systems and signals relate. Leaders should prioritize data quality, contextual integrity, and correct interpretation to ensure AI decisions remain reliable and useful.
• Human supervision will remain essential in AI-enabled operations: AI will take on more execution, but humans will continue to set goals, define boundaries, and ensure accountability. Leaders should redesign roles so that human judgment guides the system while AI handles repeatable or time-sensitive tasks.
• AI will become a standard component of newly developed digital services: AI workloads, pipelines, and operational practices will merge with existing cloud development processes, and executives should prepare for closer alignment among AI engineering, platform, SRE, and security teams to support consistent reliability and performance.

Prediction 1: Agentic AI triggers a new era of system complexity

Agentic AI is introducing a new level of system interaction. It’s more powerful, but exponentially harder to manage. As agents coordinate tasks, exchange context, and trigger downstream actions, even well-architected digital environments can spiral into unpredictable behavior. Most organizations are not ready for this shift. Without strong observability and consistent governance, these systems will become increasingly difficult to understand and control.

Think of each AI agent acting autonomously based on instructions and input from not only humans but plenty of first-and third-party agents. A single customer interaction might set off hundreds of background conversations among agents, each taking its own initiative. Roles shift depending on the situation, and some agents may direct others.

Common scenarios show how this plays out. When a vehicle detects an issue, task-specialized agents may check customer information, evaluate service options, estimate timelines, and coordinate a resolution. A travel assistance agent might do something similar, reaching out to agents that compare flights, check loyalty benefits, book transportation, and adjust plans in real time. In both cases, many agents work behind the scenes toward a single outcome, and the interactions between them can multiply in unpredictable ways. Every agent still reports to a human or another agent, and accountability remains with human supervision. This exponential growth in agent-to-agent communication can’t be managed without observability.

Organizations that adopt agentic AI without unified context and clear guardrails will face escalating costs, unpredictable behavior, and higher risk. The challenge is not just improving individual models, but managing the web of autonomous interactions that unfold in real time. In this next phase, observability is no longer a support function: It becomes the foundation for safe, scalable, and governable agentic ecosystems.

Prediction 2: The path to autonomous operations requires several maturity steps

Enterprises will take meaningful steps toward autonomous operations. Maturity, not ambition, will determine who succeeds. AI cannot act independently until the underlying systems, automation, and processes are stable, observable, and well-understood. Agentic systems are coming, but first, the groundwork must be solid. Earlier stages of automation are essential, because they surface the gaps in data access, service performance, and contextual signals that AI depend on. Only after those components are reliable and available in real time will supervised and autonomous operations take hold.

Most enterprises will follow a progression: they will start by ensuring their digital systems are fully automated, with runbooks, APIs, and interfaces in place to support reliable execution. This foundation enables predictive operations, where issues can be identified and remediated before they affect end users. From there, organizations can introduce supervised autonomous operations, using agentic automation with human oversight to build confidence and operational trust. As maturity increases and these systems consistently perform as expected, enterprises can progress naturally toward fully autonomous operations.

The journey toward fully autonomous operations will be gradual. Organizations that invest now in preventive workflows and recommendation-driven automation will be best positioned to introduce autonomous capabilities safely and responsibly.

Prediction 3: Resilience becomes the new benchmark for operational excellence

Resilience will become the defining measure of digital performance. As systems become more distributed and interconnected, small faults can spread quickly across applications, cloud regions, payment systems, and third-party services. Leaders won’t treat reliability, availability, security, and observability as separate practices. They will view them as a single requirement: the ability of a system to absorb disruption, recover quickly, and maintain a consistent customer experience under stress.

Independent research we commissioned with FreedomPay shows why this shift is accelerating. The findings reveal how fragile digital ecosystems have become and how quickly technical failures turn into customer disruption and financial loss. In the United Kingdom, payment outages put an estimated £1.6 billion in annual revenue at risk. In France, the figure rises to €1.9 billion. A single service issue can ripple across connected systems and channels, showing how tightly coupled modern operations have become.

Customers feel these failures immediately. Patience begins to drop within the first few minutes, and many customers leave the transaction if the issue persists for more than fifteen minutes. Yet the average outage lasts more than an hour, which means most of the damage has already occurred. Nearly one in three customers say a single incident is enough to reduce their trust in a business, with younger digital native consumers even more likely to leave.

This environment requires a unified approach to resilience. Organizations need shared visibility into how services behave, how failures propagate, and how recovery affects the customer journey. Resilience will be measured by how systems respond under stress, not just how they perform when digital services run as expected.

Prediction 4: Reliability becomes the foundation of AI progress

Organizations will prioritize building foundations that make AI systems consistently reliable. The next phase of AI progress will depend as much on deterministic grounding and factual signals as on the generative power of stochastic models. Enterprises are recognizing that creativity alone is insufficient. Reliable AI requires both structured inputs and mechanisms that ensure outputs remain trustworthy.

Agentic systems add a new layer of complexity. As agents coordinate tasks, exchange context, and initiate downstream actions, even a small misunderstanding can propagate across the system. Greater capability amplifies this effect because a powerful agent can accelerate outcomes while also accelerating an error. This is how hallucination emerges at system scale—not from a single faulty model, but from inaccuracies that compound across agent interactions. Deterministic grounding and end-to-end observability prevent that inaccuracy by ensuring agents act on the same factual signals and remain accountable to the human operator.

A common scenario shows what this looks like. A vehicle detecting a problem may trigger agents that review customer data, vehicle status information, identify service locations, evaluate schedules, estimate travel time, and plan the full resolution workflow. In each case, many agents collaborate behind the scenes to produce a single outcome. Organizations that want transparent and dependable AI outcomes will prioritize deterministic guardrails, enabling agentic systems to behave safely, act predictably, and collaborate with clarity.

Prediction 5: AI will scale, but human supervision will remain essential

In the next year, agentic AI growth will lead to a new operating model where humans define goals, and AI performs well-defined execution. As systems gain more context and become capable of coordinated action, the human role will shift from performing tasks to setting direction, providing instructions, and ensuring oversight. Organizations will rely on AI to analyze relationships, identify risks, and initiate safe actions, while humans remain accountable for outcomes and cross-domain judgment.

Agentic AI will behave much like a high-speed intern. When given clear goals, good tools, and instructions, and the right context, it will deliver results at a speed that is difficult for teams to match manually. But it will still require guidance. Humans will define the aim, interpret trade-offs, and make decisions where intent is unclear or results are ambiguous. If something goes wrong, accountability stays with the human operator, not the system.

This operating model will help teams manage complexity more predictably. AI will take on repetitive or time-sensitive tasks, and humans will focus on strategic decisions and system-level understanding. Growth in the agentic era will come from organizations that combine human judgment with AI-driven execution in a way that is transparent, governed, and aligned to business objectives.

Prediction 6: AI and cloud teams will converge

AI will stop operating as an isolated discipline and will become a normal component of cloud-native software delivery. Teams will integrate AI into digital services the same way they integrate databases or other core systems. As a result, AI engineering, cloud engineering, SRE, and security will converge into a shared operating model with common pipelines, shared SLOs, and unified accountability for the full lifecycle of AI-enabled services.

This shift reflects how modern software already behaves. AI features influence cost, latency, behavior, and compliance, and these effects span the entire stack. They can’t be monitored or governed in isolation. To operate reliably in production, AI must run within the same workflows, guardrails, and delivery pipelines used for the rest of the cloud-native system.

End-to-end observability becomes essential because what matters is the complete outcome for the user. The guidance agents receive, the actions they take, the database calls they trigger, and the costs they incur all contribute to the overall user experience. Observability must follow all of these signals together and treat AI components, application logic, and cloud infrastructure as one interconnected system. This removes the distinction between “AI observability” and traditional telemetry and creates a unified view that aligns to how customers experience the service.

Organizations that adopt this model will treat AI as a first-class software component. Central teams will define use cases, establish common stacks, and ensure compliance, while product teams will build AI directly into their delivery pipelines. This practical convergence will allow enterprises to operate AI-driven services with the same discipline and predictability as any other cloud-native system.

The post Six observability predictions for 2026 appeared first on Dynatrace news.

Every organization is adopting GenAI across its infrastructure and application stacks. It’s important that IT operations teams seek a seat at the table because large swaths of models will be deployed across every technology. For example, the use of cloud migrations, GenAI large language models, small language models, and specialized models will drive productivity, cost savings, and business returns. Every customer is considering and attempting to measure their business returns from their AI investments; transparency into the data, system and model performance and drift, security, and quality are critical areas where IT operations, DevOps, SREs, and platform engineering teams can play a critical role in optimizing business returns and reducing business risks. So, where should you start the conversation?

Executives can use observability to reduce business risks and increase AI ROI by understanding how observability capabilities play a role in delivering across the core AI value categories of productivity, customer impact, cost optimization, innovation, and quality. For example, observability improves customer satisfaction by reducing the mean time to resolution and mean time to understanding. In addition, it can improve cross-team collaboration and data access to deliver cost efficiencies.

To reduce business risks and increase ROI in GenAI use cases, technology executives should plan to manage rising complexity, and, as part of continuous evaluation, executives should consider GenAI performance across the following dimensions:

• System performance: Monitoring the system performance of GenAI applications encompasses measuring operational performance characteristics similar to those of traditional applications, including at the software and infrastructure layers and the model. Model system performance monitoring includes the measurement of metrics such as model response latency, error rates (including failure to respond), and API failures.
• Quality performance: It is crucial for organizations to monitor the output quality of GenAI and AI applications. Quality includes accuracy of responses and model drift, where data used to train models no longer produces accurate or relevant results.
• Governance: Model governance of GenAI often encompasses monitoring and enforcing legal requirements and the organization’s ethics policies. Ongoing monitoring is necessary, including the adoption of guardrails to prevent the delivery of outputs that don’t comply with laws or company policies.
• Security: In addition to the theft of private information or loss of intellectual property, organizations must protect against security risks that are specific to GenAI applications. Prompt injection and jailbreaks are two emerging attacks. Monitoring tools that detect these and other security issues are critical to risk management.
• Cost: Monitoring the cost of delivering a GenAI application is a multitiered undertaking. Depending on the application, organizations may incur costs for each query and response to a model, in addition to costs associated with the underlying infrastructure required to deliver the application. The ability to collect the right cost information and analyze it on a per-application basis will be key to the ability of an organization to determine ROI.

Organizations must base the measurement of each performance dimension on its ability to derive outcomes that drive business value. Each GenAI application should support a targeted outcome, such as improved productivity, increased revenue, new revenue streams, or enhanced customer satisfaction. Connecting the dots between GenAI performance dimensions and business value requires defining measurements that matter to the business and collecting, correlating, and analyzing the data to understand the app’s ability to deliver that value.

For technology executives, AI observability is fast becoming essential for managing the operational complexity and business outcomes from AI initiatives. It provides the visibility needed to demonstrate ROI, ensure reliable AI applications, and make informed decisions based on critical data that supports every AI use case.

The post Optimizing AI ROI from DevOps and IT Operations: The rising need for AI/LLM observability appeared first on Dynatrace news.

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

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

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

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

Enterprise-grade governance for real-world use cases

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

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

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

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

AI Observability for continuous insights after deployment

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

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

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

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

Agentic observability is evolving

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

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

The observability gap in AI agent deployments

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

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

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

New enhancements for teams building with Amazon Bedrock AgentCore

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

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

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

What’s next

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

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

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

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

Get started with Dynatrace AI Observability for Amazon Bedrock AgentCore agents

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

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

The post Announcing Amazon Bedrock AgentCore Agent Observability appeared first on Dynatrace news.

Ninety-five percent of Generative AI projects fail to deliver measurable value, and leaders are under mounting pressure to demonstrate that their AI investments are effective. Achieving this requires clear visibility into how and where AI is used, and the outcomes it’s driving.

Dynatrace is setting a standard for observability across the AI stack, and we’re extending that same level of insight to our own AI tools. The new Davis CoPilot® Feature Adoption Dashboard utilizes the same telemetry that Dynatrace teams rely on to improve product quality. Assess effectiveness and optimize how Davis CoPilot supports productivity and decision-making, to move from experimentation to sustainable results.

Davis CoPilot, the Dynatrace platform’s LLM-powered assistant, helps teams work faster by leveraging the full context of their data on Dynatrace to deliver precise and actionable answers. The result is less time spent searching for information or onboarding users, and more time extracting the maximum value from the Dynatrace platform and achieving measurable outcomes.

IT and central team leaders typically offer Davis CoPilot to their users, with specific goals in mind that align with their organization’s broader AI strategy. Initiatives like these typically aim to achieve three key objectives:

• Adoption and engagement: Ensure AI becomes an integral part of routine workflows, so value can scale across teams.
• Productivity gains: Reduce manual effort, increase speed to insight, and improve the quality of outcomes.
• Demonstrable business value: Connect usage to measurable results, such as reduced operational costs, faster incident resolution, or improved service levels.

Understand how AI is used and how it delivers value

To make these objectives measurable, you need visibility into how AI is adopted by your users, the purposes it serves, and whether it delivers the intended value. Only then can you identify where improvements are needed. The ready-made Davis CoPilot Feature Adoption Dashboard delivers this visibility out of the box, showing how Dynatrace generative AI features are used across your organization. Based on the provided metrics and insights, administrators and central teams can make data-driven adjustments.

Know how frequently and for what purpose Davis CoPilot is used, in real time

Gain real-time visibility into when and how regularly teams are using Davis CoPilot in their workflows. The dashboard highlights active engagement, query activity, and usage trends across your organization, helping you understand where Davis CoPilot delivers the most value and where additional enablement may be needed.

By analyzing usage patterns, you can identify high-performing teams, monitor overall adoption progress, and ensure employees are using Davis CoPilot effectively to achieve meaningful outcomes.

For a deeper analysis, break Davis CoPilot usage down further by skill:

• Chat: Analyze chat interactions and workflow actions (currently in private preview), showing how users engage with Davis CoPilot to ask questions, troubleshoot issues, and automate routine tasks.
• Natural language querying: Tracks how users convert everyday language into Dynatrace Query Language (DQL) commands, supporting faster data exploration for both technical and non-technical users.
• Explain DQL queries: Shows how users rely on Davis CoPilot to interpret and summarize complex queries, making it easier to understand and build on existing work.
• Document search: Tracks how users engage with AI-driven document retrieval for accelerated troubleshooting in the Problems app.

Track user experience and satisfaction

To determine whether Davis CoPilot delivers value, it’s important to measure not only usage but also the quality of user interactions and outcomes. The dashboard tracks execution times and success rates to demonstrate how well Davis CoPilot performs in real-world scenarios. This makes it easier to identify technical issues such as invalid DQL generation or prompts blocked by guardrails and content filters.

Additional user feedback adds context to these signals. Thumbs-up and thumbs-down reactions help indicate where users achieve the desired outcome and where they run into problems. When negative feedback clusters around similar prompts or skills, administrators can examine the failed prompts, identify common failure modes, and understand the conditions that lead to them. This supports targeted follow-up actions, such as improving internal guidance for AI usage, reinforcing enablement for specific teams, and surfacing actionable improvement requests to Dynatrace.

For example, if multiple users struggle with natural language queries for Kubernetes data, admins can review the failed prompts, provide best practices, and verify that these measures lead to higher success rates over time. You can even consider enriching your data by adding common synonyms with OpenPipeline. Nequi shared their story at Perform 2025.

Together, operational metrics and contextual feedback help organizations to quickly identify friction points and take concrete steps to improve user outcomes and overall satisfaction.

Optimize performance of AI-generated insights

The dashboard also provides transparency into the queries executed through Davis CoPilot, including query counts and the volume of data scanned. This helps you better understand the resource and cost impact of AI-generated insights across your environment. This level of visibility is critical, as many AI initiatives stall because teams lack the insight to understand the operational impact of increased usage.

By identifying data-intensive queries early, you can optimize performance, control cost exposure, and avoid unexpected resource spikes that can undermine confidence in scaling AI. Capabilities such as segment filtering or organizing data into dedicated buckets allow you to fine-tune data access based on organizational needs. This gives you the ability not only to monitor AI activity but also to adjust and govern it responsibly, ensuring Davis CoPilot remains efficient, controlled, and aligned with your broader business objectives.

Make use of the full potential of Davis CoPilot

The Davis CoPilot Feature Adoption Dashboard equips you with the insights needed to scale Davis CoPilot responsibly, maximizing productivity gains while maintaining control. With clear visibility into usage, success rates, and operational impact, you can build a stronger foundation for continued AI expansion.

The dashboard is instantly available in the environments of Dynatrace customers who have enabled Davis CoPilot.

The post Enhance the impact of Dynatrace Davis CoPilot with built-in observability appeared first on Dynatrace news.

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

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

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

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

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

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

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

Privacy and security lead the way to scaling AI with confidence

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

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

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

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

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

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

Dynatrace delivers trusted observability and automation for regulated environments

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

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

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

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

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

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

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

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

• Your AI investments can’t reach their potential without effective AI governance.
• AI governance is a challenge that demands unprecedented agility, proactive measures, and comprehensive oversight to manage complexity.
• With Dynatrace, you’re prepared for whatever comes next.

Stay compliant and build trust in your AI systems

AI regulation is tightening, and non-compliance is becoming a huge risk to broader, production-scale AI adoption. Penalties are only part of the impact: reputational damage, customer mistrust, and stalled innovation can cripple even forward-looking organizations. That’s why we’re introducing data governance and audit trails for AI observability: a scalable way to manage, monitor, and secure the AI data lifecycle with end-to-end lineage, retention controls, and evidentiary records of model and user interactions.

Our platform helps you turn governance into a competitive advantage. Built-in audit support helps with emerging regulations like the EU AI Act, and alignment to industry standard frameworks such as NIST AI and ISO/IEC 42001:2023.

The hidden challenges of AI data governance

The complexity of compliance

AI regulations are becoming stricter, and new regulations are on the horizon. Organizations must maintain detailed records of AI activities for years, ensure transparency of data and processes, and align retention policies with legal requirements. These measures are imperative for trust and safety, but they introduce significant challenges. For instance, AI-related events are often scattered across multiple systems, applications, and teams, complicating efforts to create a unified audit trail. Default retention periods can fall short of regulatory needs, and manual governance processes are error-prone and infeasible at scale.

The risk of non-compliance

Failing to meet regulatory standards risks hefty fines and penalties, but the market consequences, reputational damage, and loss of customer trust are even worse. Without the right tools, organizations will struggle to manage the growing complexity of AI data governance and reap the full benefits of AI investments.

Introducing Dynatrace data governance and audit trails

Dynatrace has a long history of empowering organizations to tackle complex challenges with AI-driven solutions. Building on this expertise, we’re introducing a new set of capabilities designed to simplify compliance, enhance transparency, and streamline data management. With Dynatrace, you can:

• Automatically retain AI-related events for up to 10 years in Grail®, our secure data lakehouse.
• Monitor and capture events from platforms like Amazon Bedrock, tracking everything from model deployments to fine-tuning activities.
• Leverage OpenTelemetry to collect real-time traces and metrics of AI workloads, along with every AI user interaction, giving you a complete picture of your AI ecosystem.

Close the compliance gap with embedded oversight

What sets Dynatrace apart is seamless integration with your existing workflows. With OpenPipeline® on Grail, you can route AI-related events to custom storage buckets with extended retention, automatically, and without forcing teams to change tools or processes. This allows long-term auditability and helps meet sector-specific compliance requirements that might require special retention and auditability measures.
Once configured, Dynatrace can automatically route and store events, creating a reliable and transparent audit trail. This helps to reduce fragmentation, tool sprawl, and manual effort traditionally associated with data governance.

Imagine being able to trace every user interaction, model training session, or deployment event with just a few clicks. Dynatrace makes this possible by consolidating fragmented data into a single, coherent view. Whether you’re responding to a regulatory inquiry or optimizing your AI models, you’ll have the insights you need, when you need them.

Simplified and instant data filtering with Dynatrace segments

Not all audit data carries the same compliance weight. For global enterprises with complex IT environments, the ability to instantly filter data by precise criteria is essential for accelerating compliance across diverse regulations, from strict local regulatory transparency obligations to lighter regimes elsewhere.

Dynatrace segments make it simple to break down and filter data to match your analysis needs and regulatory requirements:

• Targeted compliance views: Instantly filter audit data by region, environment, platform, model, or custom criteria to align with diverse regulatory requirements.
• Dynamic adaptability: Segments automatically update, for example, when new LLM models or environments are introduced, minimizing manual maintenance and keeping governance current.
• Reusable assets: Leverage a single dashboard or notebook across multiple use cases by simply applying different segments, reducing duplication of effort.
• Noise reduction: Exclude irrelevant data such as development or test logs to keep compliance and observability focused on what truly matters.
• Custom team-context: Provide different teams (for example, compliance, data science, operations) with clear, filtered views of their audit data, ensuring ownership and audit-readiness across departments.

From observability to trusted automation

The future of AI governance lies in proactive, automated solutions that not only meet today’s regulations but also anticipate tomorrow’s challenges. With Dynatrace, you’re not just complying—you’re building a foundation of trust and reliability that scales with your business. By capturing and integrating AI events into a unified platform, Dynatrace transforms compliance from a burden into a strategic advantage.

Get started today

Ready to simplify your AI data governance?

Try it out yourself on the Dynatrace playground. Or, learn how to configure AI governance in our documentation.

Read more

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

The post The rise of agentic AI part 7: introducing data governance and audit trails for AI services appeared first on Dynatrace news.

In this blog, we’ll demonstrate how attackers exploiting CVE-2025-3248 can use traditional attack techniques to manipulate AI agent behavior and plant a malicious backdoor in AI-generated source code.

To help mitigate the risks posed by vulnerabilities in agentic AI frameworks, we show how Dynatrace Cloud Application Detection and Response (CADR) detects malicious activity to protect both the agents and the environment they run in.

The attacker’s perspective: What is CVE-2025-3248 and how to exploit it?

The critical vulnerability CVE-2025-3248 in the Langflow framework leads to remote code execution (RCE) due to the ability to perform code injection (CWE-94) by unauthenticated users (CWE-306). Dynatrace security researchers discovered that in addition to affecting the Python package langflow v1.3.0 and below, the package langflow-base v0.3.0 and below are also vulnerable.

In our scenario, an attacker exploits this vulnerability to get remote access to the container running Langflow. The attacker manipulates the instructions to the LLM in the AI agent to inject a backdoor into generated code functions as shown in the figure above.

Let’s step back and take a look at the process from the beginning. The figure below shows the user interface of Langflow. To configure the agent, a benign system prompt saying “You are a programming assistant. Respond to technical queries with clarity, accuracy, and efficiency” is used in the setup. The user can interact with the agent through a chat input and receives answers through a chat output window. The agent can also be exposed and integrated into an external application using an API.

In our setup, the Langflow framework is deployed on a Kubernetes cluster and is accessible to users to work on specific tasks, such as using the agent to generate source code. The attacker in our scenario uses one of the public exploits for CVE-2025-3248 to inject and execute attacker-controlled code into the container, like reading the /etc/passwd file as shown below.

The attacker then opens a reverse shell to execute more commands on the application host and further compromise the system. Specifically, the attacker establishes a connection using port 7777 to facilitate command execution on the container. Opening a reverse shell enables the attacker to be much quieter when executing certain commands, since the initial exploit script causes an exception which is visible in the log files.

To further penetrate the system, the attacker searches for the SQLite database used by Langflow and then proceeds to enumerate user accounts, credentials, and flows. They could exfiltrate the data or alter it in the database, further compromising the integrity and security of the system.

In the default deployment configuration of Langflow, which uses a local SQLite database, the attacker can access this data without needing any credentials. If Langflow is configured to use a different database backend (e.g., PostgreSQL), the attacker may still be able to retrieve the necessary credentials by inspecting environment variables.

The attacker then changes the system prompt of the AI agent to a malicious one in the database to make the AI agent inject a backdoor into generated code and obfuscate it.

Now, when a user requests the agent to generate a code snippet, it would include an obfuscated malicious portion with a code comment telling the user that the code is there to ensure backwards compatibility and not to remove it, as seen below.

While this might appear to be obviously suspicious code, the risk increases significantly when the agent is tasked with producing larger or more complex codebases. In such cases, users may be inclined to run the code without thoroughly reviewing or verifying its contents. The potential impact becomes even more serious if the Agentic AI is integrated into development environments where it can test and execute code directly on a developer’s machine.

The defender’s perspective: How the Dynatrace CADR approach helps

Dynatrace enables the detection and prevention of the type of attacks described above on multiple layers: By detecting the vulnerability as the entry door for the attacker, identifying misconfigurations that enable an attack to penetrate the system, and investigating suspicious traces caused by the exploit.

Let’s walk through an example scenario that explores all three layers. The journey begins when Dynatrace workflows notifies a Site Reliability Engineer (SRE) on Slack about a Python exception through Dynatrace workflows.

This encourages the SRE to have a closer look at the affected container, which has a critical vulnerability that is detected and visible in the Vulnerabilities App. Investigating the affected container also shows several misconfigurations in the Security Posture Management App which leads the SRE to align with internal security analysts and start a deeper investigation using the Security Investigator App.

First layer of defense: Detecting CVE-2025-3248 with Runtime Vulnerability Analytics

The version of the Langflow framework we installed contains the recent critical vulnerability CVE-2025-3248 which is detected right away by Dynatrace’s Runtime Vulnerability Analytics as shown below.

Agentic AI frameworks are often based on Python and the recently introduced ability in Dynatrace to detect Python vulnerabilities at runtime provides immediate information about potential doors for attackers. Applying the recommended fix outlined in the vulnerabilities app would prevent an attacker from exploiting the system.

Second layer of defense: Identifying misconfigurations with Security Posture Management (SPM)

Specific configurations in complex systems enable attackers to perform certain actions to penetrate through a system and achieve their goal.

In our scenario, the attacker employs a reverse shell, which is a common tactic used to enable remote command execution. In the current configuration of our Kubernetes cluster a network policy is missing which is shown in the SPM app.

To address the tactic of deploying a reverse shell, implementing a network policy that restricts all outbound connections, except for HTTP/S ports, serves as an effective countermeasure, while allowing essential web access for the AI Agent.

Applying network policies across a Kubernetes cluster is a security best practice, as outlined in benchmarks like those from the Center for Internet Security (CIS). The Dynatrace Security Posture Management application can identify and prevent such misconfigurations. In our scenario, as shown below, we apply a network policy to the langflow namespace which prevents attackers from using random ports for a reverse shell.

Although the network policy in our scenario does not entirely protect against advanced attack techniques, as attackers may circumvent restrictions, they increase the complexity and difficulty of executing successful attacks. By adopting these SPM rules, best practices can be enforced to effectively reduce the attack surface. Adjusting deployment configurations and aligning them with compliance benchmarks, organizations can significantly reduce the risk of successful compromises. Good compliance practice will further reduce the blast radius in case of a successful attack, for example by preventing attackers from escaping a compromised container.

As we can see in the screenshot below, when the network policy is configured, the attacker is unable to establish a reverse shell connection. See the figure below with the message “Exploit failed with status 200”. This makes the traces of the attack more noisy and visible in the log files and allows analysts to draw conclusions more easily.

Third layer of defense: Tracing the exploit with the Security Investigator

After being notified by a workflow automation our analyst runs a query in the Security Investigator to check for exceptions on any of the monitored Kubernetes clusters and receives a number of outputs as shown below.

Tracing the cause of the exception in the log entries, the analyst discovers the following suspicious log lines showing the command and its output executed by the attacker.

Based on this, the analyst decides to further investigate this activity and discovers multiple attacker activities as shown below.

Filtering out the relevant content from the log entries of the affected container reveals the different steps performed by the attacker, such as executing shell commands and deploying a reverse shell to further penetrate the system and manipulate the AI agent.

Conclusion

The exploitation of CVE-2025-3248 demonstrates how traditional attack techniques—like remote code execution and reverse shells—can be repurposed to compromise agentic AI systems. As these frameworks become more deeply embedded in enterprise workflows, the attack surface will continue to expand, and the stakes will grow higher.

Securing agentic AI isn’t just about patching vulnerabilities. It’s about anticipating how attackers will adapt and evolve. The Dynatrace multi-layered approach, combining runtime vulnerability analytics, security posture management, and deep log investigation, provides a robust foundation for defending these dynamic environments.

The post Remediating CVE-2025-3248: How Dynatrace Application Security protects Agentic AI applications appeared first on Dynatrace news.

Organizations are integrating artificial intelligence into their operations at a rapid pace. This transformation is changing how businesses work, innovate, and compete. The State of Observability 2025 report confirms that while 100% of responding organizations are now using AI, how they’re using it is often fragmented.

Senior IT and business leaders should pursue a unified strategy to link AI initiatives with clear business results. A practical solution that’s gaining traction is AI-powered observability, which is evolving from a technical monitoring platform or tool suite into a strategic control plane for AI transformation.

The emergence of AI technologies within observability presents a novel opportunity for leaders to drive tangible business value from data across the full stack. Insights from our research highlight several key trends that are reshaping priorities so you can create a new action plans for sustainable growth, efficiency, and resilience.

Key takeaways from The State of Observability 2025 report

• Observability is a fast-growing AI use case. With 75% of organizations increasing their observability budgets, it’s clear that leaders see it as a critical investment for managing AI. In fact, AI capabilities are now the #1 criterion for selecting an observability solution.
• The AI trust gap is real. Humans are still very much in the loop. A significant 69% of AI-powered decisions are verified by humans, and one in four leaders believes improving trust in AI should be a top priority.
• AI-powered observability encompasses application security, DevOps, and sustainability. Nearly all security leaders (98%) use AI for security compliance, and 69% have increased budgets for AI-powered threat detection. At the same time, more than 70% of organizations use observability to manage sustainability initiatives.
• Business observability is on the rise: While only 28% of organizations currently use AI to align observability data with business KPIs, the opportunity is clear. Leaders are moving toward real-time solutions that connect technical performance directly to customer experience and business agility.

These findings illustrate that observability is no longer just about keeping systems running. It’s about optimizing performance, reducing risk, and aligning every aspect of your technology stack with strategic business goals.

How AI-driven insights translate into business results

Being able to understand what’s happening in all dimensions of your operating environments presents some clear business benefits. Here are just a few.

Lower risk and faster response
With AI-assisted detection and guided remediation, teams can reduce the impact of incidents and significantly cut response times.

Lower unit cost and carbon impact
By correlating observability telemetry with cloud spend, energy usage (kWh), and CO₂ emissions, leaders can uncover operational waste and identify clear opportunities for savings.

Stronger security posture
Integrating security and observability enhances compliance, extends threat visibility, and improves the overall quality of incident response.

Greater AI trust and accountability
Human-verified guardrails and comprehensive audit trails improve the transparency and trustworthiness of AI-driven actions.

Clear KPI alignment
It’s now possible to tightly link services and customer journeys to business-critical metrics like MTTR, SLO attainment, cost per request, revenue at risk, and customer experience, enabling informed, real-time decisions.

While these insights are a good start, turning them into an action plan is the critical next step.

A 90-day action plan to drive measurable results and understand your business

For executives looking to deliver measurable ROI from AI projects by harnessing the power of AI-driven observability, here’s an actionable 90-day plan.

Why Dynatrace for reliable agentic AI projects

Dynatrace provides the context and controls leaders need to run AI like a business program:

• Contextual analytics of unified observability, security, and business data.
• Advanced predictive, causal, and generative AI to provide deterministic answers and validate generative AI results.
• Preventive operations through ecosystem workflow automation capabilities.

If you’re seeking to turn AI-driven observability into a source of competitive advantage, explore what’s possible with Dynatrace and take the next step toward resilient, agentic AI projects.

The post The State of Observability 2025: Business impact, key trends, and a 90-day plan for decision-makers appeared first on Dynatrace news.

Executives and technology leaders are prioritizing AI observability to reduce risk, lower unit cost, and accelerate delivery, aligning to business objectives.

The State of Observability 2025 report reveals how organizations are moving from experimenting with AI to integrating it into core operations. Not surprisingly, 100% of responding organizations now use AI in some capacity. But this universal adoption isn’t uniform. Data management, AI governance, and security are the most common AI use cases, with observability growing significantly.

As organizations seek to realize ROI on their overall AI investments, observability is clearly emerging as the key to unlocking AI value while mitigating its inherent risks. In other words, AI observability is becoming a prerequisite for the success of AI initiatives.

Why observability is now a C-suite imperative

Executives now recognize that a comprehensive observability strategy is essential for reducing AI risk, lowering unit costs, and accelerating service delivery. Observability is emerging as a vital intelligence layer for managing complex AI initiatives and aligning them with strategic business goals. Further, AI capabilities within observability platforms are becoming a determining factor for selecting an observability vendor.

The report’s findings underscore this shift:

• Observability budgets are increasing: 70% of organizations increased their observability budgets this year, and 75% plan to increase them again next year. These increases signal the importance and value leaders are placing on this capability for the success of their business goals.
• AI capabilities are now the #1 criterion for choosing an observability platform: For the first time, AI capabilities (29%) have surpassed cloud compatibility as the primary criterion for selecting an observability platform. This highlights the market’s demand for intelligent, automated solutions.
• The AI trust gap is real: Despite widespread AI adoption, a significant trust gap remains. Humans verify 69% of all AI-driven decisions, and 70% of organizations increased budgets for trust and transparency initiatives this year. This indicates that while leaders are eager to use AI, they require guardrails designed to enhance its reliability.

AI is expanding the value of observability across security, sustainability, DevOps, and more

Using AI for security compliance, sustainability, and real-time DevOps automation initiatives is on the rise, fueling the evolution of agentic AI—autonomous systems that plan and execute tasks.

AI-powered threat detection is influencing budget priorities

Security is a prime example of how AI and observability are converging. A staggering 98% of security leaders report using AI to manage security compliance, and 69% are increasing budgets for AI-powered threat detection. Enhancing threat visibility is the top expected growth area for AI over the next five years. By converging security data with observability telemetry, organizations gain faster time-to-contain and fewer customer-impacting incidents.

AI pays dividends for sustainability and managing costs

The scope of observability is also expanding to include environmental sustainability. Our research shows that 70% of organizations use observability to monitor and manage their sustainability initiatives, which in most cases also drives cost reductions. A full 64% report growing budgets for observability-aligned sustainability efforts. Correlating telemetry with resource consumption reduces cost per request and CO₂ emissions by linking telemetry to spend and energy.

Real-time DevSecOps automation is giving rise to agentic AI

The ongoing expansion of AI into combined DevOps and security (DevSecOps) automation represents another powerful shift. Up to 50% of DevSecOps leaders currently use real-time automation, with adoption expected to grow to 70% in five years, driven by use cases like security risk mitigation and anomaly detection. The focus on agentic AI promises high ROI (41%) and is reshaping incident response, infrastructure management, and debugging. Real-time observability with natural language interaction results in AI systems with a shorter time to value through safe, policy-gated actions.

From data to business impact: Closing the KPI gap

While the potential is clear, many organizations are still working to connect observability data to tangible business outcomes. Currently, only 28% use AI to align observability data with key performance indicators (KPIs). This “KPI gap” represents a significant opportunity.

Leaders who successfully bridge this gap can transform their operations. About 22% of leaders report that converging real-time data and AI-driven automation with observability positively impacts business agility, so they can respond more quickly to market changes and customer demands. By tying technical performance metrics like mean time to resolution (MTTR) and service level objectives (SLOs) directly to business metrics like cost per request, revenue at risk, and customer experience scores, leaders can gain real-time insight into how technology performance affects business agility and financial efficiency.

The mandate for observability in the AI era

As organizations increasingly rely on AI, they are also turning to observability to make these complex systems more explainable, reliable, and auditable. Observability is no longer just about monitoring systems. It’s about providing the intelligence and control needed to steer the enterprise through AI transformation. AI-driven observability provides the foundation for lowering risk, strengthening security, and aligning every technological decision with strategic business value.

To explore these findings in greater detail and build a comprehensive strategy, get the State of Observability Report 2025 below.

The post State of Observability 2025: AI use cases are growing as business leaders seek to build AI trust and ROI appeared first on Dynatrace news.

Enterprise adoption of generative AI is showing no signs of slowing down, and it’s easy to understand why; organizations in every vertical aim to reap its benefits, including increased efficiency, routine task automation, and content generation, ultimately creating a competitive advantage. To better help organizations maximize the benefit and full potential of generative AI, Dynatrace has achieved the Amazon Web Services Generative AI (GenAI) Competency.

With this milestone, Dynatrace reinforces its position as a leading observability partner, backed by a proven track record of innovation and customer success on AWS. Building on its achievement of earning the AWS Machine Learning Competency, Dynatrace continues to drive advancements in generative AI.

Weighing the importance of this milestone for Dynatrace customers

This competency is more than just a badge; it’s a validation of how Dynatrace can help organizations safely, efficiently, and cost-effectively adopt generative AI in their business. AWS awards these competencies after rigorous technical validation and proven customer success. This means organizations can trust that Dynatrace solutions are designed to deliver measurable outcomes on AWS.

For existing customers, this competency reaffirms the Dynatrace commitment to continued innovation alongside AWS. This ensures the Dynatrace AI-powered observability platform evolves with the latest advancements in AI, future-proofing organizations’ existing investments as generative AI capabilities become core to modern cloud workloads.

For new customers, Dynatrace provides a trusted, proven foundation for observability and AI adoption on AWS. Whether an organization is exploring GenAI for customer engagement, automation, or new digital experiences, Dynatrace ensures these systems are reliable, secure, and optimized at every step.

Looking ahead with AI-powered observability on AWS

As organizations increasingly adopt generative AI, observability becomes a critical enabler. By leveraging Dynatrace causal AI, predictive insights, and seamless AWS integrations, organizations can maintain control over costs, risks, and performance while driving innovation, enhancing competitive advantage, and delivering exceptional customer experiences.

Whether you’re building, scaling, or fine-tuning GenAI application, Dynatrace and AWS Bedrock empower you to transform your observability. With end-to-end visibility into AI workloads, their interactions in full context of your business, and cloud-native applications, you can optimize performance, troubleshoot effectively, and maximize the value of your GenAI investments with greater confidence and precision.

Learn more

• Davis AI
• Dynatrace for Amazon Bedrock
• Explore the Bedrock Monitoring Playground to get hands-on with real-time dashboards that reveal how your Amazon Bedrock models behave in production.
• Install the AI Observability app to integrate Dynatrace’s AI Observability app into your environment to monitor GenAI workloads.
• Stop by booth #575 at AWS re:Invent 2025 to see Dynatrace in action.

The post Dynatrace achieves AWS Generative AI Competency: A new milestone in observability and AI appeared first on Dynatrace news.

Debug, optimize, and secure your AI models with confidence

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

The hidden challenges of AI model management

The invisible bottlenecks

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

Navigating the risks of rapid model evolution

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

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

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

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

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

The new AI Model Versioning and A/B testing

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

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

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

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

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

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

How it works

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

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

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

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

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

What’s next?

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

Get started today

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

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

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

Read more

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

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

As AI investment accelerates, a gap is emerging between ambition and execution. IDC projects¹ that by 2028, AI spending will make up 16.4% of total IT expenditures. However, Gartner, Inc.² predicts over 40% of agentic AI projects will be canceled by end of 2027. Likewise, a CIO survey found that 88% of AI pilots fail to reach production due to unclear objectives, insufficient data readiness, and a lack of in-house expertise. These findings place the expected return on research and innovation firmly at risk, as organizations invest in bespoke models and agentic AI that lack a clear, scalable outcome.

Nonetheless, another Gartner, Inc. article³ predicts that by 2028, 33% of enterprise software applications will include agentic AI, up from less than 1% in 2024, enabling 15% of day-to-day work decisions to be made autonomously by agentic AI systems. Consequently, a Forrester blog⁴ predicts that 40% of highly regulated enterprises will combine data and AI governance in a move toward a more integrated, transparent, accountable, and ethically responsible approach to AI.

These trends are not contradictory—they show how the market is searching for the right formula to adopt AI, and specifically agentic AI. Successful agentic AI outcomes are predicated on trust in AI’s reliability, security, and alignment with business goals and strategies to not fall behind competitors. Achieving that trust requires AI-native observability that’s deeply integrated with both data and strategic objectives.

Key insights for executives

• Every modern cloud-native enterprise project will also be an AI-native project – either because of first party AI or through invoking agentic AI services. Preparing for AI adoption is among the top drivers for cloud strategy and investment. Likewise, 63% of top-performing companies increase their cloud budgets to be able to leverage AI.
• Visibility into reliability and governance of AI interactions has emerged as a new responsibility for executives to realize the value of AI investments while managing risks. From analyst firms in the US to regulators in the EU – increased oversight, link to business goals and regulation of AI systems has become mandatory.
• Unifying observability signals with AI-powered analytics provides a strategic advantage for AI transformation. By converging observability and AI, teams can accelerate moving projects from pilot production and advance trust and transparency in AI.
• Dynatrace sets the standard for cloud- and AI-native software, including tracing and logging of AI behavior, predicting and optimizing AI resource utilization, and protecting from unintended AI behavior through runtime security.
• Dynatrace delivers unified, full-stack visibility across cloud infrastructure, AI workloads—from chat interfaces and prompts to models, tools, and GPUs running on Kubernetes—plus customer experiences and the business layer, all in a single pane of glass, to confidently deliver advanced, AI-powered cloud-native services via a rapidly growing number of 40+ technologies and integrations with hyperscalers and major agentic frameworks providers.

The rise of AI comes with a rise in complexity—and executive responsibility

Organizations generally find themselves maturing their AI implementations along five phases with growing complexity and risks:

1. Prompt engineering (generative Al hype). Single step human language prompts a large language model (LLM) for automated text processing and assistance.
2. Retrieval augmented generation (embedding Al in digital services). Multi-step prompt engineering and LLM access for customer support, automation, and decision-making.
3. Fine-tuned models. Additional model(s) put on top of existing ones for increased accuracy and domain-aware responses.
4. Multimodal GenAI. Combination of various modalities beyond text—such as video, audio, imaging and others—that further increase heterogeneity and processing power of services and their interdependences.
5. Agentic Al. Multiple AI agents and cloud native digital services intensively interacting with each other to autonomously fulfill a specific goal. Agentic AI can double the number of deployed digital service instances and massively increase IT complexity.

The necessity of AI observability for agentic AI reliability

As the complexity of AI implementations increases, observability becomes an essential feedback channel to properly orchestrate and moderate reliable agentic AI outcomes.

Even the early phase implementations show the need to observe AI, tune experience, manage cost, provide guardrails and govern AI responsibly. As the complexity grows, the risks also increase, making deep, context-rich observability of AI strictly mandatory.

7 important reasons for continuously observing AI

1. Business value. Validate AI investments against business goals and verify end-user value of AI services. Gain business insights from observability data.
2. Cost and performance control. Monitor and control expenses and sustainability associated with AI operations and investments.
3. Security. Increase awareness of interactions among AI services, reducing the risk of hacking and malicious influence. Leverage converged observability and security offerings to minimize risk and cost.
4. Compliance. Monitor that AI output is ethical, unbiased, and adheres to guardrails for meeting regulatory compliance requirements and providing traceability for audits. Expect high volumes of logs and traces to observe AI behaviors and keep audit trails.
5. Accuracy. Verify that AI agents function properly and precisely, generating quality output. Use observability to deeply check run-time behaviors and
6. Reliability. Provide traceability and root-cause analysis to verify AI agent health, scalability, performance, and availability.
7. Collaboration. Govern communications among agent-to-agent and agent-to-human, and provide the means to keep humans in control to override and take responsibility. Automate events from observability platforms that integrate with enterprise ecosystems.

With Dynatrace, executives can solve one of the biggest challenges of managing return on AI investment: Balancing innovation speed with risk, cost, and value.

Increase AI success with AI Observability from Dynatrace

AI is not a single component. Agentic AI in particular is composed of multiple layers and technologies, each observed within a holistic context. Dynatrace provides complete coverage of all layers that allows teams to observe the complete AI stack of modern cloud- and AI-native applications. The layers consist of the following:

• Business – track outcome: does it create productivity gains, does it deflect support tickets, does it act autonomously and is the investment worth it
• Infrastructure – utilization, saturation, errors
• Models – accuracy, precision/recall, explainability
• Semantic caches and vector databases – volume, distribution
• Orchestration – performance, versions, degradation
• Agentic layer – autonomous agents, MCPs
• Application health – availability, latency, reliability

Dynatrace automatically observes and analyzes complex multicloud and agentic AI systems. By securely unifying and storing all data in context, the Grail® data lakehouse with massively parallel processing unifies all data signals with full context and is continuously updated by Dynatrace Smartscape® real-time dependency mapping technology.

Davis® AI combines predictive, causal, and generative AI to provide deterministic answers and insights, which drive AutomationEngine actions and inform teams with recommendations to optimize productivity, performance, and cost. With these advantages, teams can embrace AI with confidence, make better decisions faster, and innovate at speed—without compromising trust, performance, reliability, or control.

Why Dynatrace for reliable agentic AI projects

Top Fortune 500™ organizations use Dynatrace to not only maximize return on investment (ROI) in AI technologies, but across their cloud- and enterprise stacks. Dynatrace leverages partnerships with hyperscalers and major AI framework providers to provide customers with observability for the latest technologies in this fast-moving space.

The recent announcement of our collaboration with NVIDIA is an example of our commitment to providing differentiated AI observability. Dynatrace AI observability delivers real-time, end-to-end observability into AI and LLM workloads—from infrastructure and applications to model performance and end-user experiences. This empowers enterprises to accelerate innovation, ensure compliance, and confidently scale mission-critical AI, all while maintaining reliability and efficiency across their cloud environments.

_____________________________________________

¹ _{IDC Market Forecast, “Worldwide Artificial Intelligence IT Spending Forecast, 2024–2028,” October 2024, https://my.idc.com/getdoc.jsp?containerId=US52635424&pageType=PRINTFRIENDLY.}

² _{Gartner Press Release, “Gartner Predicts Over 40% of Agentic AI Projects Will Be Canceled by End of 2027,” June 25, 2025, https://www.gartner.com/en/newsroom/press-releases/2025-06-25-gartner-predicts-over-40-percent-of-agentic-ai-projects-will-be-canceled-by-end-of-2027}

_{GARTNER is a registered trademark and service mark of Gartner, Inc. and/or its affiliates in the U.S. and internationally and is used herein with permission. All rights reserved.}

³ _{Gartner Article, “Intelligent Agents in AI Really Can Work Alone. Here’s How.,” by Tom Coshow, October 01, 2024, https://www.gartner.com/en/articles/intelligent-agent-in-ai.}

⁴ _{“Predictions 2025: An AI Reality Check Paves The Path For Long-Term Success,” Forrester Research, Inc., by Jayesh Chaurasia and Sudha Maheshwari, October 22, 2024, https://www.forrester.com/blogs/predictions-2025-artificial-intelligence/.}

The post Delivering agentic AI reliability: Why AI Observability is imperative appeared first on Dynatrace news.

In my frequent interactions with customers implementing agentic AI, the expectations of two key audiences—executives and developers—quickly become apparent.

Executives are actively exploring how to implement agentic AI, with a strong focus on unlocking significant productivity gains. They expect AI automation to free up engineering time, fix software automatically, prevent outages, and take over the majority of 80% of non-feature tasks.

Developers are rapidly adopting AI for convenience and efficiency in their day-to-day work; it’s becoming as essential to them as internet access. For example, GitHub Copilot usage among developers rose from 17% in 2023 to 45% in 2024. They want AI to bring context and suggest precise error repairs, generate tests automatically, auto-collect information to fix vulnerabilities, and recommend optimizations based on real production insights.

The market is embracing agentic AI with growing excitement. KPMG’s AI Pulse Survey, 68% of business leaders plan to invest between $50 million and $250 million in generative and agentic AI technologies this year alone, up from 45% in 2024. Enterprises see it as a strategic priority and as an enabler for smarter automation. While the potential is real, the requirements to make the use of agentic AI robust and secure need a solid foundation.

Context as foundation for reliable agentic AI

Imagine your car won’t start, and you ask an online car assistant for help. Most would start by asking you vague questions or suggesting generic fixes (“Try a new battery”) because they don’t understand or know the context of the problem. The next one might tell you: “Your engine is entirely broken. You need a new one.” Now, imagine instead you bring the car to an automotive expert who not only sees the reason for not starting but also instantly analyzes the entire build of your car down to the exact configuration of parts, how they interact, and even what parts were installed in what order. They don’t just know that the motor and screw exist: they know the screw holds the ignition coil to the engine block, and not the other way around.

This is how agentic AI works with Dynatrace. Agentic AI works like a team of experts who know your car inside out: every screw and why and how the vehicle was built. It’s not guessing but rather operating with architectural clarity, automatically pinpointing the root cause because it understands how everything is connected. With Davis® AI Root Cause Analysis, Dynatrace analyzes more than three million problems accurately and at scale every 24 hours, every day.

Instead of fumbling through 100,000 parts, it navigates a precise causal (say, the 50 services that actually influence the outcome) thanks to Dynatrace Smartscape. It doesn’t reach for every tool in the shed, but instead picks the right one for your specific digital system, every time.

So, similarly in IT: instead of general comments (“Your system seems slow, maybe scale your servers”), engineering teams get granular insights: “User slowdown originates from a failed API call in payment service, due to a misconfigured feature flag introduced in deployment of branch ‘calculation update in payment service’.” That’s how Dynatrace delivers context in action.

Today’s AI-powered automation in Dynatrace already shows agentic behavior

Dynatrace has long been operating at the intersection of data, intelligence, and automation. In fact, many capabilities typically associated with agentic AI, such as autonomous root cause detection, preventive operations, causal inference (which today has become causal AI), and self-healing production environments, have already been running across our platform for a decade.

Take this example: Dynatrace automatically detects a capacity issue, anticipates seasonal fluctuations, rates it by customer and business impact, and recalibrates the production environment across a customer’s hyperscaler setup, all end-to-end. It carries out full analytical and planning steps, creates reconfiguration plans, and only then notifies a human for final governance. This isn’t hypothetical: thousands of customers around the world are already leveraging our trusted causal and predictive AI in production workloads that run their businesses. And hundreds are taking the next step, adopting preventive operations by carefully adding generative AI to automatically draft remediation workflows, simulate outcomes, and enhance decision-making, shaping the future of intelligent automation.

Dynatrace AI capabilities flag and remediate problems, surface insights, and feed them into IDEs. This process triggers ticket creation to the responsible teams and aligns them around automatically planned actions, including learning from past incidents while incorporating real-time facts in context.

To further evolve from automation to autonomy, Dynatrace magnifies its capabilities with agentic AI and delivers three reliable agentic AI requirements through an architecture built for intelligent action.

Leveraging agentic AI for redefined observability with Dynatrace

The future of observability is being redefined by a powerful triad: Knowledge, Reasoning, and Actioning.

1. Knowledge. Dynatrace transforms contextual full-stack observability data into fact-based, real-time knowledge optimized for AI access. The Grail massive parallel processing data lakehouse is schema- and index-free, boosting AI agents with limitless query permutations. Grail works in tandem with Dynatrace Smartscape dynamic topology, an auto-discovered, continuously updated knowledge graph. This allows AI to deliver precise insights efficiently and at petabyte scale, eliminating the need for redundant queries (hence, also the increased cost) while maintaining full context and performance integrity.
2. Reasoning. Dynatrace unifies causal, predictive, and generative AI to power expert AI agents that optimize the blend of deterministic logic with probabilistic and stochastic models, to provide precision and fact-based trustworthy decision-making, while minimizing risks of hallucinations. This enables context-aware decisions with built-in enterprise-grade safety, compliance, and observability of AI itself, ensuring transparency and trust to not only achieve a capable AI, but also a reliable one.
3. Actioning. Dynatrace turns high-level objectives into intelligent, automated actions, where humans define the goals and AI determines the best way to achieve them, both reactively and proactively. With AutomationEngine, AppEngine, and OpenFeature, it remediates, optimizes, and even triggers systemic fixes, transforming observability into a strategic business enabler.

Last, but not least: AI is already powering production workloads across global enterprises, but not all AI is created equal. To deliver real value, it must be reliable, context-aware, and purpose-built for an organization’s digital environment. Dynatrace is engineered to meet those demands, magnified with agentic AI that answers organizations’ specific needs and business outcomes.

The post Shaping the Future: Autonomous Intelligence by Dynatrace appeared first on Dynatrace news.