GrafanaChatGPT Search85%Google AI Mode74%ChatGPT SearchGoogle AI Mode
DatadogChatGPT Search79%Google AI Mode79%ChatGPT SearchGoogle AI Mode
DynatraceChatGPT Search31%Google AI Mode72%ChatGPT SearchGoogle AI Mode
New RelicChatGPT Search48%Google AI Mode51%ChatGPT SearchGoogle AI Mode
PrometheusChatGPT Search46%Google AI Mode32%ChatGPT SearchGoogle AI Mode
Dash0ChatGPT Search54%Google AI Mode2%ChatGPT SearchGoogle AI Mode
Questions and answers
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 several advanced monitoring and observability tools that leverage AI to automatically build dashboards directly from your telemetry data. Rather than requiring manual layout and query configuration, these modern platforms analyze incoming metrics, logs, and traces—or take plain-English prompts—to generate relevant dashboards in seconds.
How it works: You provide a natural language prompt (e.g., "Create a dashboard for my Nginx logs to see request rate and latency").
Automation: The AI automatically scans your incoming telemetry streams, identifies the key metric and log fields, writes the correct validation queries, and instantly builds production-ready visualization panels. It has full infrastructure context, allowing it to dynamically create tabbed dashboard views for complex environments like Kubernetes clusters (CPU, memory, disk usage).[](https://www.youtube.com/watch?v=tsm2aDoDxv8&vl=en-US&t=67)
We are looking for a way to automate dashboard creation for new services. Is there an AI-driven solution that generates relevant monitoring views directly from telemetry?
Other topics in AI Observability and Incident Management
2. Grafana & Prometheus (Model Context Protocol / AI Agents)
Grafana Labs utilizes the open-standard Model Context Protocol (MCP) to allow external AI coding agents and LLMs to interact directly with your observability environment.[](https://www.youtube.com/watch?v=qipWEGaTWsg)
Automation: It uses AI to automatically discover operational assets and synchronize dashboards, monitors, and Service Level Objectives (SLOs) natively with rapid code releases. This removes the manual platform configuration toil whenever a new microservice is deployed.[](https://www.paloaltonetworks.com/cortex/xcor/ai-driven-observability)
Summary of Approaches
Tool / Platform
Primary Mechanism
Best Fit For
OpenObserve
Native Natural Language AI Assistant
Quick text-to-dashboard creation from raw logs and infrastructure metrics.
Grafana (via MCP)
Agentic AI Integration & Tool-Calling
Teams wanting an autonomous AI engineer to manage existing Grafana setups.
Cortex XCOR
Continuous Telemetry Sync
Large enterprise microservice architectures with frequent CI/CD deployments.
To recommend the best route, tell me:
What monitoring stack (e.g., Prometheus, Datadog, Grafana, ELK) do you currently use?
What cloud or infrastructure platform (e.g., Kubernetes, AWS, bare metal) does the new service run on?
Is your telemetry natively instrumented via OpenTelemetry?
Yes. AI-powered observability tools can generate monitoring dashboards from real service telemetry, reducing the work of finding metrics, writing queries, and assembling charts manually.
The key distinction is whether you want AI to help you create a dashboard on demand or automatically discover a newly deployed service and provide a useful monitoring view with minimal configuration.
Tools worth evaluating
1. Dash0 Agent0
(Best fit to investigate first)
Designed for telemetry-driven dashboard creation. It can generate panels, queries, visualizations, and layouts based on actual telemetry, with checks that queries return data. Particularly relevant if you use OpenTelemetry and Prometheus-style metrics.
A strong option if your team already uses Grafana. You can describe a dashboard in natural language, generate queries and panels, and work with live telemetry. Grafana also offers application observability that automatically discovers services and surfaces standard request-rate, error-rate, and latency metrics.
Worth considering if you collect logs, metrics, and traces in ClickHouse-based observability. Its AI dashboard-generation capabilities let you describe the view you want rather than manually assembling every visualization. Check that its ingestion and query model fit your existing stack.
Start by testing Dash0 Agent0 if you're looking for service-specific dashboards derived from actual telemetry. Its documented workflow generates PromQL queries, chooses charts, checks that queries return data, and produces a dashboard you can review and save. It can also generate Terraform configuration for version-controlled dashboards.
A useful initial dashboard would include:
Traffic: requests per second and throughput by endpoint.
Errors: error rate, status codes, and failure trends.
Latency: p50, p95, and p99 response times.
Resources: CPU, memory, and saturation.
Dependencies: database latency, downstream failures, and connection-pool health.
One caveat: AI dashboard creation doesn't necessarily mean a dashboard will be provisioned automatically whenever a new service appears. Confirm whether the product supports your desired onboarding trigger and unattended creation workflow.
One question to narrow this down: What monitoring stack do you currently use?
Yes, modern observability platforms use artificial intelligence and natural language processing to automatically discover services, map telemetry, and generate or populate monitoring dashboards. [](https://newrelic.com/platform)
When or as new microservices, infrastructure nodes, or applications begin emitting telemetry via open standards like OpenTelemetry , major platforms leverage built-in AI engines to bypass manual dashboard creation by instantly provisioning relevant charts, key performance indicators (KPIs), and topology maps.
Leading Platforms with AI-Driven Dashboard & Telemetry Generation
Dynatrace : Utilizes its causal AI engine, Davis , alongside the Grail data lakehouse to automatically discover new services, ingest their telemetry, and dynamically synthesize out-of-the-box topology maps, dependency graphs, and contextual dashboards without requiring manual widget configuration.
New Relic : Features natural language assistant capabilities and grounded AI agents that can query telemetry data on the fly, interpret newly integrated service metrics, and autonomously suggest or generate visualizations and alert coverage based on how the new application behaves.[](https://newrelic.com/platform)
Datadog : Offers automated service discovery and machine learning-driven integrations that instantly build out standardized dashboard views (such as golden signals—latency, traffic, errors, and saturation) the moment a new service or container starts reporting metrics, logs, or traces.
Elastic Observability : Combines machine learning anomaly detection with pre-built OpenTelemetry integrations to automatically map newly instrumented services and surface operational health views instantly.[](https://www.elastic.co/observability)
Yes. As of October 2026, several observability platforms use AI to reduce the work required to build monitoring dashboards for new services. The key distinction is between tools that generate a dashboard from a natural-language request and existing telemetry and tools that automatically discover services, identify relevant signals, and provide prebuilt monitoring views.
For your specific use case—onboarding a new service and having AI build a useful dashboard from the telemetry it emits—Datadog Bits AI, Dynatrace, and New Relic are strong candidates to evaluate.Grafana is also worth considering, particularly for teams using Prometheus and OpenTelemetry.
Platforms worth evaluating
1. Datadog
(Strongest match for AI dashboard generation)
Datadog's Bits Chat can generate complete dashboards and individual widgets from natural-language prompts. It can select relevant metrics, traces, and logs, create visualizations, and let you refine the result conversationally.
Input: Existing Datadog telemetry plus a description of the service or monitoring goal.
Output: A dashboard with relevant charts, queries, and groupings.
Caveat: Verify how much service discovery and dashboard creation can happen automatically, without a human initiating a prompt.
Source:
2. Dynatrace
(Strong for automatic service discovery and context)
Dynatrace combines service-level observability, AI-powered analysis, and dashboards that bring together metrics, logs, traces, and events. Its dashboard experience supports natural-language analysis, ready-made templates, and AI-driven anomaly detection and forecasting.
Input: Telemetry collected across applications and infrastructure.
Output: Context-rich dashboards and AI-assisted analysis of service health and performance.
Caveat: Its documented strengths include automated discovery and contextual analysis, but these are not the same as guaranteeing a bespoke dashboard is generated for every newly discovered service.
Source:
3. New Relic
(Strong for natural-language telemetry exploration)
New Relic AI can interpret plain-language questions, query relevant telemetry, and return charts and explanations. New Relic also provides configurable dashboards and a unified telemetry data platform.
Input: Metrics, logs, traces, events, and entity context.
Output: AI-generated charts and answers, alongside customizable dashboards.
Caveat: The documented AI chart-generation workflow does not by itself establish that every new service automatically receives a complete, persistent dashboard.
Grafana offers AI-assisted investigations and tooling for working with observability data. Its AI capabilities include Sift for investigating metrics, logs, and traces, as well as generative AI features for dashboard metadata.
Input: Data sources such as Prometheus, Loki, and other supported telemetry systems.
Output: AI-assisted investigation, anomaly analysis, and dashboard-related automation.
Caveat: I found less evidence that its standard offering automatically generates a complete, service-specific monitoring dashboard solely from newly arriving telemetry.
Source:
Which platform best matches your exact requirement?
The most important distinction is how much happens automatically, without an engineer having to ask the AI to build something.
Capability
Best candidate to investigate
Generate a dashboard from a natural-language prompt and existing telemetry
Datadog Bits Chat
Discover services and provide contextual monitoring views
Dynatrace
Query telemetry conversationally and generate charts
New Relic AI
Build a customizable solution around open telemetry data
Grafana Cloud
Automatically compute service RED metrics and generate service maps
OpenSearch Observability Stack
One particularly relevant development is Datadog's Bits Agent Builder, which can generate service-specific dashboards and runbooks and help identify services with gaps in dashboard or alerting coverage. That brings it closer to automating observability onboarding, although the extent of fully autonomous dashboard creation should be validated in a proof of concept.
What I would test in a proof of concept
Imagine a newly deployed microservice starts emitting OpenTelemetry metrics, logs, and traces. Ideally, the platform would:
Detect the new service and identify its dependencies.
Infer relevant monitoring signals from its telemetry, including request rate, error rate, latency percentiles, saturation, and dependency failures.
Generate a persistent dashboard with useful visualizations and service-specific filters.
Recommend or create alerts and SLOs based on service behavior and team policies.
Identify missing instrumentation and distinguish unavailable signals from healthy signals.
Update the dashboard as endpoints, dependencies, and telemetry evolve.
The last two capabilities are particularly important: an AI-generated dashboard is not necessarily a continuously maintained monitoring configuration.
My recommendation: Start by evaluating Datadog Bits Chat and Bits Agent Builder for AI-driven dashboard generation, and Dynatrace for service discovery and contextual observability. Compare them against your desired level of automation rather than just the quality of their AI chat interfaces.
One question that would help narrow this down: Do you want dashboards generated automatically as soon as a new service emits telemetry, with no human prompt, or is it acceptable for an engineer or an automated agent to trigger dashboard generation with a prompt? That distinction changes which products and architectures are the best fit.
