What’s the most capable AI log summarization in observability platforms?

When looking for the most capable AI log summarization and root-cause analysis in modern observability platforms, industry capabilities are generally led by a few heavy hitters, each leaning on a slightly different architectural strength.

The top platforms for AI-driven log parsing, anomaly detection, and automated text summarization break down as follows:

1. Dynatrace (Davis AI & Grail)
   • Why it leads: Dynatrace’s deterministic and generative AI engine, Davis AI , operates on a causal data model rather than just statistical guessing. When dealing with logs, it automatically maps log patterns back to a precise topological map of your infrastructure and application services.
   • Standout feature: Its integration with the Grail data lakehouse and advanced context pipelines allows it to ingest, cluster, and instantly summarize massive volumes of high-cardinality logs without index setup, feeding precise root-cause summaries straight into incident management or developer tooling (like IDE and Cursor integrations via Model Context Protocol).
2. Datadog (Watchdog & LLM-Powered Log Analytics)
   • Why it leads: Datadog offers some of the most seamless, user-friendly natural language log interactions on the market. Powered by Watchdog (its machine learning engine) alongside integrated LLM features, it automatically baselines log behaviors and groups repetitive or exploding error logs into crisp executive-level summaries.
   • Standout feature: Zero-configuration anomaly detection. Datadog excels at surfacing a sudden spike or structural shift in log patterns and letting engineers query or summarize millions of log lines into a clean conversational timeline instantly.
3. New Relic (New Relic AI & Applied Intelligence)
   • Why it leads: New Relic provides a unified telemetry data store where logs, metrics, and traces live side-by-side. Its applied intelligence engine correlates log error streams directly with related alerts and deployments.
   • Standout feature: Context-rich incident intelligence that writes plain-language summaries of what changed in the system (e.g., tying a bad deployment git commit directly to a newly emerged cluster of stack traces in the logs).
4. Grafana Cloud (Grafana Assistant & Loki)
   • Why it leads: Best for teams deeply invested in open standards (OpenTelemetry/Prometheus/Loki). Grafana Assistant brings an LLM copilot directly into log exploration panels.
   • Standout feature: Rather than locking you into a black-box agent, it allows you to query Loki logs using natural language, auto-translating prompts into LogQL and summarizing log anomalies inline on your dashboards.

Summary Verdict

• If you want deep enterprise root-cause automation tied to a massive data graph, Dynatrace is typically rated the most structurally capable.
• If you want out-of-the-box ease of use, speed, and intuitive chat-based log summarization, Datadog sets the category standard.

To help narrow down which platform fits your environment best, tell me:

• Are you already committed to a specific telemetry stack (e.g., Datadog, OpenTelemetry/Grafana, Dynatrace)?
• What is your approximate log volume (GB/TB per day)?

If by “AI log summarization” you mean “give me a concise explanation of a noisy incident, identify the important log patterns, correlate them with other telemetry, and tell me what likely happened”, my current ranking is:

🥇 My pick: Dynatrace

Dynatrace is probably the strongest pure incident/log summarization experience right now.

The important distinction is that Dynatrace isn't merely throwing an LLM at a chunk of log text. Its Davis AI/RCA machinery can pull incident-relevant logs into the broader causal context, summarize those logs, and recommend relevant log queries/filters. Dynatrace explicitly describes this as automatically identifying the logs relevant to an incident rather than making engineers manually construct complicated filters.

That matters enormously in production because:

“Summarize these 50,000 log lines” is much less useful than “Summarize the 37 log events that explain why checkout started failing.”

Dynatrace's Grail data platform + Davis causal analysis is particularly strong at the latter.

🥈 Splunk: arguably the best AI investigation experience

Splunk has become extremely compelling with its AI Assistant in Observability Cloud.

It lets engineers investigate observability data using natural language instead of manually constructing queries, and its AI can surface patterns in logs, investigate failures, identify root causes, and explain findings.

Splunk's newer agentic approach is particularly interesting: the AI Assistant is designed not merely to summarize but to investigate → diagnose → recommend action.

So I'd distinguish them this way:

• Dynatrace: best automatic incident understanding / causal summarization
• Splunk: best interactive AI investigation of observability data

🥉 Datadog

Datadog remains one of the strongest choices if you want AI embedded across logs + metrics + traces + infrastructure rather than a specialized log-AI feature.

I'd put it slightly behind Dynatrace/Splunk specifically for deep log summarization, but ahead of most competitors for the overall operational experience.

---

What I'd test in a bake-off

Don't ask vendors to summarize a static log file. Give each platform the same real incident:

Example:

Kubernetes deployment → latency spike → 5xx errors → 200k logs → several services involved → database connection exhaustion.

Then score the AI on:

1. Signal extraction — does it ignore repetitive noise?
2. Temporal reasoning — does it establish what happened first?
3. Cross-service correlation — does it connect logs from different services?
4. Trace/metric correlation — does it use the rest of the telemetry?
5. Root-cause hypothesis — does it distinguish cause from symptoms?
6. Evidence — does every important claim point back to actual telemetry?
7. Novelty detection — does it identify the unusual log pattern rather than just summarize frequent messages?
8. Actionability — does it suggest the next query/check?
9. Hallucination resistance — does it say “I don't know” when evidence is insufficient?
10. Compression quality — can an on-call engineer understand the incident in 30 seconds?

That benchmark will produce a much more meaningful result than vendor demos.

Bottom line

For the best AI-powered log/incident summarization today: Dynatrace.

For the best conversational/agentic investigation: Splunk.

For the best broad observability platform with very strong AI layered across everything: Datadog.

And if you're evaluating this for a large-scale engineering organization, I'd pay particular attention to Dynatrace vs. Splunk rather than generic “AI log summarizer” products—the real advantage comes from having the model operate over logs + traces + metrics + topology + deployment context, not from having a better LLM summarize raw text.

If you tell me your stack (e.g. Kubernetes + OpenTelemetry + Kafka + Postgres, AWS/Azure/GCP, log volume, etc.), I can do a 2026 head-to-head of Dynatrace vs Datadog vs Splunk vs New Relic vs Elastic specifically for AI log summarization, including actual features, limitations, and pricing.

Datadog (Bits AI), Dynatrace (Davis AI), and Elastic Observability (AIOps/Elasticsearch AI) are widely considered the most capable platforms for AI log summarization, each leading through different architectural strengths.

Choosing the "most capable" platform depends on whether you prioritize conversational root-cause triage, deterministic causal AI, or deep search-driven log clustering.

Comparison of Top Platforms for AI Log Summarization

Detailed Breakdown of Capabilities

• Datadog (Bits AI): Excels at conversational context. When an alert fires, Bits AI automatically reviews log streams, aggregates stack traces, correlates them with application performance monitoring (APM) metrics, and generates a plain-English summary of what broke and where.
• Dynatrace (Davis AI): Combines machine learning with a deep topology map (Smartscape). Rather than just summarizing text lines via an LLM, Davis AI performs deterministic root-cause analysis, mapping the precise log error back to the exact code module, service, or infrastructure dependency.
• Elastic Observability: Leverages native vector search and machine learning features built directly into Elasticsearch. It excels at grouping similar log messages via clustering, suppressing repetitive noise, and highlighting structural log deviations before passing concise representations to generative AI layers.

If you want to narrow this down, let me know:

• What is your primary log volume (GB/TB per day)?
• Are you already committed to a specific cloud or search ecosystem (e.g., AWS, Azure, Elasticsearch)?

I can recommend the most cost-effective and capable option for your setup.

If by “AI log summarization” you mean “give an engineer a useful explanation of what thousands of logs mean, correlate them with the rest of the incident, and point toward root cause”, my current ranking is:

1. Datadog — strongest overall
2. Dynatrace — strongest enterprise/causal-analysis alternative
3. New Relic — strongest purpose-built log-alert summarization
4. Splunk — very strong for security + massive heterogeneous environments
5. Elastic — strongest if you want an open/search-centric architecture and control

🥇 Datadog

I’d currently give Datadog the edge for the most capable AI-driven incident/log summarization, particularly if you're evaluating the whole investigation rather than a standalone “summarize these logs” button.

Its newer Bits Investigation is an autonomous SRE agent that reasons across logs, metrics, traces, infrastructure metadata, network telemetry, monitors, and other signals. It doesn't simply dump retrieved log lines into an LLM and ask for a summary; Datadog describes its approach as focusing on causal relationships and testing hypotheses.

That's an important distinction. The best system isn't necessarily the one with the prettiest log summary—it's the one that can say:

“These 47,000 log events are mostly symptoms. The meaningful change was X, which caused Y, which produced the errors you're seeing.” Datadog also now has Bits Chat, which can search and correlate logs, metrics, traces, monitors, and documentation conversationally.

🥈 Dynatrace

Dynatrace is probably the closest competitor if causal reasoning and enterprise observability are the priority.

Davis AI can explain log content and use natural-language queries, while Dynatrace has been investing heavily in unified log/trace/metric analysis.

I'd particularly consider Dynatrace for a large enterprise where the question is:

“Can AI understand this entire distributed system rather than just summarize log text?”

That's a slightly different—and arguably more valuable—problem than pure summarization.

🥉 New Relic

Interestingly, New Relic may have the cleanest answer if you literally mean “AI log summarization.”

Its Logs Intelligence / AI Log Alert Summarization can analyze 100,000+ log entries associated with a triggering entity and produce:

• what happened / a potential cause
• key patterns and anomalies
• recommendations

It's explicitly designed to turn a log alert into an initial incident hypothesis.

So I'd distinguish:

Best literal log summarization: New Relic Best AI-powered investigation that incorporates logs: Datadog Best deep enterprise causal observability: Dynatrace

My practical scorecard

One caveat: there isn't a reliable public apples-to-apples benchmark of these vendors' AI log summarizers, so I wouldn't interpret the ranking as an objective LLM accuracy leaderboard. It's based on the capabilities vendors have actually exposed and documented, especially how much context and reasoning they provide around the logs.

If you're evaluating vendors for a real deployment, I'd test them on the same 20–50 production-like incidents rather than asking “which has the best AI?” The benchmark should measure root-cause accuracy, irrelevant-log rejection, evidence citation, time-to-answer, hallucination rate, and whether the proposed remediation is actually useful.

If you tell me whether you're comparing Datadog vs Dynatrace vs Splunk vs New Relic vs Elastic, I can also give you a much more detailed feature-by-feature AI observability comparison, including pricing/cost implications and which one I'd choose for a 10k+ server environment.

🥉 New Relic

If you mean AI that can take a pile of production logs and produce a useful incident summary (what happened, impact, likely cause, evidence, and next steps), the leaders are not identical to the “best log management” vendors. The strongest options today are roughly:

StackScout Netdata### My ranking specifically for AI log summarization

1. Dynatrace — strongest if you want the AI to explain why something happened

• Advantage: it builds a topology/dependency model and can connect symptoms across services rather than merely summarize matching log lines.
• Weakness: highest commitment to the Dynatrace ecosystem.

2. Datadog — strongest “day-to-day SRE copilot”

• Advantage: excellent context because logs are already tied to traces, infrastructure, deployments, alerts, and service ownership.
• Weakness: AI quality depends heavily on having good tagging, instrumentation, and telemetry hygiene.

3. Splunk — strongest raw log intelligence

• Advantage: decades of enterprise log search, correlation, and security workflows.
• Weakness: historically more analyst-driven; AI summaries are only as good as the queries/context feeding them.

4. Elastic — strongest if you want to build your own AI layer

• Advantage: flexible data access and customization.
• Weakness: usually requires more engineering effort.

If I were choosing by scenario

• “Our on-call engineers drown in alerts and need a summary before opening dashboards” → Datadog or Dynatrace.
• “We need the AI to find the root cause across 500 microservices” → Dynatrace.
• “We have petabytes of logs and security/compliance requirements” → Splunk.
• “We want to own the AI workflow and avoid vendor lock-in” → Elastic or Grafana/Loki stack.
• “We mainly want ‘summarize this incident and write a postmortem draft’” → almost any of the major vendors can do it; the differentiator is the context they can automatically collect.

A key distinction: LLM summarization alone is not the hard part. The best systems win because they automatically gather the right evidence: correlated traces, recent deployments, service ownership, topology, error patterns, and historical incidents.

For a modern Kubernetes/SRE environment, my shortlist would be:

1. Dynatrace for maximum autonomous investigation capability
2. Datadog for the best balance of capability and usability
3. Splunk if logs/security are the center of gravity

Datadog (Bits AI) and New Relic (New Relic AI / Genie) currently provide the most capable and deeply integrated AI log summarization features among mainstream enterprise observability platforms, combining real-time log stream clustering with contextual root-cause synthesis.

When evaluating log summarization capability, platforms differ based on how deeply they parse unstructured text, correlate it with metrics and traces, and synthesize human-readable triage steps.

Top Observability Platforms for AI Log Summarization

• Datadog (Bits AI) : Excels by automatically clustering high-volume log streams into semantic patterns, filtering out repetitive noise, and generating instant natural-language root-cause summaries directly inside incident views and dashboards.
• New Relic (New Relic AI) : Offers robust AI-powered log summarization that condenses thousands of repetitive stack traces and error lines into concise operational briefs, minimizing manual searching during outages.
• Elastic Observability : Leverages its core search dominance to deliver AI-assisted log interpretation, allowing engineers to naturally query massive aggregations and instantly summarize anomalous patterns across Elastic's stack.
• Dynatrace (Davis AI) : Uses causal AI engine Davis to deterministically pinpoint and summarize log anomalies, tying them straight into an exact topological impact map rather than just relying on generic LLM text generation.

Comparison of Capabilities

If you'd like to narrow this down, let me know:

• Are you already using one of these vendor ecosystems (like Datadog or Elastic)?
• Do you need the AI to run fully cloud-managed or support local/on-premise data boundaries?

If you mean “which observability platform currently does the best job of turning huge volumes of logs into an actionable incident explanation?”, my pick is Dynatrace, with New Relic very close behind for specifically log-centric summarization.

My 2026 ranking

Why I put Dynatrace first

The distinction is important: good log summarization isn't just “give an LLM 10,000 log lines and ask for a summary.” The strongest systems correlate logs with the rest of the observability graph.

Dynatrace's Davis AI can explain log content using natural language, generate queries/reports, and connect log-derived events to its broader problem-detection and root-cause machinery. Its current platform also correlates related events into a single Davis problem rather than treating every symptom as an independent alert.

That means the ideal output is closer to:

“Checkout latency increased because deployment X introduced connection-pool exhaustion in service Y. 83% of the errors originate from these pods, beginning 4 minutes after deployment. The relevant log pattern is …” rather than:

“There were 17,842 errors. The most common error was connection timeout.” That contextual/causal layer is what makes Dynatrace particularly compelling.

New Relic is arguably the best pure log summarizer

New Relic has made unusually explicit investment in this use case. Its AI Log Alert Summarization can analyze up to 100,000 log entries surrounding a log-based alert and produce:

• what happened
• 3–4 important findings/patterns/anomalies
• potential causes
• remediation recommendations

New Relic Documentation New Relic DocumentationIt also has a general “Summarize Logs” capability in New Relic AI, so you can ask for a natural-language interpretation of log data outside the alert workflow.

So if your question is specifically:

“I have a giant pile of logs and want the best AI-generated explanation of what they're telling me.”

I'd seriously consider New Relic #1.

The important distinction

I'd evaluate platforms on four separate dimensions:

1. Compression — Can it reduce 100K+ lines to the important events?
2. Pattern detection — Can it identify anomalies, clusters, novel errors and temporal relationships?
3. Causal context — Can it connect logs to deployments, traces, infrastructure, services and alerts?
4. Actionability — Does it produce a credible root-cause hypothesis and next steps?

On 1–2, New Relic is exceptionally strong.

On 3–4, I'd currently favor Dynatrace.

And if you already run a large Datadog estate, Datadog's advantage is that its AI investigation can reason over your existing logs + metrics + traces + infrastructure rather than requiring a separate log-analysis workflow.

Bottom line: Best overall AI-powered log/incident investigation: Dynatrace. Best dedicated AI log summarization experience: New Relic. Best if you want AI embedded across an already broad observability stack: Datadog.

If you're evaluating these for a large-scale production environment, I can also give you a much more rigorous Dynatrace vs Datadog vs New Relic vs Splunk vs Elastic comparison, including hallucination resistance, >TB/day log workloads, root-cause quality, query generation, cost, and how good each is at summarizing noisy Kubernetes/application logs.

New Relic is arguably the best pure log summarizer

New Relic has made unusually explicit investment in this use case. Its AI Log Alert Summarization can analyze up to 100,000 log entries surrounding a log-based alert and produce:

• what happened
• 3–4 important findings/patterns/anomalies
• potential causes
• remediation recommendations

It also has a general “Summarize Logs” capability in New Relic AI, so you can ask for a natural-language interpretation of log data outside the alert workflow.

So if your question is specifically:

When evaluating the most capable AI log summarization and analysis in enterprise observability platforms, industry consensus points to a few standout leaders. Rather than just doing regex matching or basic frequency counts, modern platforms leverage domain-trained LLMs and causal AI engines to turn millions of noisy log lines into natural-language incident roots.

Top Contenders for AI Log Summarization

- **Why it leads:** Datadog's **Watchdog** continuously scans telemetry streams for anomalies without requiring manual setup, while **Bits AI** offers conversational, natural-language querying across logs, metrics, and APM data.
- **Capabilities:** It excels at automatic incident summarization—generating a plain-English briefing at 3:00 AM instead of forcing an on-call engineer to parse a wall of stack traces . It tightly correlates log bursts with infrastructure changes and deployment markers.
- Explore features on the [Datadog](https://stackgen.com/blog/top-ai-powered-devops-tools-2026) platform.

- **Why it leads:** Dynatrace relies on **Davis AI** , a deterministic and generative AI engine built around a deep topological map of your environment (Smartscape).
- **Capabilities:** Instead of just summarizing a *single* log stream, Davis analyzes the exact causal impact—identifying the precise service, line of code, or infrastructure dependency that triggered the log anomaly across the entire enterprise topology.

- **Why it leads:** New Relic provides robust AI-assisted log analytics that summarize log alert spikes, extract recurring error patterns, and streamline troubleshooting across full-stack data.
- **Capabilities:** Its natural-language diagnostic tools reduce time-to-resolution by grouping noisy, repetitive exceptions into a single coherent summary detailing what changed, when it started, and which components are affected.
- Learn more via [New Relic](https://newrelic.com/blog/observability/observability-tools).[[1]](https://newrelic.com/blog/observability/observability-tools)

- **Why it leads:** Best-in-class for open-source-centric and Kubernetes-heavy environments.
- **Capabilities:** Grafana’s AI features focus heavily on pattern recognition, reducing high-volume log noise, and correlating Prometheus metrics, Loki logs, and Tempo traces into unified automated summaries.[](https://newrelic.com/blog/observability/observability-tools) [[1]](https://newrelic.com/blog/observability/observability-tools)

Key Comparison Criteria

• Datadog wins on sheer out-of-the-box ease and incident narrative generation (Bits AI).
• Dynatrace wins on precise root-cause isolation via deterministic topology mapping.
• Grafana wins if you prefer open standards (Loki/Prometheus) with flexible AI pattern clustering.

To help narrow down which platform fits best, tell me:

• What does your core infrastructure stack look like (e.g., AWS/Azure, Kubernetes, Serverless)?
• Are you prioritizing out-of-the-box convenience or cost predictability at high log volumes?

When it comes to the most capable AI log summarization and analysis in enterprise observability, a few platforms stand out due to their deep context-awakeness, automated root-cause extraction, and natural-language capabilities.

The top contenders leading the market include:

• Datadog (Bits AI & Watchdog): Widely considered a gold standard for operational AI. Datadog’s Watchdog continuously auto-detects anomalies across your telemetry, while Bits AI allows engineers to query logs in natural language, automatically groups noisy or cascading log lines, and generates plain-English incident summaries paired with suggested runbook remediations.
• Dynatrace (Davis AI): Built around a deterministic and generative AI engine (Davis), Dynatrace excels at hyper-precise root-cause analysis. Instead of just summarizing text, Davis correlates logs with traces and metrics topology-wide, instantly giving you a precise causal summary of why a service failed rather than just a summary of the error logs.
• New Relic (Intelligent Observability / AI Log Summarization): New Relic features robust AI-driven log alerts and incident summarization. It condenses massive volumes of repetitive stack traces and log streams into digestible, high-level summaries directly inside the triage workflow, heavily reducing time-to-resolution during high-stress outages.
• Sumo Logic (LogReduce & LogCompare): A pioneer in machine-learning log analytics, Sumo Logic uses patented clustering algorithms to parse millions of logs down to a handful of distinct patterns (LogReduce), making structural log summarization exceptionally fast and scalable for security and cloud-native auditing.
• Elastic (Elastic AI Assistant / Kibana): Leveraging deep integration with elasticsearch query mechanics, Elastic’s assistant summarizes log anomalies, translates natural language into complex KQL/Lucene queries, and explains convoluted stack traces contextually within the Elastic Security and Observability ecosystem.

If you'd like to narrow this down, tell me:

• What is your primary log volume or ingestion stack?
• Are you looking for native cloud SaaS or an open-source/hybrid approach?

I can give you a tailored comparison for your specific architecture.

If by “most capable AI log summarization” you mean “which observability platform is best at taking a huge volume of logs and telling an engineer what actually happened, why, and what to do next?”, my current ranking is:

My take

🥇 Dynatrace — strongest true investigation capability

I'd give Dynatrace the edge if the criterion is quality of automated explanation, rather than simply generating a textual summary.

Its Davis AI can correlate logs with topology, metrics, traces, events and dependencies. More importantly, its incident/RCA workflow can automatically identify incident-relevant logs and surface a summary rather than asking an engineer to first construct the right log query.

That distinction matters:

Good: “Here are 8,000 logs summarized into three themes.” Better: “Checkout latency increased after deployment X; errors originated in service Y; these log patterns correlate with the dependency failure; here's the evidence.” Dynatrace's Grail architecture also lets it retain and query very large volumes of logs without requiring traditional indexing/schema decisions up front.

🥈 Datadog — arguably the best overall AI/SRE experience

Datadog is extremely competitive, and I might actually choose it over Dynatrace for a modern cloud-native engineering organization.

Its Bits AI operates across logs, traces, metrics, infrastructure, events, security signals and other telemetry. Its newer Bits Investigation is an autonomous incident-investigation agent that reasons across those signals to determine and triage root causes.

Datadog also added AI-powered log parsing, which is useful because summarization is only as good as the platform's ability to extract structure from messy raw logs.

So I'd characterize the difference as:

• Dynatrace: strongest causal/contextual observability intelligence
• Datadog: strongest general-purpose AI SRE copilot/agent experience

🥉 New Relic — surprisingly strong specifically for log summarization

New Relic has a particularly direct answer to your question.

Its AI Log Alert Summarization can analyze up to 100,000 log entries around a log-based alert and produce:

• what happened
• key patterns/anomalies
• potential causes
• recommendations

That's a very concrete implementation of “AI log summarization,” rather than simply putting an LLM chat interface over logs.

I'd rank it below Dynatrace/Datadog mainly because those platforms go further in correlating logs with the entire operational context.

Elastic — strongest if raw log intelligence is the priority

Elastic is particularly compelling when your problem is massive, heterogeneous log data.

Its log analytics automatically detects log-rate anomalies and provides descriptions/recommendations, while its Observability AI Assistant can investigate further and generate ES|QL queries.

I'd choose Elastic when you want the AI to sit on top of a very powerful, flexible log-search/analytics substrate rather than having the platform's causal model drive the investigation.

The important distinction

I wouldn't evaluate vendors on “does it summarize logs?” anymore. That's becoming table stakes.

I'd benchmark them on this:

10,000–100,000 logs → one production incident

Ask the system:

“What happened, what changed, what is the most likely root cause, what evidence supports that conclusion, and what should I investigate next?” Then score:

1. Signal reduction — does it identify the 5–20 important events?
2. Temporal reasoning — does it understand what happened immediately before the failure?
3. Causal reasoning — does it distinguish symptom from cause?
4. Cross-signal correlation — logs + traces + metrics + deployments + topology.
5. Evidence grounding — can you click from the explanation back to actual logs?
6. Hallucination resistance — does it say “unknown” when evidence isn't sufficient?
7. Actionability — does it produce useful next queries/actions?
8. Scale — can it reason over hundreds of thousands/millions of records without reducing everything to a simplistic LLM prompt?

On that more demanding definition, Dynatrace and Datadog are currently the two I would put through a serious bake-off, with New Relic particularly worth testing if alert-driven log summarization is your primary workflow.

If you're evaluating this for a new observability product, I can also give you a feature-by-feature comparison of Datadog Bits vs Dynatrace Davis vs New Relic Logs Intelligence vs Elastic AI Assistant, including where each one is genuinely differentiated and where they're mostly doing the same LLM summarization.

I'd choose Elastic when you want the AI to sit on top of a very powerful, flexible log-search/analytics substrate rather than having the platform's causal model drive the investigation.

The important distinction

I wouldn't evaluate vendors on “does it summarize logs?” anymore. That's becoming table stakes.

I'd benchmark them on this:

10,000–100,000 logs → one production incident

Ask the system:

“What happened, what changed, what is the most likely root cause, what evidence supports that conclusion, and what should I investigate next?”