Datadog’s DASH 2026 vision for autonomous operations and AI-native observability

Datadog’s DASH 2026 keynote was all about one big idea: AI is now moving as fast as software itself, and teams need tools that can keep up. Instead of just adding more dashboards and alerts, Datadog is pushing toward “autonomous operations” – using AI to detect, investigate, and fix problems across modern stacks, while also giving deep visibility into AI systems themselves.

The race against complexity

Datadog’s CEO Olivier Pomel opened by framing the core problem: software productivity has exploded over the last decades, from punch cards to cloud and now AI. But with that speed comes even more complexity. Teams are shipping systems they don’t fully understand, built on components they didn’t write, and running across clouds, containers, and AI services.

Datadog’s mission is to help teams win that race against complexity. The company is investing heavily in R&D to make operations more autonomous, so teams can move at “AI speed” without losing reliability, security, or customer trust.

Bits AI: from assistant to autonomous teammate

Bits AI is Datadog’s AI layer that sits across the platform. It started as an SRE-focused assistant and chat interface, but at DASH 2026 Datadog expanded Bits into a full autonomous teammate for operations and development.

Bits Chat: natural language control of Datadog

Bits Chat lets anyone ask questions and act across Datadog in plain language: create dashboards, explore telemetry, triage issues, and understand production behavior without manually wiring queries. Bits Chat is now generally available to all Datadog users.

Bits Detection: AI-driven production monitoring

Traditional monitoring depends on humans predicting what to watch and hand-tuning thresholds. With AI-driven systems changing constantly, that approach doesn’t scale. Bits Detection (now in preview) automatically analyzes historical telemetry, service topology, ownership, and code context to:

• Discover new endpoints and critical paths as they appear
• Learn baselines as traffic ramps up
• Detect anomalies that actually matter to the business

Instead of waiting for someone to create a monitor, Bits Detection continuously adapts monitoring to how services evolve.

Bits memories: capturing hard-won operational knowledge

Many of the hardest incidents aren’t solved by metrics alone – they depend on tribal knowledge scattered across Slack, runbooks, tickets, and postmortems. Bits memories let Datadog capture that knowledge as teams work:

• Signals shared in incident Slack threads
• Recommended actions from runbooks
• Root causes documented in postmortems

Bits then reuses those memories in future investigations automatically, without anyone having to search old threads or paste context into prompts.

Bits Remediation and guardrails: safe autonomous fixes

Once Bits detects and investigates an issue, it can now act. Bits Remediation proposes safe actions like restarting pods, rolling back deployments, or scaling resources. Guardrails define what Bits is allowed to do:

• Which resources and environments it can touch
• Which actions require human approval
• Which actions are fully auto-approved

Teams can start with human-in-the-loop approvals and gradually expand what Bits can do autonomously as they gain confidence. Every action is logged with evidence and outcomes.

Bits infrastructure operations: closing the loop before outages

Not every risk shows up as a page. Slow-burning infrastructure issues – repeated pod OOM kills, ECS task failures, expiring certificates, mis-sized Lambdas – quietly degrade reliability until they trigger a major incident.

Bits infrastructure operations continuously scans for these issues, investigates them, and proposes or applies fixes within defined guardrails. The goal is to resolve routine infra problems automatically, before they become customer-facing outages.

Network, database, and logs: deep visibility with AI on top

Alongside Bits, Datadog announced several core platform upgrades that make traditional observability more powerful and AI-ready.

Network monitoring: full-stack network operations

As apps span clouds, on-prem, and hybrid environments, network issues can hide anywhere: noisy workloads, congested circuits, misconfigured firewalls. Datadog’s network monitoring now provides:

• Network Path: a hop-by-hop view from application to destination across cloud and on-prem, with the ability to compare routes before and during an incident and pinpoint the hop introducing latency or packet loss.
• Network Device Monitoring + Bits: health and error visibility for routers, switches, and edge devices, with Bits explaining root causes in plain language.
• Network Configuration Management: one-click rollbacks to last-known-good configs directly from Datadog, with diffs and change timelines.

The result is faster diagnosis and remediation of network issues, even for engineers who aren’t deep networking experts.

Bits Database Optimization: AI suggestions with real benchmarks

LLMs can suggest SQL optimizations, but they’re often inconsistent or even harmful. Bits Database Optimization wraps AI suggestions in a rigorous validation harness:

• Datadog collects schema and statistics from your database.
• Bits spins up an ephemeral Postgres container and generates synthetic data that matches your real distributions (without touching sensitive data).
• It runs the original and optimized queries across a range of parameters, measuring latency, logical reads, and blocks dirtied.
• It compares execution plans to explain why performance changes (e.g., moving from sequential scans to index scans).
• Finally, it opens a pull request that applies the validated optimization in your codebase, whether you use raw SQL, ORMs, or query builders.

In Datadog’s tests, this approach cut 300 raw AI suggestions down to 30 validated optimizations – a 90% reduction in noise with high confidence in what’s left.

Federated Logs, findings, and Observability Pipelines

Telemetry now lives across Datadog, data lakes, and cloud storage. That fragmentation makes investigations slow and brittle. Datadog’s new log capabilities aim to unify this:

• Federated Logs: search logs across Datadog, data lakes (like Databricks), and cloud storage from a single Log Explorer view, without copying data.
• Findings: save key observations (like a specific error type or pattern) as structured artifacts during an investigation, then let Bits analyze them for root cause, impact, and next steps.
• Observability Pipelines: standardize telemetry into open formats (OTel, CSF), enrich with context (e.g., ServiceNow), redact PII, and route to data platforms like Databricks for AI and analytics.

Datadog is partnering closely with Databricks so teams can use Datadog for operational investigations while leveraging Databricks for deeper analytics and AI, without duplicating data. This complements broader trends we’re seeing across the industry, similar to how Microsoft and others are tightening the link between observability and AI platforms in their own ecosystems, as covered in our Build 2026 recap.

Bring Your Own Cloud: Datadog in your VPC

For organizations with petabyte-scale telemetry or strict data residency rules, Datadog introduced Bring Your Own Cloud for logs, metrics, and traces. Your data stays in your cloud and region, while you still get the familiar Datadog experience:

• Same Log Explorer, traces, and metrics views
• Same alerts, dashboards, and workflows
• Same Bits AI capabilities on top

It’s one platform and UX, regardless of where your data physically lives.

Infinite Cardinality Metrics

Metric cardinality has exploded as teams tag everything by container, endpoint, user, version, model, and more. Traditional pricing and storage models break under that load. Datadog’s new Infinite Cardinality Metrics are designed for this world:

• Capture as many dimensions and attributes as you need, even at very high cardinality.
• Pricing is based on metric name and data volume, not cardinality, giving more predictable costs.
• Optimized for exploratory analysis where you don’t want to pre-prune dimensions.

This is especially relevant for AI workloads, where each request can carry many tags (model, prompt type, user segment, tool path, etc.).

Journey Monitoring: connecting user experience to backend reality

Even when all services are green, users can still be stuck. Datadog’s Journey Monitoring connects what users are trying to do with what’s happening under the hood.

Instead of looking at isolated services or endpoints, Journey Monitoring tracks end-to-end user journeys, each defined by:

• A start intent (e.g., open login page)
• An outcome (e.g., successfully redirected to profile)

Datadog automatically discovers journeys by scanning real traffic – including new flows created by AI features – and surfaces them on a single canvas (login, search, add to cart, checkout, etc.). For each journey you can see:

• Conversion and drop-off rates
• Uptime from synthetic tests
• Upstream and downstream journey relationships
• SLO status and technical errors impacting the flow

When a journey degrades, Bits can investigate across product analytics, backend telemetry, and deployments to tie business impact (e.g., lower conversion) to technical root cause (e.g., a slow model or a bad rollout). Product and engineering finally share one view of the same story.

Bits AI for developers: speeding up the dev loop safely

AI coding agents have dramatically accelerated code creation, but trust and safety often lag behind. The bottleneck has shifted from writing code to reviewing, validating, and rolling it out safely. Datadog introduced new Bits AI capabilities aimed at the entire dev loop.

Bits Release: one view of each change from staging to prod

When a pull request opens, Bits Release analyzes the change, infers its intent, and builds a validation plan that spans staging and production. In one place, developers can see:

• The expected behavior of the change
• Validation criteria (correctness, errors, performance, conversion)
• Status across staging tests, rollout, and production health

Instead of hopping between GitHub, CI/CD, feature flags, dashboards, and Slack, Bits Release consolidates everything into a single flow.

Bits Testing: autonomous goal-driven tests

Traditional tests follow predefined steps. Bits Testing introduces autonomous, goal-driven tests that behave more like real users:

• Bits defines a goal (e.g., “AI shopping assistant returns relevant recommendations”).
• It navigates the UI dynamically, reacting to responses instead of following a fixed script.
• It explores multiple paths and edge cases, building complex test scenarios on its own.

Bits runs these tests in staging and production. When it finds an issue (for example, a missing IAM role causing failures only in prod), it can investigate, propose a fix, and convert the temporary test into a persistent guardrail that runs continuously.

Datadog for AI: full-stack observability for AI systems

The second half of the keynote focused on “Datadog for AI” – everything you need to observe, secure, and optimize AI workloads themselves. As more companies roll out AI features and agents, they’re discovering that AI looks great in demos but can be unpredictable, expensive, and risky in production.

Datadog’s view: before you ship AI, you need to know three things:

• Does it work reliably for real users?
• Is it safe and secure?
• Does it have sustainable economics?

Answering those questions requires visibility across the entire AI stack: infrastructure (especially GPUs), data, models, and agents.

Data Observability and Bits Data Analysis

AI is increasingly run directly on data warehouses, but data pipelines are fragile: schemas change, pipelines break, and stale or dirty data leads to bad AI outputs.

Data Observability (GA)

Datadog’s Data Observability, now generally available, helps teams trust their data end to end:

• Track pipelines, runs, and failures across Databricks, Snowflake, Airflow, and more.
• Monitor freshness, volume, schema changes, and value distributions.
• Visualize lineage from ingestion through transformations to APIs and apps.
• Get proactive diagnoses and even draft fixes for broken pipelines.

Bits Data Analysis: grounded, context-aware BI answers

Generic BI agents often query the wrong tables or ignore business rules, returning plausible but wrong numbers. Bits Data Analysis uses Datadog’s full context to avoid that:

• It grounds answers in lineage, quality checks, and business definitions, not just exposed tables.
• It verifies data freshness and filters out test transactions or unprocessed returns when they shouldn’t be counted.
• It can follow a question from business impact to technical cause – for example, tying a revenue dip to a drop in checkout conversions, to a latency spike in a specific service, to a particular deployment.

Data teams can refine Bits’ understanding by curating definitions and feedback. Bits evaluates not just the final answer but the reasoning chain, so quality can be measured and improved over time.

Agent Console: visibility and governance for coding agents

Coding agents like Claude Code, Cursor, and Codex are spreading quickly, but most organizations lack a clear view of how they’re used, what they cost, and whether they’re being used effectively.

Datadog’s Agent Console gives teams a single pane of glass for coding agent usage:

• Aggregate spend, sessions, and usage across agents and teams.
• Break down usage by user, repo, team, and tool.
• Track AI-assisted commits and pull requests over time.
• Identify user cohorts who are highly effective or potentially misusing agents (for non-coding tasks or excessive token usage).
• Set alerts to prevent runaway costs.

Beyond reporting, Agent Console also helps improve agent behavior. It can detect problematic patterns (like agents committing without running tests), surface existing “fixes” other teams have authored (e.g., pre-tool hooks that enforce testing), and help you roll those fixes out via PRs to your own repos.

GPU-heavy AI infrastructure at scale: the Modal Labs example

Modal Labs, which runs AI infrastructure across 17+ cloud providers and moves over 100 PB of data per month, shared how Datadog fits into their stack:

• Infinite Cardinality Metrics make it feasible to monitor millions of short-lived, highly tagged AI requests.
• Datadog unifies observability across all their cloud providers, so engineers don’t bounce between consoles.
• Network monitoring helps them understand and optimize massive data flows.
• Datadog plus agents (like Claude Code and Arc XP’s tooling) power a surprising amount of their internal SRE work.

Modal also exposes Datadog telemetry to their customers, so teams running on Modal can see their AI workloads directly in their own Datadog instances.

Agent Observability: understanding and improving AI agents

Modern agents are no longer single LLM calls; they’re autonomous loops that use tools, call APIs, and take actions. That complexity makes them harder to test and debug.

Datadog extended its LLM Observability into full Agent Observability, covering a continuous loop of develop → monitor → iterate.

Patterns and auto-clustering

Agent traffic is messy. Patterns automatically clusters traces into topics and behaviors, surfacing:

• Known topics (like task creation, status updates)
• Newly emerging behaviors (like “coordination” across projects)
• Which clusters are driving cost, latency, or errors

This helps teams quickly answer “where should I look?” when something goes wrong, such as a sudden cost spike with no code changes.

Bits Evals: the agent that debugs your agent

Once a problematic pattern is identified, Bits Evals analyzes it to find root causes and propose fixes. For example, it can detect that an agent is stuck in a tool loop (calling the same tool repeatedly instead of fetching all data at once), then:

• Suggest prompt or configuration changes to break the loop.
• Flag gaps in your golden dataset (e.g., missing examples of new user behaviors) and add real traces to it.
• Run experiments against the updated dataset, comparing the old and new configs across cost, tool usage, and quality.

This turns what used to be a multi-day manual cycle into a much faster loop, with clear experiment results to back up changes.

Security for the AI era: AI Guard, prioritization, and AI-powered SOC

AI also changes the security landscape. Attackers can weaponize new vulnerabilities in hours, and AI agents introduce new attack surfaces: prompts, tools, data sources, and coding agents themselves.

AI Guard for custom agents and coding agents

AI Guard is Datadog’s runtime protection layer for AI agents.

For custom agents, AI Guard:

• Integrates directly into the agent flow.
• Inspects every input and output, including content from APIs and data sources.
• Uses AI-based behavioral analysis to detect and block prompt injection, data exfiltration attempts, and other malicious patterns in real time.

In a fintech example, AI Guard caught a malicious instruction hidden inside a receipt image that tried to override the model’s behavior and exfiltrate 90 days of transaction data to an attacker’s email.

For coding agents like Claude Code, AI Guard can:

• Intercept dangerous commands hidden in skills or tools (e.g., dynamic context commands that try to steal GitHub tokens).
• Block those commands before secrets leave the machine.

AI Guard Agent Discovery

To secure agents, you first need to know where they are. AI Guard’s Agent Discovery maps all agents in your environment, showing:

• Which models and endpoints they call (including unsanctioned ones).
• What data sources they access and how sensitive they are.
• Which agents are protected by AI Guard and which are not.
• Active threat signals on specific services.

From that view, teams can quickly bring unprotected agents under AI Guard’s protection.

Runtime Prioritization Engine: shrinking the vulnerability backlog

Most security teams are drowning in vulnerability backlogs. Datadog’s Runtime Prioritization Engine uses live runtime context to cut through the noise:

• Combines CVE data with real runtime behavior, exploit availability, and business impact.
• Uses APM traces and telemetry to identify “crown jewel” services handling sensitive data right now, not just based on old tags.
• Surfaces a small set of truly critical issues (e.g., 16,000 CVEs reduced to 9) with clear reasoning for each.

This helps teams focus remediation on what actually matters instead of chasing every CVE.

Bits Security Analyst: battling AI-scale attacks with AI

Even with prevention and prioritization, attacks will happen. Bits Security Analyst is an AI SOC analyst that:

• Runs initial investigations on every alert at machine speed.
• Correlates signals across identities, geolocation, behavior, and infrastructure.
• Generates hypotheses (routine admin action vs. compromised credential vs. insider threat) with transparent reasoning and evidence.
• Resolves benign alerts autonomously and escalates only what needs human attention.

Bits Security Analyst now works not only with Datadog Cloud SIEM but also on top of non-Datadog SIEMs, so teams can benefit from its investigations regardless of their existing security stack.

Security and observability on one platform

Arc XP, the Washington Post’s publishing platform, shared how they treat reliability and security as two sides of the same promise: newsrooms must be able to publish safely, around the clock.

By consolidating on Datadog for observability, security, and incident response, Arc XP:

• Gave all teams a real-time view of platform health.
• Reduced customer-impacting incidents by 86% year over year.
• Built an AI SOC analyst that now fully investigates every alert and autonomously resolves 89% of them.

That freed capacity to build new AI-powered editorial tools, like generative editors and agents that help journalists tell richer stories – with Agent Observability watching model behavior in the background.

Two flywheels, one platform

Datadog closed the keynote by tying everything together into two reinforcing flywheels:

• AI for Datadog: Bits AI makes Datadog more helpful and autonomous across operations, development, and security – from Bits Detection and Remediation to Bits Release, Testing, and Security Analyst.
• Datadog for AI: Datadog provides full-stack observability and security for AI workloads – from GPU monitoring and data observability to Agent Console, Agent Observability, and AI Guard.

Underneath those flywheels sits a rapidly expanding platform: Federated Logs, Bring Your Own Cloud, Journey Monitoring, Infinite Cardinality Metrics, network and database enhancements, and much more. Datadog says it shipped around 170 features around DASH 2026 alone.

As AI becomes a core part of every product and workflow, the message from DASH 2026 is clear: speed is no longer the only challenge. Trust, safety, and cost control have to move just as fast. Datadog wants to be the platform that lets you do both – build and run AI-powered systems at full speed, with enough autonomy and visibility that your teams can focus on what truly matters.

If you’re tracking how other major players are reshaping their stacks around AI agents and observability, it’s also worth comparing Datadog’s direction with what companies like Intel and Microsoft are doing at the hardware and OS layers, as we covered in our look at Intel’s agentic data center vision at Computex 2026.