The quick download:
Autonomous IT starts with AI-ready data, not AI alone.
-
AI in IT operations is only as trustworthy as the telemetry beneath it. An AI-ready foundation needs data that is complete, governed, and consumable so AI can reason across the environment and turn insights into action.
-
LogicMonitor is expanding its Enterprise Data Foundation with OpenTelemetry metrics and cloud cost embedded in operational workflows.
-
Bringing application evidence and infrastructure cost alongside performance and reliability data gives teams—and eventually AI—a more complete picture for troubleshooting, optimization, and operational decisions.
-
This foundation powers everything above it: complete data enables connected context, and connected context enables Edwin AI to investigate, recommend, and take governed action with greater confidence.
An AI investigation opens on a latency incident and, within seconds, blames the database. It’s articulate. It cites evidence. But, it’s wrong. The real cause was a firewall cluster in a segment of the network that was never onboarded into monitoring, because the device didn’t speak SNMP the way the collector expected. The AI didn’t hallucinate. It just reasoned using incomplete data.
If you own observability for a large hybrid estate, this is the failure you should worry about most as AI moves into your operations. Not the model, but the data. LogicMonitor is announcing innovations across every layer of its Autonomous IT platform. This blog focuses on the Enterprise Data Foundation layer, which decides whether the AI on stage is trustworthy. We’ll cover what “AI-ready” data actually means, what we’re adding, and why systems of action are built from this layer up. Let’s dig in.
Why most AI in IT operations fails on the data, not the model
Large language models are now good enough that the differentiator in IT operations has shifted. Every vendor can produce a fluent summary of an alert. Very few can guarantee that the summary reflects everything that was actually happening in your environment.
Three things break that guarantee. Coverage gaps: the branch-office SD-WAN, the storage array that only the storage team monitors, the cloud account whose credentials silently expired last quarter. Ungoverned sprawl: logs with no retention policy, no partitioning, and access rules that would embarrass you in an audit. And data that’s technically accessible but practically unusable: a hundred schemas, no shared identity for the same host across tools, and no way for a model to reason across them without a human translating.
Any one of these leaves the AI confidently wrong. Together, they guarantee it. So before anything else, the foundation has to be right.
What “AI-ready” actually means
Think about the difference between a warehouse and a library. Both hold everything. Only one is organized so that someone who’s never been inside can walk in, find the right volume, and trust that the catalog is complete. Raw telemetry is a warehouse. AI-ready data is a library. It has three properties.
Complete: coverage across the estate you actually run
Not the estate on the architecture diagram. The real one, with the vendor mix, the restricted network segments, the legacy Windows tier, and the cloud accounts nobody remembers creating. AI-ready means the foundation can ingest from all of it, including devices and environments that don’t fit a pull-based, agent-on-every-box model.
Governed: retention, access, and scale you can defend
Who can see which logs. How long they’re kept. Whether a partition for one business unit can be searched by another. Whether the pipeline holds up at the scale of a large enterprise — across our customer base, that means more than 2 trillion metrics a day. Governance isn’t a compliance afterthought here; it’s what makes it safe to let an AI read the data at all.
Consumable: designed for action, not just queries
This is the property most vendors skip. AI-accessible means a model can run a query against the store. AI-consumable means the data carries the identity, relationships, and structure a model needs to reason over it directly, in batch and at speed, and to hand the result to an automation without a person reformatting it in between. Data designed for action is what lets an investigation end in a decision instead of a report.
Those three properties are the bar. Here’s what we’re adding to clear it.
What we’re announcing in the Enterprise Data Foundation
Three innovations, each aimed at one of the ways foundations break — and each built so the layers above can act on what it collects.
OpenTelemetry metrics ingestion
Push metrics to LogicMonitor in a standardized, vendor-neutral way, using either an upstream open-source OpenTelemetry collector or LogicMonitor’s own. That removes pull-based requirements, which matters in two places that have historically been coverage gaps: restricted environments where traditional SNMP access isn’t available, and high-scale streaming telemetry from network devices that a polling model struggles to keep up with.
- Coverage where polling can’t reach: Environments that push telemetry outbound can now be first-class citizens in the same platform as everything else.
- One path for your own instrumentation: If your engineering teams already emit OpenTelemetry metrics, they land in LogicMonitor without a proprietary agent.
- No lock-in on the way in: The collector is open; your instrumentation stays portable.
One note of precision, because it matters to the engineers reading this: this innovation is OpenTelemetry metrics. Traces continue to arrive through LogicMonitor APM, and native OpenTelemetry log ingestion is a separate path we’ll describe when it’s available. We’d rather tell you the scope than have you discover it.
IIS log collection through the OpenTelemetry Windows collector
Windows web tiers are among the most common places where infrastructure looks healthy while the application is failing. Internet Information Services (IIS) logs carry the request-level evidence — status codes, response times, failing endpoints — that closes that gap. Collecting them through the OpenTelemetry Windows collector brings that application-layer signal into the same foundation as your infrastructure metrics, out of the box.
- Application evidence next to infrastructure evidence: A slow endpoint and the host it runs on are in one place, ready to be connected by the context layer.
- Out-of-the-box query packs for IIS: so the first useful view doesn’t require a week of query-writing are coming soon.
- Same open path as metrics: One collector story for the Windows tier.
Infrastructure cost inside observability workflows
Cost is telemetry too, and today it usually lives in a different tool owned by a different team. Embedding infrastructure spend into operational workflows means the engineer sizing a cluster, tuning a retention policy, or deciding whether to keep a redundant environment sees what it costs while making the decision, instead of learning about it in a finance review three weeks later.
- Spend next to performance and reliability: In the workflow where trade-offs are actually made.
- Cost as context for AI: Once cost is in the foundation, Edwin AI can weigh it when recommending an action, not just after.
- A shared language between operations and finance: Grounded in the same data.

Why open standards are a strategic decision, not a checkbox
Customers tell us, consistently, that they don’t want to be locked in — not to a monitoring vendor, not to an agent, not to a data format. OpenTelemetry is the industry’s answer to that, and building the foundation on it is a strategic choice about whose data this is. It’s yours. LogicMonitor’s job is to make it complete, governed, and consumable, not to hold it hostage.
That’s also why we’re being explicit about scope. Open standards only earn trust if the vendor is precise about what they support. Metrics now. The rest as it arrives, described the same way.
A foundation is only worth building for what goes on top of it. So what does this one unlock?
What the foundation unlocks above it
Everything. Literally. The Unified Context Layer — the context graph that connects infrastructure, applications, services, and users — can only connect what the foundation collects. If the firewall cluster from the opening story isn’t in the data, it isn’t in the graph, and no amount of AI reasoning will find it.
And Edwin AI, LogicMonitor’s AI operating layer for IT operations, can only act on what the context graph connects. When it delegates an investigation to a domain agent, that agent works close to the data in the foundation. When it recommends a remediation, the evidence it cites comes from here. When it takes governed action, the audit trail that lets you trust it is written here.
Complete data makes context possible. Connected context makes action trustworthy. That’s the whole architecture, and it starts at the bottom.
Conclusion
The most important layer in an Autonomous IT platform is the one that never makes the demo, and LogicMonitor is investing in it deliberately: an open, push-based path into the restricted corners of your estate, application evidence from the Windows tier landing beside infrastructure evidence, and cost sitting next to the performance it explains. This is the foundation a system of action stands on.
Before you evaluate anyone’s AI for IT operations — including ours — audit your foundation against three questions. Is it complete? Is it governed? Is it consumable? Get all three to yes and every layer above becomes trustworthy. That is the standard we’re building to.
You can’t automate what you can’t see. And you can’t trust what you didn’t collect.
Ready to Make Your Data AI-Ready?
Talk with our team about connecting infrastructure, application, and operational data to support more intelligent IT operations.
FAQs
Does LogicMonitor support OpenTelemetry?
LogicMonitor supports OpenTelemetry metrics ingestion using either upstream open-source or LogicMonitor OpenTelemetry collectors. Traces are supported through LogicMonitor APM. Native OpenTelemetry log ingestion is not part of this announcement.
What does “AI-ready data” mean in IT operations?
Telemetry that is complete across the environment, governed with defined retention and access controls at enterprise scale, and consumable — structured with the identity and relationships an AI system needs to reason over it and hand results to automation.
Can I use my existing OpenTelemetry collectors with LogicMonitor?
Yes. You can push metrics from an upstream open-source OpenTelemetry collector or use LogicMonitor’s OpenTelemetry collector; your instrumentation stays portable either way.
Why put infrastructure cost into observability workflows instead of a FinOps tool?
Because the trade-offs that drive cost — sizing, retention, redundancy — are made in operational workflows. Showing spend where those decisions happen lets teams optimize cost alongside performance and reliability rather than after the fact.




