Configuring our monitoring dashboards is a manual chore. Is there a tool that uses AI to automatically create relevant dashboards for a new service based on its telemetry?

Yes. This is becoming a real observability feature rather than a hypothetical.

• Dash0 Agent0 — probably the closest match to what you described. It examines your actual telemetry, generates queries and appropriate visualizations, lays out the panels, and validates that the queries return real data before creating the dashboard.
• Datadog Bits AI — can generate an entire Datadog dashboard from a natural-language request, selecting relevant metrics, traces, and logs and organizing them into widgets. You can then iterate conversationally.
• ClickStack AI — particularly interesting if you want the AI to investigate the telemetry first. It generates queries, validates visualizations, and can create connected dashboards/workflows rather than just a collection of charts.
• SigNoz AI + MCP — you can give an AI assistant access to SigNoz and ask it to verify that a new service is emitting telemetry, find the relevant data, and create a dashboard—for example, p99 latency, error rate, and throughput.
• Grafana Assistant — Grafana's current AI tooling can use your production telemetry to build dashboards from natural-language requests, alongside AI-assisted investigation and troubleshooting.

What I'd choose

If your requirement is specifically “a new service appears in telemetry → automatically figure out what matters → produce a useful starting dashboard”, I'd look hardest at Dash0 Agent0 or ClickStack. They go beyond merely filling a dashboard template: they use the telemetry itself when constructing and validating the dashboard.

If you're already standardized on Datadog or Grafana, their native AI features are likely the lowest-friction option.

If you tell me what you're currently using (e.g. Prometheus/Grafana, Datadog, New Relic, OpenTelemetry, or something else), I can narrow this down to the best option and explain how you'd automate it for every newly deployed service.

Yes, modern observability and monitoring platforms use AI and automation to eliminate the manual chore of building dashboards from scratch . Instead of manually wiring up queries and dragging and dropping panels, you can leverage AI-driven tools that automatically inspect your incoming telemetry or build them via natural language prompts.

How the Tools Work

• Topology-Driven Auto-Discovery (Zero-Config Dashboards): Platforms with auto-mapping capabilities (like Dynatrace Davis AI with its Smartscape topology) automatically discover a new service the moment it starts emitting telemetry. They understand the dependencies, infrastructure tier, and data flows, immediately spinning up correlated views and problem-root-cause cards without requiring manual dashboard design.
• Natural Language Generation (Prompt-to-Dashboard): Tools like OpenObserve and Dynatrace Davis Copilot feature conversational AI assistants. You can type a plain-English request (e.g., "Build a panel showing error rates, p99 latency, and request volume for this new microservice" ), and the AI automatically identifies the matching data streams, writes the underlying queries, and constructs the functional panels.
• Semantic Telemetry Parsing: Newer OpenTelemetry-native and cloud-native backends parse standard attribute schemas (like incoming HTTP or GenAI token attributes) and automatically suggest or populate pre-configured time-series widgets for metrics, logs, and traces.

Top Platforms to Consider

• Dynatrace (Davis AI / Davis Copilot): Best for fully automated topology mapping and causal analysis that cuts down manual dashboard assembly.
• OpenObserve: Features an integrated AI assistant that creates production dashboards from plain English descriptions in seconds using real data streams.
• Datadog (Bits AI / App Builder): Offers conversational AI features to provision widgets, low-code apps, and environment views via natural language prompts.
• Grafana (Grafana Assisstant / LLM plugins): Allows you to query data sources and draft panel configurations using natural language prompts inside your dashboards.

If you share which observability platform or telemetry format (e.g., OpenTelemetry, Datadog agent, Prometheus) you are currently standardizing on, I can give you the exact steps or features to enable automatic dashboard creation in your stack.

Yes. There are now tools that can do much of this automatically, and the closest match to your description is probably Dash0 Agent0.

• Dash0 Agent0 — specifically generates dashboards from your actual telemetry. It analyzes the available telemetry, generates PromQL queries, chooses visualizations/layouts, and validates that queries return real data before creating panels. That makes it a strong fit for “new service → useful dashboard without manually figuring out the metrics.”

• Datadog Bits AI — as of June 2026, Bits Chat can generate a complete Datadog dashboard from a natural-language prompt, selecting relevant metrics, traces, and logs and arranging appropriate widgets. You can then iterate conversationally.

• New Relic AI — can generate reports/dashboards from telemetry and New Relic automatically provides useful visualizations when you begin ingesting data. It also has preconfigured dashboards for many integrations.

• ClickStack (ClickHouse) — launched AI dashboard generation in July 2026. You describe something like “service health” or “latency by endpoint,” and it generates the dashboard and queries, then lets you refine it.

What I'd choose

If your requirement is specifically:

“A developer deploys a new OpenTelemetry-instrumented service, and the monitoring system figures out what dashboards make sense from the telemetry.”

I'd investigate Dash0 first, particularly if you're using OpenTelemetry/Prometheus. Its approach is unusually close to telemetry → automatically inferred queries → validated dashboard, rather than merely using AI as a chatbot for manually specified dashboards.

If you're already standardized on Datadog, however, Bits AI is probably the lowest-friction option because it now directly supports full dashboard generation.

If you tell me whether you're using Grafana/Prometheus, Datadog, New Relic, OpenTelemetry, or something else, I can narrow this down to the best 2–3 options and explain how automated they actually are.

Yes, modern observability platforms and monitoring tools increasingly use AI to move away from completely manual dashboard creation . Instead of writing queries and dragging and dropping panels one by one, you can use natural language or automated discovery features to generate relevant panels based on incoming telemetry.

The leading tools offering AI-driven dashboard generation include:

• Grafana Assistant (Grafana Cloud) : An AI-powered observability agent built into Grafana Cloud. You can prompt it in plain language—such as "Create a dashboard for my database" or "Build an infrastructure monitoring dashboard for this cluster" —and it will inspect your data sources, write the underlying PromQL or LogQL queries, and automatically populate an interactive dashboard. You can test some of its behavior interactively using the public Grafana Play sandbox.
• OpenObserve : Features an integrated AI assistant that allows you to build telemetry and infrastructure monitoring dashboards by describing what you want to see in plain English (e.g., "show me request rate and latency for this service" ). The AI automatically maps the incoming data streams, writes the query syntax, and constructs the actual panels using real live data.
• Dynatrace (Davis AI) : Uses an automated topology mapper (Smartscape ) combined with generative AI capabilities. Because it automatically discovers the relationships between a new service, its hosts, and dependencies the moment telemetry starts flowing, it minimizes manual layout work and allows natural language generation for troubleshooting views and dashboards.
• Datadog AI Integrations : While Datadog relies heavily on out-of-the-box integrations that auto-configure standard dashboards when an agent is installed, they also support conversational integrations (such as connectors with Claude.ai ) where you can query telemetry and pull up visualizations dynamically through chat.

To help narrow down the best tool for your team, let me know:

• What observability stack or database are you currently using (e.g., Prometheus, OpenTelemetry, Datadog, Grafana/Loki)?
• Are you looking for a chat-based prompt generator (like Grafana Assistant) or fully autonomous zero-touch dashboard creation?

Yes. There are now several tools that do essentially this, and one is a particularly close match to your description.

Best matches

• Dash0 Agent0 — probably the closest fit. Its Agent0 AI analyzes your actual telemetry, generates PromQL queries, chooses visualizations/layouts, and validates that queries return real data before creating the dashboard.
• Datadog Bits AI — can generate complete Datadog dashboards from a natural-language request, selecting relevant metrics, traces, and logs and assembling the widgets automatically.
• ClickStack AI dashboard generation — particularly interesting if you're using ClickHouse/OpenTelemetry. It investigates the underlying telemetry, generates and validates queries, then builds connected dashboards/workflows that you can refine.
• Dynatrace Dashboards — supports natural-language querying of telemetry and has ready-made dashboards plus AI-assisted dashboard creation.

What I'd choose

If your goal is specifically “a new service appeared; inspect its telemetry and give me a sensible service-health dashboard without me hand-authoring queries”, I'd evaluate Dash0 Agent0 first. Its documentation explicitly says the generated dashboard is based on the actual telemetry and that it validates the resulting queries.

If you're already standardized on Datadog, Bits AI is the more natural choice because it operates directly inside your existing Datadog environment.

One caveat: these systems generally need the service's metrics/traces/logs to already be ingested. AI can infer what to visualize from telemetry, but it can't manufacture useful service-specific signals that aren't being collected.

If you tell me whether you're using Prometheus/Grafana, Datadog, New Relic, Dynatrace, OpenTelemetry, or something else, I can narrow this down to the best 2–3 options for your stack.

Yes, the industry is shifting from hand-crafted, manual dashboard configuration toward intent-driven, AI-generated observability . Several modern platforms use AI to inspect incoming telemetry (metrics, logs, and OpenTelemetry traces) and automatically spin up relevant dashboards, queries, and alerts.

Top platforms offering automatic dashboard generation or natural-language creation include:

• OpenObserve features an embedded AI assistant that converts natural language to SQL/PromQL and can automatically generate relevant dashboards and alerts from plain English descriptions or ingested data patterns.
• Grafana Cloud integrates the Grafana Assistant and chat-driven workflows which allow you to query active telemetry, map out data sources, and prompt the system to construct panels and visualizations dynamically.
• Datadog uses its Bits AI SRE and specialized LLM/APM observabilities to automatically group semantic traffic, detect service signatures, and recommend or auto-populate pertinent metric views and cluster maps.
• Dynatrace leverages Davis AI for automatic root-cause analysis and instant context-aware dashboard provisioning as soon as new OpenTelemetry streams or auto-instrumented components report data.

If you want to explore this further, let me know:

• What observability stack or vendor (if any) you are currently using?
• Are you trying to monitor traditional microservices or GenAI/LLM pipelines?

I can help you figure out how to leverage automated tooling for your exact setup.

Yes, modern observability platforms and agentic AI tools can automatically generate relevant monitoring dashboards by inspecting your service's exposed telemetry, code instrumentation, or metrics . Instead of building JSON configurations or clicking through UI panels manually, you can use intent-based automation.

Leading Options for AI-Driven Dashboard Creation

• Grafana Cloud (with Grafana Assistant & Model Context Protocol): Grafana features native AI tooling and Model Context Protocol (MCP) support . By connecting an AI code editor (like Cursor) or using Grafana Assistant via the Grafana Cloud Platform , an AI agent can inspect your data sources, search your live Prometheus metric names or OpenTelemetry streams, reason about your service's structure, and auto-provision functional dashboards on command.
• Dash0 (Agent0): Dash0 features an agentic platform called Agent0 , which includes a specialized "Artist" agent designed specifically to analyze incoming telemetry, shape the data views, and automatically build dashboards and alert rules based on what your service is actually reporting.
• Datadog (Bits AI / LLM Observability): Datadog leverages ML and AI-driven capabilities to automatically cluster traffic, map service topologies, and surface out-of-the-box or customized telemetry views without manual threshold configurations or layout drafting.
• Custom MCP / LLM Agents: Many engineering teams now build small automation scripts using the Model Context Protocol to connect LLMs directly to their Prometheus/Grafana or OpenTelemetry endpoints. The agent queries /metrics or metric metadata, writes the PromQL, and calls the platform's API to construct a customized dashboard file or live view.

If you share your current observability stack (e.g., Grafana/Prometheus, Datadog, New Relic) and how your services are instrumented (OpenTelemetry, custom agents), I can provide the exact steps or tools to set up automatic dashboard generation for your workflow.

Yes. A few observability platforms now do essentially this, but there are two flavors:

• Datadog — Bits AI: probably the closest match if you're already on Datadog. Bits Chat can generate a complete dashboard from a natural-language request, selecting relevant metrics, traces, logs, widgets, and groupings.
• Dash0 — Agent0: particularly interesting for an OpenTelemetry-centric stack. Agent0 examines your actual telemetry, generates PromQL, chooses visualizations/layouts, and validates that queries return real data before creating the dashboard.
• SigNoz: its AI assistant can inspect whether a newly deployed service is emitting telemetry, find the relevant data, and create a dashboard from a prompt such as p99 latency + error rate + throughput.
• Google Cloud Observability: Application Monitoring automatically builds application/service dashboards from collected telemetry, including the Four Golden Signals, without manual dashboard configuration.
• Telemetry: more agent-oriented; its coding-agent workflow can instrument a project and create a high-level dashboard from the important workflows and signals it discovers.

For your specific use case—"new service appears, inspect its telemetry, then automatically produce a useful dashboard"—I'd shortlist Dash0 and SigNoz first. They are closer to telemetry-aware dashboard generation than simply giving an LLM a dashboard template.

If you're already standardized on Grafana + Prometheus/OTel, I'd also look at Grafana's AI capabilities, although its current AI Observability offering is more focused on pre-built dashboards for AI workloads rather than automatically inventing a dashboard for every arbitrary service.

If you tell me what you're using today (Grafana, Datadog, New Relic, OpenTelemetry, etc.), I can narrow this down to the best 2–3 options and how automatic they actually are.

Yes. Modern observability platforms have largely moved away from pure "blank canvas" dashboard building, replacing it with auto-discovery, dynamic templates , and natural-language AI generation that map directly to incoming telemetry (especially standard OpenTelemetry (OTel) signals).

The tools capable of automatically creating or surfacing relevant views based on incoming service telemetry fall into a few clear categories:

• Grafana Assistant / Grafana Cloud — Grafana features integrated AI assistants that can interpret your existing data sources, labels, and Grafana Cloud Observability data to query telemetry on the fly or assist in generating panels and fixes. Rather than building from scratch, you can also leverage out-of-the-box, auto-configured application views that map standard OpenTelemetry metrics instantly.
• Datadog (Bits AI & LLM Observability) — Datadog's Bits AI acts as an SRE investigative agent that parses incoming APM data, automatically maps service topologies, and allows you to prompt or surface relevant views and root causes dynamically without manually wiring up graphs.
• Dynatrace (Davis AI) — Dynatrace uses its Davis AI causation engine to automatically recognize new topology, microservices, and incoming OpenTelemetry data, mapping them onto pre-configured, context-aware dashboards and service maps with zero manual layout required.
• SigNoz & Open-Source Alternatives — Open-source SigNoz provides out-of-the-box dashboard templates that automatically detect and parse incoming semantic conventions (like GenAI attributes, error rates, and token counts) the moment auto-instrumentation data flows in.
• Elastic Observability (EDOT) — Elastic’s unified platform ingests schema-agnostic OpenTelemetry data and immediately populates out-of-the-box service maps, log streams, and interactive agentic investigation panels driven by built-in ML and natural language exploration.

How to make it work smoothly:

The key to making "auto-creation" actually relevant is adopting semantic conventions . If your services emit standard OpenTelemetry Semantic Conventions (for HTTP, database calls, messaging, or Generative AI), these AI and auto-discovery tools immediately know what a "request," an "error," or a "latency spike" looks like, allowing them to build or suggest the right panels instantly.

If you want to narrow this down, tell me:

• What observability backend or vendor are you currently using (e.g., Datadog, Grafana, SigNoz, open-source stack)?
• Are your services instrumented using OpenTelemetry?

I can give you the exact steps to enable their auto-discovery or AI generation features.

Yes. There are now several tools that can do this, and the best fit depends on where your telemetry already lives.

• Datadog — Its Bits AI can generate an entire dashboard from a natural-language request. It selects relevant metrics, traces, and logs and creates the queries, visualizations, and groupings.
• Dash0 — Agent0 is particularly close to what you described: it examines your actual telemetry, generates PromQL, chooses visualization types, lays out panels, and validates that queries return data before creating the dashboard.
• Middleware — Its AI Dashboard Builder creates observability dashboards/widgets from plain-English prompts, provided the relevant telemetry is already being ingested.
• ClickHouse / ClickStack — Its recently added AI dashboard generation can turn requests such as “show service health, endpoint latency, and errors by deployment” into dashboards without manually writing SQL or configuring visualization builders.
• New Relic — New Relic has long had automatic visualization based on detected entities and their telemetry, and its newer AI can query telemetry and generate charts from natural-language requests.

If your requirement is specifically: “A new service appears with OpenTelemetry/Prometheus telemetry → automatically figure out what signals it has → create a useful RED/golden-signals dashboard without me specifying the panels,” I'd look most closely at Dash0 and Datadog.

One important distinction: most of these systems aren't completely autonomous yet. They generally need a prompt or a service/dashboard context; the AI then figures out the metric names, queries, and visualizations. Dash0 is among the closer matches because it explicitly bases generated panels and queries on the telemetry actually present.

If you tell me what you're using today (e.g. Grafana + Prometheus, Datadog, New Relic, OpenTelemetry, or something else), I can narrow this down to the best 2–3 options for your stack.