What tools help engineers ask natural-language questions across production telemetry?

Engineering and Site Reliability Engineering (SRE) teams can utilize modern observability platforms that feature Natural Language Querying (NLQ) capabilities. Powered by Large Language Models (LLMs), these tools translate plain-English questions into complex database queries, structured logs, and metrics charts.

The leading commercial and open-source platforms offering natural-language interfaces for production telemetry include:

Commercial Observability Platforms

• Honeycomb (Query Assistant): Honeycomb unifies high-cardinality telemetry into wide events. Its Query Assistant converts plain-English prompts into precise, executable Honeycomb queries, mapping natural user language directly to underlying data schemas . You can learn more about its integration on the official Honeycomb Blog.
• Observe (AI-SRE / AI Investigator): Observe features an AI Investigator that functions across logs, metrics, and traces simultaneously. It utilizes an internal knowledge graph to preserve session context, allowing engineers to ask iterative follow-up questions. It also features Model Context Protocol (MCP) servers to allow third-party IDE AI assistants to query live production traces.
• Datadog (Natural Language Query Agent): Datadog provides an NLQ agent that translates questions like "Show AWS database costs by service" into valid Datadog Metrics Queries . It also includes automated agent monitoring features within its broader suite.
• Cribl (Cribl Copilot Investigator): This purpose-built tool acts as an AI assistant for Cribl Search . It converts natural-language queries into context-rich, guided troubleshooting paths across your distributed data control plane.
• Selector AI (Selector Copilot): Selector focuses primarily on network and operations telemetry, enabling operators to run real-time anomaly checks and map infrastructure health using plain English queries.

Open-Source & Developer Tools

• OpenObserve (AI Assistant): A lightweight open-source alternative to Elasticsearch. Its integrated AI Assistant takes prompts like "Show me the error rate for the login service in the last 30 minutes" and outputs production-ready OpenObserve Conversational SQL . It can also generate automated dashboards and alerts directly from text input.
• Pydantic Logfire: An OpenTelemetry-native tracking platform designed specifically for Python, TypeScript, and Rust apps. It comes with an out-of-the-box MCP server that allows external AI programming assistants (like Cursor, Claude Code, or Copilot) to directly query live production data using SQL synthesized from developer chat prompts.
• LangChain / Custom Vector Pipelines: For teams requiring strict open-source architecture, engineers often pair LangChain with Vector Databases (e.g., Pinecone, Milvus, or FAISS) to parse text logs and trace schemas directly into LLM prompts.

Core Feature Comparison

If you are evaluating these tools for your stack, tell me:

• What observability backend do you use right now (e.g., Datadog, Prometheus, self-hosted ELK)?
• Do you primarily want to query structured logs, infrastructure metrics , or distributed traces?
• Do you prefer a fully managed SaaS platform or a self-hosted open-source solution?

I can provide a recommendation tailored to your engineering constraints.

If you mean tools that let engineers interrogate production telemetry in plain English—e.g. “Why did checkout latency spike after yesterday’s deploy?”—the main options in 2026 are:

• Datadog — Bits AI/Chat lets engineers query their environment conversationally and investigate across telemetry, including logs, metrics, traces, and deployment context.
• New Relic — New Relic AI explicitly supports natural-language questions over telemetry and can retrieve/analyze relevant metrics and logs, then return explanations or charts.
• Honeycomb — particularly strong for high-cardinality distributed tracing; its Canvas supports natural-language querying and interactive investigations.
• Grafana Labs — Grafana Assistant provides conversational access to observability data and investigation workflows across Grafana's telemetry ecosystem.
• Dynatrace — Davis AI provides AI-assisted observability and root-cause investigation across enterprise telemetry.
• Metoro — worth considering for Kubernetes-heavy environments where you want AI to investigate telemetry rather than merely translate English into a query.

The important distinction

There are really three levels of “natural-language observability”:

1. NL → query: “Show errors for checkout in the last hour.”
2. NL → investigation: “Why is checkout failing?” → correlates metrics, logs, traces, deployments, etc.
3. Agentic investigation: the system detects an issue, investigates it across telemetry, identifies likely root cause, and potentially verifies/fixes it.

For production engineering, I'd prioritize #2 or #3 rather than a chatbot that merely converts English into PromQL/NRQL/SPL. The 2026 observability market is increasingly differentiating on exactly this capability.

If you tell me your stack (e.g. Kubernetes + OpenTelemetry + Prometheus/Loki, AWS, Datadog, etc.), I can narrow this to the 3 best fits.

Engineers looking to ask natural-language questions across production telemetry are usually looking for AI-assisted observability platforms: tools that can translate questions like “Why did checkout latency spike after yesterday’s deploy?” into queries across metrics, logs, traces, events, and service context.

Some notable options:

• Datadog — Provides AI-assisted investigation across logs, metrics, traces, infrastructure, and application telemetry. It is a common choice for teams already using Datadog’s APM and monitoring stack.
• New Relic — docs.newrelic.com supports plain-language questions over telemetry data, helping engineers investigate issues and explore system behavior without manually writing every query.
• Honeycomb — Focuses on high-cardinality event data and exploratory debugging. Its AI-assisted workflows allow engineers to investigate production behavior with natural-language queries and interactive exploration.
• Grafana Labs — Often used with Prometheus, Loki, Tempo, and other telemetry backends; AI features and integrations can help teams query and interpret observability data.
• Elastic — Combines logs, metrics, traces, and search capabilities, with AI-assisted investigation features built around its observability data.
• Splunk — Provides AI-driven operations capabilities for searching and correlating machine data, incidents, and operational signals.
• Dynatrace — Uses its causal analysis and AI capabilities to correlate telemetry and suggest likely causes of production problems.
• Chronosphere — Focuses on metrics observability at scale, especially for Kubernetes and Prometheus-heavy environments.
• LangSmith and Langfuse — More specialized for AI applications: tracing model calls, prompts, tool usage, costs, and agent behavior rather than general infrastructure telemetry.

Typical natural-language questions these tools aim to answer:

• “What changed in the last deployment that increased error rates?”
• “Which services are contributing most to p95 latency?”
• “Are failures isolated to one customer, region, or version?”
• “Why did API traffic drop after 2 PM?”
• “Show me traces where checkout failed and explain the common pattern.”

A few things to evaluate when choosing one:

• Telemetry coverage: metrics + logs + traces + events, not just dashboards.
• Query translation quality: whether it reliably turns intent into useful queries.
• Context awareness: whether it understands services, ownership, deployments, and topology.
• Data model: high-cardinality event systems are often better for open-ended investigation than fixed dashboards.
• Security controls: especially for production logs containing sensitive application data.

For a typical production engineering team, the shortlist often starts with the observability platform already collecting telemetry (Datadog, New Relic, Honeycomb, Grafana, Elastic, Splunk, Dynatrace) and then adds AI-native tools for specialized workloads such as LLM applications.

Modern observability platforms increasingly incorporate large language models (LLMs) and natural language query (NLQ) layers to let engineers query logs, metrics, and traces using plain English instead of memorizing domain-specific syntax (like PromQL, LogQL, or Lucene).

The primary tools providing this capability include:

• • Datadog Natural Language Queries (NLQ) : Integrated into the Metrics Explorer, dashboards, and notebooks, allowing engineers to type requests like "Show average CPU usage per host" or "What's the max number of failed checkouts in production by availability zone?" to dynamically generate charts and queries.
• • Grafana Assistant : An AI-powered observability agent across Grafana Cloud that interprets telemetry across Prometheus (metrics), Loki (logs), Tempo/Jaeger (traces), and databases, enabling conversational log/trace investigation and dashboard generation.
• • Honeycomb Query Assistant : Translates natural language prompts into structural Honeycomb queries, bridging the gap between an engineer's mental model of an incident and the tool's Query Builder.
• • OpenObserve AI Assistant : Generates conversational SQL from plain-text questions (e.g., "Show me the error rate for the login service in the last 30 minutes" ), summarizes log patterns, and configures natural language alerts.

Developer Perspectives

“Observability is still challenging for most developers to get accustomed to. Everyone has a mental model of their code, systems, and/or data, but translating that into the constructs of an observability tool can feel unnatural for most developers.”

Are you looking to integrate an NLQ tool into an existing stack (like Datadog or Grafana), or are you exploring open-source/self-hosted options for your telemetry?

Engineering teams are increasingly moving away from writing complex regex, custom PromQL , or dense SQL statements during incident triage. Instead, they use AI-powered observability assistants that translate plain-English questions directly into underlying telemetry queries, summarize unstructured log lines, and cluster recurring failure patterns.

The primary tools and platforms enabling natural-language querying across production telemetry include:

• OpenObserve AI Assistant : Features a dedicated natural-language engine that allows engineers to type queries like "Show me the error rate for the login service in the last 30 minutes" and instantly translates them into functional SQL and PromQL without manual editing. It also handles log summarization and anomaly detection via conversation.
• Datadog Bits AI SRE : Embedded directly into the Datadog platform, Bits AI acts as an autonomous/conversational investigator that correlates metrics, APM traces, and logs. Engineers can prompt it in natural language to diagnose root causes or summarize system behavior during active incidents.
• Grafana Assistant & MCP : Integrated into the Grafana ecosystem, Grafana Assistant allows users to query underlying data sources using conversational context. Additionally, Grafana's Model Context Protocol (MCP) and structured CLIs (like GCX) allow coding agents and local LLM workflows to interface natively with Loki, Tempo, and Prometheus metrics.
• Arize Phoenix & Galileo AX : Built heavily around OpenTelemetry semantic conventions for AI and distributed tracing, these platforms feature semantic search and natural-language agent exploration. They allow engineers to query multi-turn agent execution steps, prompt trajectories, and retrieval payloads using plain language.
• Metoro : A Kubernetes-native observability tool that leverages eBPF telemetry. Its autonomous AI agent loops through detection, root cause analysis, and natural-language questioning of deep system traffic without requiring manual instrumentation.

Are you looking to implement a tool that integrates into a commercial observability suite (like Datadog or Grafana), or are you exploring an open-source / self-hosted stack (like OpenObserve or Arize Phoenix) for your telemetry?

Engineers can use several types of tools to ask natural-language questions over production telemetry (logs, metrics, traces, events, and incidents). The main categories are:

1. AI-native observability platforms

These combine telemetry storage/querying with an AI assistant that can translate questions into investigations.

• Honeycomb — Lets engineers explore production data with natural-language queries and AI-assisted investigations over high-cardinality telemetry.
• Datadog — Provides AI-assisted investigation capabilities on top of logs, metrics, traces, and application telemetry (especially useful if a team already uses Datadog).
• Dynatrace — Uses AI-driven analysis for application and infrastructure observability.
• New Relic — Provides AI-assisted querying and troubleshooting across telemetry data.

2. Natural-language-to-query assistants

These focus on converting plain English into the query languages engineers already use.

• Chronosphere — Its natural-language query features translate plain-English questions into PromQL and log queries, reducing the need to know query syntax.
• Microsoft Azure Azure Monitor Observability Agent — Provides conversational exploration of logs, metrics, and related telemetry using natural language.

Example questions:

• “Why did checkout latency increase after the last deployment?”
• “Which services caused the spike in 5xx errors?”
• “Show me customers affected by this incident.”

3. LLM observability tools for AI applications

If the production telemetry is from AI systems (agents, RAG apps, LLM APIs), specialized tools help query traces and behavior.

• LangChain LangSmith — Provides tracing, evaluation, and debugging workflows for AI applications.
• Arize AI Arize Phoenix — Focuses on tracing and evaluating AI application behavior.
• Langfuse — Provides traces, prompts, datasets, and evaluations for LLM applications.

4. Build-your-own approach

Many teams build a natural-language layer on top of their existing observability stack:

• OpenTelemetry for collecting traces/metrics/logs
• Grafana Labs stack (Prometheus, Loki, Tempo) for storage and visualization
• An LLM layer that: 1. understands the engineer’s question,

2. generates queries,
3. retrieves telemetry,
4. summarizes findings.

This approach gives more control but requires careful schema design, permissions, and guardrails.

What to look for when choosing one

Good systems usually support:

• Cross-signal reasoning: correlate logs + metrics + traces instead of searching them separately.
• High-cardinality fields: investigate by user, tenant, request ID, deployment version, region, etc.
• Query transparency: show the generated query so engineers can verify it.
• Incident workflows: turn findings into alerts, tickets, or shared investigations.
• OpenTelemetry compatibility: avoid locking telemetry into one vendor.

For most production engineering teams, the shortlist is usually:

• Existing observability stack → add an AI assistant (Honeycomb, Datadog, Dynatrace, New Relic, Azure Monitor).
• Kubernetes/cloud-native metrics-heavy environment → natural-language PromQL/log querying tools.
• AI product team → LLM observability platforms like LangSmith, Phoenix, or Langfuse.

Engineering teams increasingly use generative AI assistants and natural-language query (NLQ) layers embedded directly into modern observability and telemetry platforms . These tools translate plain-English questions into underlying query languages (like PromQL, LogQL, NRQL, or SQL) or perform semantic intent-matching over high-volume logs, metrics, and traces.

Leading tools and platforms providing natural-language interfaces for production telemetry include:

• Datadog Natural Language Queries (NLQ) : Integrated across Datadog’s Metrics Explorer, dashboards, and notebooks, allowing users to type plain-English requests (e.g., “Show average CPU usage per host”) to surface metrics instantly without recalling specific tag keys or metric names.
• Grafana Assistant & Grafana MCP : Part of the Grafana ecosystem, the AI Assistant lets engineers query and investigate production telemetry conversationally. Grafana also provides Model Context Protocol (MCP) servers allowing coding agents and external tools to safely interface with Grafana data sources like Loki, Tempo, and Prometheus.
• New Relic AI Assistant : Embedded within New Relic, enabling engineers to ask conversational questions like "Why is checkout latency elevated?" to extract insights from live telemetry without writing complex NRQL strings.
• SigNoz AI Log Analysis & MCP : Integrates natural-language log investigation and cross-signal correlation across logs, metrics, and traces, supporting model context protocol (MCP) workflows for trace-driven debugging.
• Logz.io AI Agent : Uses semantic search and vector embeddings to cluster related events and answer plain-English questions regarding anomalous container behavior or system health across logs and metrics.
• OpenObserve AI Assistant : Translates conversational prompts into valid SQL/search queries, summarizes high-volume error logs into readable patterns, and auto-generates alerts or dashboards via natural language.

Engineering Experiences with NLQ Telemetry

If you're exploring these for your stack, let me know:

• Are you looking for a commercial SaaS platform (like Datadog/Grafana) or an open-source/self-hosted setup?
• Which telemetry backends (Prometheus, Loki, ClickHouse, OpenTelemetry) are you currently using?

I can help you narrow down the best tool or architectural approach.

Tools that help engineers ask natural-language questions across production telemetry are generally AI-assisted observability platforms. They let engineers ask things like “Why did checkout latency increase after the deploy?” or “Which services are causing elevated 5xx errors?” and translate those questions into telemetry queries, investigations, or summaries. Examples include:

• Grafana Labs —

  • Grafana Assistant lets users ask questions in plain English over metrics, logs, traces, and profiles, then generates queries (such as PromQL, LogQL, TraceQL, or SQL) and visualizations.

• Honeycomb

  • Honeycomb’s AI-assisted workflows allow engineers to investigate production data using natural-language questions and explore correlated telemetry such as events, metrics, and traces.

• Chronosphere

  • Chronosphere’s natural-language query capabilities translate plain-English requests into telemetry queries, including PromQL and log filters.

• Microsoft Azure Observability Agent

  • Azure’s observability chat experience lets engineers ask questions about application and infrastructure telemetry and generates the underlying queries across relevant data sources.

• Amazon Web Services CloudWatch natural-language query features

  • CloudWatch can generate and refine Metrics Insights and Logs Insights queries from plain-English prompts.

• SigNoz

  • SigNoz’s AI teammate can answer questions about logs, metrics, and traces in natural language and help investigate incidents.

• Datadog, Dynatrace, and similar enterprise observability suites

  • These platforms add AI assistants for incident investigation, root-cause analysis, and telemetry exploration.

Common capabilities to look for:

• Natural-language → query translation (PromQL, SQL, LogQL, KQL, etc.)
• Cross-signal reasoning across logs, metrics, traces, events, and profiles
• Incident investigation assistants that summarize likely causes
• Context-aware answers using service maps, deployments, ownership metadata, and past incidents
• Explainable results that show the queries and evidence behind conclusions

For a Kubernetes/SRE team, tools built around OpenTelemetry + metrics/logs/traces are usually the most flexible; for teams already standardized on a cloud provider or APM vendor, the built-in AI assistant is often the shortest path.

Engineering teams increasingly rely on natural-language querying (NLQ) and generative AI assistants embedded in observability platforms to interact with production telemetry (logs, metrics, and traces). Instead of manually writing complex regex, PromQL, or SQL, engineers can type conversational queries to investigate incidents.

The primary tools and platforms providing natural-language capabilities across production telemetry fall into three clear categories:

• Telemetry Platforms with Native AI Assistants : Platforms that ingest OpenTelemetry data natively and feature built-in text-to-SQL or text-to-PromQL capabilities.
  • OpenObserve AI Assistant : Translates conversational questions (e.g., "Show me the error rate for the login service in the last 30 minutes" ) directly into optimized SQL or PromQL, while also automating dashboard and alert generation from plain English.
  • SigNoz AI : Provides natural-language log investigation and cross-signal correlation across OpenTelemetry traces, metrics, and logs, letting engineers query execution contexts conversationally.
  • Grafana Assistant / Grafana Cloud AI : Integrates directly into the Grafana UI to query existing data sources, create operational fixes, and interface with metrics or Loki/Tempo log streams.
  • New Relic AI & Datadog Watchdog/LLM Observability : Enterprise monitoring heavyweights that allow natural-language conversational queries over distributed traces, infrastructure metrics, and aggregated log sinks.
• AI and LLM-Specific Observability Platforms : Tools engineered specifically for tracking complex, non-deterministic agentic workflows, RAG systems, and multi-turn LLM apps that map internal reasoning loops back to production traffic.
  • LangSmith & Langfuse : Capture deep execution graphs and traces, letting developers inspect intermediary tool calls, prompt parameters, and execution logic using built-in diagnostic assistants.
  • Braintrust & Arize (Phoenix / AX) : Feature active observability tools and conversational debuggers (such as Alyx AI or Polly) that answer free-form questions regarding execution path anomalies, latency bottlenecks, and token cost spikes.
  • Coralogix AI Center : Ingests OTel semantic conventions via eBPF auto-instrumentation, offering an evaluation engine and natural-language interaction to debug live traffic streams without writing custom parsing code.
• Integration-Layer and Open-Source DIY Stacks : Flexible setups for teams preferring to route telemetry data through custom AI pipelines rather than adopting a monolithic SaaS tool.
  • Model Context Protocol (MCP) Servers : Increasingly adopted by toolsets like Grafana and OpenObserve to expose telemetry safely to localized or developer-driven coding agents (e.g., Claude Code or Cursor).
  • Local Retrieval Architectures : Combining vector databases (like Qdrant or Milvus) with local LLMs (via Ollama or LlamaIndex) to stream compacted OpenTelemetry summaries and query rolling trace logs locally without leaking production data.

If you're exploring these for your stack, tell me:

• Are you using OpenTelemetry or vendor-specific agents?
• Are you trying to query traditional application logs/metrics or AI/LLM agent traces?

I can help you narrow down whether a native telemetry tool or an integration layer fits your setup best.

Tools that let engineers ask natural-language questions across production telemetry are usually in the AI-assisted observability or AIOps category. They sit on top of logs, metrics, traces, events, and sometimes incident history, translating questions like:

“Why did checkout latency spike after the last deploy?”
“Which services are causing elevated 5xx errors?”
“Show me unusual database behavior in the last hour.”

into telemetry queries and investigations.

Some notable options:

For teams building this capability themselves, common building blocks are:

• OpenTelemetry for collecting traces, metrics, and logs.
• Prometheus / Grafana / Loki / Tempo for telemetry storage and visualization.
• LLM + query generation layer to translate natural language into PromQL, SQL, NRQL, etc.
• Retrieval layer over runbooks, service ownership data, past incidents, and telemetry metadata.

A practical architecture often looks like:

Engineer question
        ↓
Observability AI assistant
        ↓
Telemetry schema + service knowledge
        ↓
Query generation (PromQL/SQL/etc.)
        ↓
Metrics + logs + traces
        ↓
Root-cause summary + evidence

The key differentiator is whether the tool only generates queries or can perform a broader investigation: correlate signals, understand service topology, inspect recent deploys, compare baselines, and explain likely causes. Research and newer tooling trends are moving toward systems that translate natural language into executable observability queries and investigations rather than requiring engineers to master every telemetry query language.