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.

Software quality isn’t just about clean code. Bartek Pisulak, Director of Cloud Quality Engineering at Pegasystems, says it’s also about architecture, documentation, and processes working in harmony. But today’s systems are so complex that even small failures can ripple into outages across your entire stack. Understanding those interactions—and testing them—has become nearly impossible without help. That’s where AI comes in.

In this episode of the PurePerformance podcast, Bartek joins hosts Andi Grabner and Brian Wilson to explore how artificial intelligence is transforming chaos engineering, making it faster, smarter, and more effective at uncovering weaknesses before they become disasters.

How AI can enhance the five stages of chaos experiments

Pisulak walked through each of the stages of chaos experiments, and explained how AI fits into each one:

1. Defining steady state. AI learns your system’s “normal,” tapping into observability systems to detect patterns. Traditionally, this might be done by simply setting thresholds for different metrics. But Pisulak suggests using AI to analyze historic data to learn normal system behavior and predict failures before they happen. This has been possible using causal AI systems since before generative AI hit the scene, but remains a key starting point.
2. Generating hypotheses. Instead of hunting for weak spots manually, Pisulak recommends feeding your system’s architecture diagrams, logs, and documentation to AI-powered tools like Chaos Recommendation for Kraken or chaos eater that can surface edge cases, single points of failure, or unusual dependencies.
3. Running experiments. This is where AI-coding tools come in. They make it much quicker and easier to write scripts to run your experiments.
4. Verifying results. After experiments run, AI can sort through the avalanche of data and analyze your dependencies and software bill of materials (SBOM) to help prioritize fixes or note which ones are most likely to be false positives.
5. Improving the system. AI can propose code changes or configuration improvements. In advanced use cases, it helps create a feedback loop, automatically fixing issues, re-running previously failed tests, and driving continuous improvement.

In short, the value of AI in chaos engineering is about making the entire process more intelligent and robust, freeing engineers to innovate and build stronger systems.

Our perspective: Organizations are under pressure to move from AI proofs-of-concept to demonstrating real value. Using AI in resilience testing, as described by Pisulak, could be an easy win for operations teams. As Dynatrace VP and Chief Technology Strategist Alois Reitbauer recently said on the CUBE, AI presents real potential to help operations teams move from firefighting mode to start thinking about making bigger-picture improvements that they just don’t have time to focus on.

The post AI’s surprising role in chaos engineering appeared first on Dynatrace news.

Working with customers brings its own joys, often unexpected ones. At Dynatrace, we’re amazed by the creative and unexpected ways our customers use our platform.

We recently announced Dynatrace Live Debugger, which gives developers unprecedented access to real-time data and runtime behavior insights. This powerful tool can be leveraged across various environments, including production, to enhance development processes and ensure robust application performance. Following are some of the coolest things we’ve seen engineers do with Live Debugger.

White box testing

The nicest thing about deploying UI changes to production is that you can immediately see the changes in action. You can see when a new version is deployed, test it to ensure everything works as expected, and you’re done.

On the other hand, deploying new code on the backend is complex and offers no such transparency. How can you tell if an algorithm or data source changed or a new feature flag worked?

Many developers attempt to mitigate this challenge with logs, but that’s a tedious and error-prone process. Not to mention, if logs are missing, you’ll have to deploy your applications and services all over again.

With Dynatrace Live Debugger, you can set a non-breaking breakpoint and instantly see if new code is following the intended new paths, if any new arguments are being considered, and if input and output arguments are aligned with expectations. This way, even if reality collides with your expectations, you have a trace ID, debug-level logs, and a real-time snapshot to guide you.

Test data collection

Accurate test data can mean life or death. After all, how useful can it be if you just make up test data in your integrated development environment (IDE) with no thought to what’s out there in the real world?

Even a naive data type such as a string can have endless variations in length, encoding, locale, character type, and more. Lists, arrays, and objects naturally cause more trouble. Worst of all, your functions might receive unexpected data types.

With Live Debugger, you can see the precise inputs your code calls in production so you can design your tests accordingly. You can verify any system settings that might impact your tests and see them in action.

Performance benchmarking

Performance benchmarking is one of the unresolved mysteries of software engineering. In many ways, it’s more of an art than a science.

Sometimes, you need heavyweight tools. Load generators simulate traffic. Distributed tracing shows transactions end-to-end. Memory and CPU profiling are there to help you find the “needle in the haystack.”

But, sometimes, you need to easily measure how long it takes to get from point A to point B. Maybe you want to focus on a specific service, endpoint, user, or use case. Maybe you want to monitor performance under different system loads. Or maybe you want to correlate an event with other events in your system.

Either way, Live Debugger allows developers to place two breakpoints and measure the time between those two invocations. This allows dynamic techniques like binary search to pinpoint the exact line of problematic code, facilitating more precise performance benchmarking.

Dead code detection

Did you ever look at a function and wonder if it was ever even called? Have you ever wished to see a pesky little log line that could tell you for certain if a certain function was used? Well, wish no more!

With one click, you can set a non-breaking breakpoint on a function, come back in a week, take a look, and see if and by whom the function was called.

You can even take it up a notch; set the breakpoint within a specific branch to test whether a condition is true or false. Set a conditional breakpoint to check if that argument is ever in use, gets a specific value, or goes beyond a certain range and size.

Learn the code

How often do you dive into a code you don’t understand? Maybe the code was written a month or a decade ago. It might have been written by your predecessor, a different team, or some new GenAI tool. Sometimes, you just have the pleasure of deciphering someone else’s “spaghetti” code.

Knowing where to start and how to follow code can be a considerable challenge, especially in modern, dynamic languages. Debugging step-by-step in your IDE often won’t get you far, especially when executing the code locally is not easy. Live Debugger allows you to follow code execution in real time, in real environments.

See which function calls which piece of code, what real values are processed, and how the code forms specific behaviors and outputs.

Troubleshooting and debugging

Not surprisingly, most of our customers use Live Debugger for a more obvious use case: troubleshooting and debugging their code.

Modern software practices are notorious for making code extremely hard to debug. The reasons for this are many.

• Cloud-native services are challenging to execute locally.
• Distributed services involve multiple processes and runtimes.
• Legacy servers pick up complexity and dependencies over time.
• Compliance and security prohibit ease of access in highly restricted environments.

However, even easier-to-debug services often come with impossible-to-reproduce troubleshooting issues, including:

• Behaviors involving the (distributed) application state.
• Bugs resulting from obscure and unexpected inputs.
• Flaws resulting from (mis)behaviors in open source and third-party dependencies.
• Defects occur only in certain stages or deployments.

Having Live Debugger is about having a production-grade tool to investigate your code. It’s a tool you can use in any environment or architecture, instantly showing you the innermost workings of your code wherever and whenever you need it.

Get started

Dynatrace Live Debugger and its Visual Studio Code and JetBrains plug-ins are now available for all Dynatrace SaaS customers with a Dynatrace Platform Subscription.

For more information, please see our recent Live Debugger announcement blog post and related press release.

The post 5 powerful use cases beyond debugging for Dynatrace Live Debugger appeared first on Dynatrace news.

Every software developer has faced the frustration of debugging. Whether it means jumping between multiple windows, sifting through extensive logs to track down bugs, trying to reproduce locally, or requesting additional redeployments from DevOps, debugging poses significant challenges and a resource drain.

The problem intensifies when bugs occur mysteriously only in production. A production bug is the worst; besides impacting customer experience, you need special access privileges, making the process far more time-consuming. It also makes the process risky as production servers might be more exposed, leading to the need for real-time production data. This typically requires production server access, which, in most organizations, is difficult to arrange.

This cumbersome process should not be the norm. Developers deserve a seamless way to troubleshoot effectively and gain quick insights into their code to identify issues regardless of when or where they arise.

Racing to the next sprint is how it works everywhere, so rapid iteration and swift problem resolution are crucial. Developers not only write code; they’re also accountable for their applications’ performance and reliability. Unfortunately, traditional methods of debugging—such as local and remote debugging—aren’t relevant in most cases and lack the real-time insights necessary for effective troubleshooting. Also, debuggers were built for local development, not for modern production environments’ massive scale and distribution.

This is why we’re excited to announce the launch of Dynatrace Live Debugger, a revolutionary tool that provides developers with visibility and data access to their running applications.

Introducing Dynatrace Live Debugger

Dynatrace Live Debugger is a cloud-native, real-time deep observability application that gives you instant access to the code-level data you need to troubleshoot and debug quickly in any environment, from dev to production and from bare metal to Kubernetes. With a single click, developers can access the necessary and relevant data without adding new code. No more waiting for CI and redeployment and wasting days trying to reproduce issues locally. Using non-breaking breakpoints allows you to instantly see the complete state of your application, including stack trace, variable values, and more—all without stopping or breaking running code.

Dynatrace Live Debugger makes troubleshooting efficient, seamless, and non-disruptive. Developers are empowered to maintain high-quality applications, resolve issues faster, and suffer less toil.

How it works

Using Dynatrace OneAgent, Live Debugger instructs your application to immediately collect arbitrary application data—a debug-data snapshot—by adding a non-breaking breakpoint, all without stopping your application.

It’s easy as 1-2-3

1. Browse your code.
2. Set a non-breaking breakpoint.
3. Get the debug data you need.

Placing a breakpoint in the code gives you a real-time snapshot whenever the line of code is triggered. This line of code contains elements like variables, stack trace, process information, and tracing. You can limit your breakpoint per timeout value or trigger and set breakpoints per logical parameters.

Debug data from third-party and open source, too!

Debugging third-party and open source code, and even external libraries for which you don’t have the source code, can be an extremely complex task. However, with Dynatrace Live Debugger, it’s easy and seamless.

At Dynatrace, we understand your challenges when dealing with external packages—whether you’re hustling with reverse engineering, automatically fetching open source code, or playing the guessing game.

Dynatrace Live Debugger can work for closed third-party libraries, like Apache Tomcat, SpringBoot, ExpressJS, and more, even when the source code is unavailable. Dynatrace just needs the file name and the line number to collect the debug data.

The problem: Where do you place the non-breaking breakpoint when you don’t have the source code?

The solution is to focus on the stack trace to pinpoint where third-party code interacts with your code. Setting breakpoints in the stack trace allows you to observe the execution flow without needing the source code. This method allows you to collect valuable data, such as local variables and arguments, without impacting application performance or wasting precious time.

Work the way you want

There are those jokes about developers never leaving their IDEs. Well, every good joke has a pinch of truth to it.

Many observability tools cause developers to disrupt their workflow. Dynatrace
provides a powerful and flexible way to work. Get live snapshots of remote environments and debug or validate fixes directly in your favorite IDE or in the Live Debugger web app, wherever works best.

Get even more context and telemetries from Dynatrace into your IDE

Having real-time code-level data available within the IDE is only the beginning.
Imagine having all your observability-related data at your fingertips.
Soon, developers will be able to instantly access additional relevant telemetry data directly from their IDE with a single click. After getting a live snapshot from the production code, you can see all related logs, which will be delivered from the Dynatrace platform directly to your IDE or Live Debugger application.

The unified observability context that brings together the platform telemetries and non-breaking breakpoint snapshots is revolutionary. It saves time and gives developers a deep understanding of their code’s behavior, making the processes significantly more efficient and effective.

Enterprise-grade regulations for your code and operations

Getting real-time insights from your code is crucial to your development efficiency and well-being. However, that would be worthless if your code base is insecure or data privacy is breached.

• Data privacy: At Dynatrace, we take a proactive approach to data privacy. Dynatrace protects your data end-to-end; the Dynatrace platform is built and operated with strong privacy controls. Privacy configurations, such as data masking, data access control, debug data retention, or privacy rights, are available to enable you to maximize the platform’s value and meet your privacy requirements.
• Source code isolation: Live Debugger integrates with source control management systems to display the correct source code revision and provide a seamless debugging experience. Designed from the ground up, this process aims to protect source code security and follow vendor best practices provided by relevant vendors. Source code is loaded only on an engineer’s workstation, using the engineer’s privileges. Dynatrace servers never access, process, or store customer source code.
• Security and compliance: Dynatrace is highly committed to information security management. Security and privacy controls implemented in Dynatrace are designed to meet the requirements of major regulatory frameworks globally. Find the list of supported frameworks in our Trust Center.

For more information, you can look at the Live Debugger Security and Privacy whitepaper

Summary and availability

Live Debugger lets you debug your production environment, or any remote environment, like never before, right from the IDE with the level of observability insight, scale, and security that enterprises demand.

Dynatrace Live Debugger is currently in preview and will be generally available within the next 90 days.

More information on the Dynatrace Observability for Developers offering can be found in the Observability for Developers blog post and the Observability for Developers webpage.

The post Dare to debug production with Dynatrace Live Debugger appeared first on Dynatrace news.