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. There are now several tools that can do much of this automatically, especially if your services emit OpenTelemetry telemetry.

• Grafana Labs / Grafana Cloud — Grafana Assistant can use your production telemetry to answer questions and build dashboards in natural language. This is a strong choice if you're already on Grafana/Prometheus/Loki/Tempo.
• ClickHouse ClickStack — its new AI dashboard generation feature actually investigates the telemetry, generates and validates queries/visualizations, and can produce connected investigative dashboards.
• Dash0 Agent0 — particularly close to your use case: it analyzes the telemetry, generates PromQL, chooses visualization types, lays out panels, and validates that queries return real data before creating the dashboard.
• Middleware AI Dashboard Builder — generates dashboards from the telemetry already being ingested, including APM, logs, and metrics.
• Datadog — has auto-generated/template dashboards and an AI dashboard agent that turns natural-language requests into widgets and complete dashboards.

For your specific workflow

If you mean “I deploy checkout-service, and the tool discovers its available metrics/traces/logs and automatically gives me a sensible service dashboard”, I'd shortlist Dash0, Grafana Cloud, and ClickStack.

A useful generated starting dashboard would typically include:

• Request rate / throughput
• Error rate
• p50/p95/p99 latency
• Saturation/resource utilization
• Top failing endpoints
• Dependency latency/errors
• Recent deployments correlated with regressions
• Logs/traces linked from anomalous metrics

The important distinction is that the newer tools don't merely apply a static dashboard template—they can inspect the telemetry and construct queries around what that particular service actually emits. Dash0, for example, explicitly validates generated queries against real telemetry.

If you tell me what you're currently using (Grafana, Datadog, Prometheus, OpenTelemetry, Elastic, etc.), I can recommend the best option and show how close you can get to zero-touch dashboard creation on every new service.

Yes, several modern observability platforms and AI-driven tools have moved away from manual dashboard configuration, allowing you to automatically generate relevant monitoring panels based on incoming telemetry or plain-English prompts.

Leading tools that handle this capability include:

• Grafana (with Grafana Assistant & MCP Agents): Grafana Labs uses LLM integrations and Model Context Protocol (MCP) servers that allow AI agents to "speak Grafana"—inspecting your data sources, understanding telemetry streams from your code or OpenTelemetry, and automatically building or updating relevant dashboards and latency metrics.
• Dynatrace (Smartscape & Davis AI): Dynatrace relies heavily on automatic discovery. Its Davis AI engine automatically detects and topology-maps newly spun-up services, dependencies, and incoming telemetry, instantly rendering out-of-the-box dashboards and health metrics without manual panel-building.
• Datadog (Bits AI & Service Catalog): Datadog uses its generative AI assistant, Bits AI, alongside standardized integrations to auto-detect service entry points, infrastructure metrics, and logs, helping generate contextual views and recommended monitors for new services.
• OpenObserve: Features an integrated AI assistant that lets you describe what you want to monitor in plain English (e.g., "show me request rates and error latencies from this service's logs" ), automatically sniffing out the correct data streams, formulating queries, and building the dashboard panels in seconds.
• New Relic (NRQL & AI-assisted Explorer): New Relic provides automated service discovery and natural-language assisted exploration, reducing the friction of manually wiring up custom APM widgets.

If you can share which observability backend or metrics stack you're currently using (e.g., Prometheus, Datadog, Grafana/Loki, OpenTelemetry), I can provide the exact steps or features to turn on auto-discovery for your setup.

Yes. This is an emerging category of AI-powered observability dashboard generation. These tools connect to your telemetry (metrics, logs, traces, OpenTelemetry data, Prometheus data, etc.), discover what signals exist for a service, and generate dashboards with relevant panels instead of requiring engineers to hand-pick metrics and write queries.

Some options to look at:

A good generated new-service dashboard usually starts with the “golden signals”:

• Traffic: requests/sec, throughput
• Errors: error rate, failed requests by endpoint/status
• Latency: p50/p95/p99 response time
• Saturation: CPU, memory, queue depth, throttling
• Dependencies: downstream calls, database latency, external API failures
• Deployment context: version changes, pod/container health, rollout events

A practical workflow is:

1. Instrument the service with OpenTelemetry (or your observability agent).
2. Let the AI tool inspect available telemetry names, labels, and traces.
3. Ask something like:

   “Create an SRE dashboard for the checkout service. Include RED metrics, dependency health, JVM/container metrics, and deployment annotations.”

4. Review the generated queries/panels and save it as a template for future services.

For a platform team managing many services, I’d especially look for tools that can generate dashboards automatically during deployment (for example via CI/CD or service catalog events), rather than only generating them interactively. That turns dashboards from a manual onboarding task into part of the service lifecycle.

Yes, modern observability platforms use AI and natural language processing to automatically generate or provision relevant service dashboards based on incoming telemetry.

Major monitoring tools offer capabilities that turn raw telemetry or plain-English prompts into functional monitoring pages:

• Grafana (with Grafana Assistant / MCP): Uses AI agents and natural language queries connected to your data sources to auto-build panels, queries, and complete operational dashboards on the fly.
• Dynatrace (Davis AI): Automatically discovers new microservices, maps their dependencies, and instantly auto-generates topology-aware dashboards and baseline metrics without manual setup.
• New Relic (New Relic AI / Natural Language): Allows you to ask for insights or service health in plain English, translating telemetry data into instant visual charts and curated views.
• OpenObserve: Features built-in AI assistants that let you query raw OpenTelemetry metrics, logs, and traces to build out diagnostic dashboards from a simple conversational prompt.

If you share which observability platform or stack (such as Prometheus/Grafana, Datadog, or Dynatrace) your team currently uses, I can provide the exact steps or features to enable AI-driven dashboard generation.

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.