AI Observability: From Hype To Impact by Wade Moore 🔗 **Source:** [AI Observability: From Hype To Impact by Wade Moore](https://www.youtube.com/watch?v=c6bhco8zL2w) > [!note]+ Document Notes > tags: [ai-observability, devops, enterprise-monitoring] > author: Wade Moore > source: All Things Open Conference > reference: https://www.youtube.com/watch?v=c6bhco8zL2w > date created: 2024-12-19 14:30 > > # 🏷️ Title: AI Observability: From Hype To Impact > <!-- deep-read:sections start --> ## 🧰 Action Inbox - [H1] Evaluate current observability platform AI capabilities — assess integration readiness #devops - [H2] Implement knowledge graph strategy for data correlation — enable context-aware AI queries #architecture - [H3] Calculate ROI of AI observability adoption — compare productivity gains vs costs #business ## 🧭 Table of Contents - [📝 Summary](#-summary) - [📖 Main Content](#-main-content) - [🗒️ Notes](#️-notes) - [📚 References](#-references) - [🗣️ Paraphrase](#️-paraphrase) - [📰 Newsletter](#-newsletter) - [✅ Action Items](#-action-items) - [🧪 Hypotheses](#-hypotheses) - [📊 Methodology](#-methodology) - [❓ Questions](#-questions) - [🔮 Future Research](#-future-research) - [💡 Implications](#-implications) - [🧠 Learning Styles Assessment](#-learning-styles-assessment) - [📊 Accessibility Assessment](#-accessibility-assessment) - [🌍 DEIB Assessment](#-deib-assessment) - [✅ Logical Validity](#-logical-validity) - [🛡️ DARVO Analysis](#-darvo-analysis) - [🎯 Conclusion](#-conclusion) ### 🔗 References - [AI Observability: From Hype To Impact](https://www.youtube.com/watch?v=c6bhco8zL2w) - [Observe Inc.](https://observeinc.com) ## 📝 Summary - Wade Moore presents AI observability evolution from basic chatbots to enterprise-integrated LLM platforms working with live data - Why it matters: Transforms developer productivity by eliminating complex query languages and dashboard navigation requirements - Key stakeholders: SREs, DevOps engineers, junior developers, IT executives managing operational costs - Risks and tradeoffs: High compute costs for AI queries vs. productivity gains; data correlation complexity vs. democratized access - Bottom line takeaway: AI observability will supercharge engineering productivity through natural language queries and automated analysis, but requires unified data architecture and cost-conscious implementation ## 📖 Main Content AI observability represents the integration of Large Language Model (LLM) capabilities directly into observability platforms, enabling real-time analysis of live enterprise data rather than generic chatbot responses. This evolution includes agentic AI systems with specialized troubleshooting agents and integration with tools like Claude and ChatGPT through MCP servers. The core value proposition centers on democratizing data access - removing the need for tribal knowledge about specific platforms or query languages. Engineers can ask natural language questions like "What's going on in my environment?" and receive actionable visualizations and analysis. Critical success factors include comprehensive business context through knowledge graphs, unified data storage architectures (particularly data lakes), and tight integration between AI and observability platforms. The economic model must balance AI compute costs against productivity improvements and reduced training requirements. ## 🗒️ Notes #### ⏱️ [00:00](https://www.youtube.com/watch?v=c6bhco8zL2w?t=0) — [H1] Introduction and Speaker Background - Key idea: Four years of observability evolution culminating in AI integration - Evidence: "I've been working with our customers and organizations to help make sense of their data" #### ⏱️ [02:30](https://www.youtube.com/watch?v=c6bhco8zL2w?t=150) — [H2] Defining AI Observability - Key idea: LLM integration with live enterprise data, not generic chatbots - Evidence: "integration of the LLM capabilities into your observability platform so that it can work directly with your live enterprise data" #### ⏱️ [03:45](https://www.youtube.com/watch?v=c6bhco8zL2w?t=225) — [H2] Agentic AI and Specialized Agents - Key idea: Specialized agents handle specific troubleshooting steps for better accuracy - Evidence: "agents that are specialized to handle specific steps in the troubleshooting process" #### ⏱️ [05:00](https://www.youtube.com/watch?v=c6bhco8zL2w?t=300) — [H2] Observe AI Suite Demo - Key idea: Natural language queries eliminate need for dashboard expertise - Evidence: "ask about my services. I don't need to know what dashboards, what data sets or what specific metrics" #### ⏱️ [07:15](https://www.youtube.com/watch?v=c6bhco8zL2w?t=435) — [H2] Knowledge Graph Integration - Key idea: Knowledge graphs enable data correlation and context understanding - Evidence: "we're first searching a knowledge graph...understand how that data is correlated to one another" #### ⏱️ [09:30](https://www.youtube.com/watch?v=c6bhco8zL2w?t=570) — [H1] Developer Productivity Impact - Key idea: Supercharges productivity without replacing engineers - Evidence: "supercharge developer productivity. I don't at all believe...it's going to replace SREs" #### ⏱️ [10:45](https://www.youtube.com/watch?v=c6bhco8zL2w?t=645) — [H2] Natural Language Troubleshooting - Key idea: Emergency situations benefit from natural language queries - Evidence: "you wake up at 2 am, what's the first question that comes to your mind? What the hell is going on?" #### ⏱️ [12:00](https://www.youtube.com/watch?v=c6bhco8zL2w?t=720) — [H2] Platform Navigation Challenges - Key idea: Complex platforms with legacy dashboards create barriers for junior engineers - Evidence: "really hard for even seasoned engineers to navigate an observability platform" #### ⏱️ [14:30](https://www.youtube.com/watch?v=c6bhco8zL2w?t=870) — [H2] The Vibe Loop Concept - Key idea: Complete AI cycle from code generation to production monitoring - Evidence: "completing the full circle of using generative AI in the software development life cycle" #### ⏱️ [17:00](https://www.youtube.com/watch?v=c6bhco8zL2w?t=1020) — [H1] Context as Critical Success Factor - Key idea: Business context and knowledge graphs essential for actionable insights - Evidence: "the most crucial element of all is context" #### ⏱️ [19:15](https://www.youtube.com/watch?v=c6bhco8zL2w?t=1155) — [H2] Knowledge Graph Technical Details - Key idea: Semantic representation enables LLM understanding of data relationships - Evidence: "knowledge graph is simply a semantic representation of your data and the relationships" #### ⏱️ [21:30](https://www.youtube.com/watch?v=c6bhco8zL2w?t=1290) — [H1] Economic Considerations - Key idea: Must balance AI compute costs against productivity benefits - Evidence: "amplify insights not cost...enterprise organizations are starting to provide these solutions as a paid for service" #### ⏱️ [23:45](https://www.youtube.com/watch?v=c6bhco8zL2w?t=1425) — [H2] Data Architecture Requirements - Key idea: Data lake architecture provides cost-effective foundation for AI - Evidence: "building on top of a data lake...gives you better cost separation of compute and storage" #### ⏱️ [26:00](https://www.youtube.com/watch?v=c6bhco8zL2w?t=1560) — [H2] IT Executive Priorities - Key idea: Cost optimization and operational resilience drive AI adoption - Evidence: "top goals...cost optimization...platform resilience and operational resilience" ## 📚 References - [Observe Inc. Platform](https://observeinc.com) - [All Things Open Conference](https://allthingsopen.org) - [MCP Server Documentation](https://github.com/modelcontextprotocol) ## 🗣️ Paraphrase - AI observability transforms monitoring platforms by integrating language models that can analyze live production data through natural conversation, eliminating the need for specialized query knowledge - Knowledge graphs provide the essential context layer that helps AI understand how different data sources relate to each other, enabling comprehensive analysis across logs, metrics, and business data - The economic value comes from dramatically reducing the expertise barrier for troubleshooting while managing AI compute costs through efficient architectures like data lakes ## 📰 Newsletter 🚀 **AI Observability: The Future of Site Reliability** The observability space is experiencing a fundamental shift as AI capabilities integrate directly with live production data. Instead of navigating complex dashboards or learning query languages, engineers can now ask simple questions like "What's wrong with my services?" and get immediate, actionable insights. **Key Benefits:** - Democratizes troubleshooting for junior engineers - Natural language queries replace technical expertise barriers - Complete development lifecycle integration ("Vibe Loop") - Standardized incident response workflows **Getting Started:** - Evaluate your current platform's AI roadmap - Assess data correlation capabilities - Calculate ROI based on reduced training time and faster resolution The winners will be organizations that combine comprehensive business context with cost-effective AI architectures, turning every engineer into a troubleshooting expert. Resources: [Observe AI Suite](https://observeinc.com), [OpenTelemetry](https://opentelemetry.io/), [CNCF Observability](https://www.cncf.io/) ## ✅ Action Items #### DevRel - Developer advocacy: Create demos showing AI observability vs traditional dashboards, measure query-to-resolution time improvements - Education: Develop workshops on knowledge graph implementation for observability contexts - Developer experience: Document MCP server integration patterns for popular AI assistants - Developer marketing: Position natural language troubleshooting as democratizing force for junior developers - Community management: Gather feedback on AI query accuracy and cost concerns from SRE communities #### OSPO - Policy & Governance: Establish guidelines for AI model selection in observability tools - License Compliance: Review LLM licensing implications for enterprise observability platforms - Security Management: Assess data exposure risks when AI systems access production telemetry - Software Inventory: Track AI observability tool adoption and integration patterns - Developer Support: Provide training on responsible AI use in production monitoring contexts - Community Engagement: Contribute to open source observability AI projects and standards - Strategic Alignment: Align AI observability investments with broader enterprise AI strategy #### Community - Maintainers: Support observability project maintainers integrating AI capabilities - Contributors: Create contribution guides for AI-enhanced monitoring tools - Sponsors: Fund development of open source AI observability frameworks - Ecosystem: Coordinate standards between observability vendors on AI integration patterns #### WordPress - Core Performance: Integrate AI observability for WordPress.org infrastructure monitoring - Meta: Implement natural language queries for .org platform health dashboards - Hosting: Provide AI observability recommendations for WordPress hosting providers - CLI: Add AI-powered diagnostic commands to WP-CLI for automated troubleshooting #### The WPCC - Programs: Fund fellowships focused on AI observability for open source infrastructure - Projects: Support governance documentation for AI tool adoption in community projects - Funding: Provide matched grants for AI observability tool development #### FAIR - Technical independence: Ensure AI observability tools don't create vendor lock-in - Policies: Establish transparency requirements for AI decision-making in incident response - Governance artifacts: Create charters for responsible AI use in production monitoring ## 🧪 Hypotheses - AI observability adoption will correlate directly with organization size and observability complexity levels - Natural language querying will reduce mean time to resolution (MTTR) by 40-60% for junior engineers - Knowledge graph implementation quality will determine AI observability accuracy more than LLM model choice - Cost concerns will drive adoption of data lake architectures over traditional observability storage models ### 📊 Methodology - A/B testing comparing traditional dashboard navigation vs AI query interfaces for incident response times - Survey analysis of engineering teams before/after AI observability implementation measuring productivity metrics - Cost analysis comparing traditional observability toolchains vs unified AI-integrated platforms across different data volumes ### ❓ Questions - How will AI observability affect the skill requirements and career paths for SRE professionals? - What governance frameworks will emerge for AI-driven automated incident response decisions? - How will observability vendors balance AI compute costs with customer value in their pricing models? ### 🔮 Future Research - Longitudinal studies on AI observability impact on engineering team structure and hiring patterns - Investigation of AI bias in incident prioritization and root cause analysis - Development of standardized benchmarks for AI observability accuracy and cost-effectiveness ### 💡 Implications - Practice: Fundamental shift from learning query languages to conversational troubleshooting interfaces - Policy: Need for AI governance frameworks in production monitoring and incident response processes - Security: New attack vectors through AI systems with access to comprehensive production telemetry data - Education: Transformation of SRE training from tool-specific knowledge to AI collaboration skills - Funding: Significant budget reallocation from training and specialized tooling to AI platform capabilities ### 🧠 Learning Styles Assessment Reading level estimate: Flesch-Kincaid Grade Level 12 #### 👀 Visual learners - Present: Screenshots of AI query interface, system architecture diagrams - Improve: Knowledge graph visualizations, cost comparison charts, workflow diagrams #### 🔊 Aural learners - Present: Conference presentation with clear narration and examples - Improve: Audio summary highlighting key economic arguments and technical concepts #### 🗣️ Verbal learners - Present: Clear definitions of AI observability, knowledge graphs, and technical terminology - Improve: More analogies comparing traditional vs AI-powered troubleshooting workflows #### 🧩 Kinesthetic learners - Present: Demonstration of actual AI query interface and results - Improve: Hands-on labs with sample observability data and AI query exercises #### 🧠 Logical learners - Present: Clear progression from problem statement through technical solution to economic impact - Improve: Decision trees for AI observability adoption, quantified ROI calculations #### 🧑‍🤝‍🧑 Social learners - Present: Conference setting with community discussion and Q&A opportunities - Improve: Team evaluation frameworks, collaborative implementation guides #### 🧘‍♀️ Solitary learners - Present: Structured presentation allowing individual reflection on organizational fit - Improve: Self-assessment worksheets for current observability maturity and AI readiness #### 🌿 Naturalistic learners - Present: Systems thinking approach connecting data ecosystem relationships - Improve: Analogies to natural information flows and ecosystem interconnections ### 📊 Accessibility Assessment #### Screen reader semantics - Present: Clear heading structure, descriptive slide titles - Improve: Alt text for technical diagrams, detailed descriptions of UI screenshots #### Keyboard navigation - Present: Standard video player controls - Improve: Transcript with timestamp navigation, keyboard shortcuts for key concepts #### Contrast and readability - Present: Clear slide presentation with adequate contrast - Improve: High contrast mode for technical diagrams, larger text for code examples #### Text resizing and reflow - Present: Video content scales appropriately - Improve: Responsive transcript layout, zoomable diagram details #### Media and captions - Present: Full video transcript provided - Improve: Closed captions with technical term emphasis, audio descriptions for visual elements #### Forms and interactions - Present: Basic video playback controls - Improve: Interactive transcript with searchable timestamps, concept highlighting #### Standards reference - Maps to WCAG 2.2 AA success criteria for multimedia content and technical documentation ### 🌍 DEIB Assessment #### Cultural breadth - Present: Enterprise focus applicable across global organizations - Improve: Multi-region deployment examples, cultural considerations for AI adoption #### Inclusive language - Present: Technical terminology clearly defined, gender-neutral examples - Improve: Plain language alternatives for complex concepts, avoid technology-exclusive assumptions #### Neurodiversity support - Present: Clear structure with logical progression, consistent terminology - Improve: Concept summaries at section breaks, visual concept mapping #### Representation - Present: Focus on democratizing technical access regardless of experience level - Improve: Diverse team examples, varied organizational contexts and sizes #### Psychological safety - Present: Supportive framing of junior engineer capabilities - Improve: Acknowledge learning curves, normalize questions about AI implementation ### ✅ <!-- deep-read:sections end --> ## 📺 Video  --- # 📄 Full Transcript *Auto-generated from YouTube captions · timestamps roughly every 30 seconds · [watch on YouTube](https://www.youtube.com/watch?v=c6bhco8zL2w)* **[00:05]** Thanks for closing out the day with us, day two, and finishing up another really great all things open conference. So, my name is Wade Moore and I am a solutions architect at Observe, Inc., and for roughly the past four years, I've been working with our customers and organizations to help make sense of their data. And so over that time I've seen the evolution and progression of the observability space as a whole. But then now more recently the integration of AI into these observability **[00:36]** platforms. So I want to talk a little bit about that with you today. Really just want to give a high level overview and look at AI observability and the current state of it today. looking at what impact and the difference it's going to make on organizations and particularly engineers who depend on observability platforms. We're going to talk a little bit about Oh, gotcha. Thank you. And then we're going to talk a little bit about how observability AI is going to be made **[01:08]** effective and what key components need to be included. And then lastly, we're going to talk about the bottom line, and I do mean cost. Because not only are we going to have to use AI efficiently to make it affordable, but also the cost and the money that's going to be saved by the increased productivity. And so let's dive right in. What is AI observability before we get into it? Anytime you're talking about AI AI, it's not very clear what exactly we **[01:38]** mean. But in terms of the enterprise observability space, what this is shaping up to be today is the integration of the LLM capabilities into your observability platform so that it can work directly with your live enterprise data. And so no longer is it simply a chatbot with generic answers, but real analysis on real data. Wish I had my clicker. But moving on, the other part of it is going to be able to leverage agentic AI. So we've talked **[02:09]** about this before in the evolution of AI systems now using agents that are specialized to handle specific steps in the troubleshooting process. This not only makes it more manageable and maintainable, but it actually yields much better results, more accurate to each step of the process. And then lastly, you know what it really comes to be in fruition and what you're using at the end of the day is things like an AIS surreating with an MCP server so that you can **[02:41]** utilize an observability solution directly from your chat GPT claw or cursor desktop. And then of course anomaly detection, something that isn't new, but also a big component of the types of features and capabilities that AI can promise. And one good example, of course, I'm from Observe, so I can give you a little sneak peek into what we're working on. Can tell you it's similar, but of course different than what other players are **[03:12]** doing. What we have here is just a quick screenshot of the observe ais surre which should look very familiar to a clawed or chat GPT prompting window where you can ask questions using natural language except now you're working within an observability platform with the data you're already analyzing and able to continue the investigation beyond what the LLM provides you. And so you'll see in this example here, we just give a plain text query at the top, ask **[03:43]** about my services. I don't need to know what dashboards, what data sets or what specific metrics I need to look into. And this enables us to democratize data for everyone within the organization. It doesn't take tribal knowledge or expertise into a particular observability platform to be able to extract these insights. So I ask a simple question and lo and behold I get a result either a visualization or maybe some set of logs or a summary analysis **[04:14]** of what's going on in my environment. And what you'll notice a little specific to observe is that we're first searching a knowledge graph. And we'll talk a little bit more about that in a second. But that's a key component to AI being effective in these live systems with a ton of different data from different places. We need to understand how that data is correlated to one another by searching through a knowledge graph. And once it does that, it can return the appropriate metrics, data sets, etc. Providing these visualizations. And like **[04:45]** I mentioned, you're getting more than just a picture. You're really able to click on these things and interface with them, see what query was generated, make changes as needed, if I want a line chart versus a bar chart. And then I can actually export and go beyond this into other dashboards, monitors or a deeper investigation. And then what you'll notice just a small picture of this is what would be put below all of these visualizations. It's not only generating queries for you **[05:17]** automatically and returning the results, but takes the extra step of being able to analyze those results, provide a summary, and give its best interpretation as to what's going on. What are the next steps that need to be taken? And so this is observes AI surre. You're certainly going to see similar things in other platforms, but again, gone are the days are having to sip through a list of dashboards and monitors or data sets. Gone are the days are you required to **[05:47]** learn a query language in order to get something meaningful out of your observability data. And so talking a little bit about the impact of what AI observability is going to do to this space. Very simply, it's going to supercharge developer productivity. I don't at all believe, at least not nearly yet, it's going to replace SRRES, engineers, or any support personnel, but their lives are going to be made exponentially easier and thus getting to **[06:20]** a resolution exponentially faster. Instead of having, like I mentioned, to sift through a very complex platform, we can simply ask questions and get to a root cause quickly. How does this come to be? Like I mentioned before, the natural language ability to ask questions moves us from queries to questions. Because I mean, you wake up at 2 am, what's the first question that comes to your mind? What the hell is going on? **[06:51]** And now, not more, not just a joke. You can actually ask an AISR exactly that and get a meaningful answer back. What's going on in my environment? Let's give you a quick overview. Similar, but worth calling out. It's really hard for even seasoned engineers to navigate an observability platform, especially one that has been in place at an organization for potentially years where dashboards and different views of the data are created incrementally **[07:23]** and not always cleaned up so much when they become out of style or out of date. And so it makes for a very large amount of resources. the difficulty of navigating that, especially for new team members or junior SRRES, this gives them the ability to dive in and take action. Ultimately, better troubleshooting. And more than just understanding where the data is, it's not easy to understand how things should be grouped. What are the different ways of thinking about my **[07:54]** environment? Do I want to group by namespace? Do I want to evaluate against different clusters or get a comparison against the overarching log volume to the errors that I'm seeing? So I can quickly deduce if this is something normal, just steady noise, or is there actually an issue at play? And so AI observability and these tools are going to give you the ability to standardize on workflows, provide a consistent runbook for engineers to query and then get results that can ultimately be **[08:25]** shared. And you can trust that AI is going to be a bit more comprehensive than less and so gaps aren't missing. And last but not least, I want to mention the vibe loop. Uh we we'll see how much this takes off. This is a term we use at Observe, but it's an incredible idea where we're completing the full circle of using generative AI in the software development life cycle. We've all seen today how Vibe coding is already integrated into a daily process for most engineers. That's a good thing. **[08:57]** Now, we want to vet that code, trust, but verify. But we're able to then generate syntax and functions and use libraries with exponentially faster time to development using generative AI and something like cursor or claude. But then what happens when that code is deployed and then running in the live environments? Then we can now use generative AI through the observability platform to complete the cycle. so I can understand issues, understand behaviors and performance in my applications, and **[09:30]** then turn around, go right back into Claude, or better yet, if you're using an MCP server, you maybe never left Claude, and you're then able to leverage those insights, leverage what's happening in your environment to then again generate and write more code for those fixes, and thus verify the fix as well. So, we call that the vibe loop. You might see that around with observe. But that's the impact of AI observability. Just to sit here for one more second, it truly is going to make **[10:00]** lives of developers so much easier because working with customers and organizations over the past four years, one of the most common things I get is, "I just don't know where to look and I don't know where to start." It's only usually a select few who probably helped set up the observability platform that really understand this on a deep level. Again, we want to democratize data, democratize the troubleshooting process to enable anyone in the organization to jump in. Whether you're familiar with this platform or not, it's all a natural **[10:32]** language query. And so getting a little bit more into how this is going to be made possible, the most crucial element of all is context. Yes, we need data and like you can imagine observability platforms are rich with tons and tons of data spanning from lower level telemetry to more highle business context whether that's ticketing systems, CI/CD systems or any **[11:04]** kind of bespoke data that you could correlate and use against the lower level logs, metrics and traces. All of this data is critical for AI to be able to make actionable insights. However, the data alone doesn't necessarily capture the business context or the workflows that you and your team and your organization use on a daily basis. So, it's this ability to enhance the lower level data with a knowledge graph. **[11:35]** A knowledge graph is simply a semantic representation of your data and the relationships at hand. to get a little bit underneath the hood, right? We can take any generic LLM chat GPT or Claude Anthropics LLM model, package that up and enhance it with a rag type of mindset, providing the context, prompting that LLM with what does it mean to have a data set? What are the individual fields that are most **[12:06]** relevant here? What are the correlation tags that have been put in place that relate this data whether it's logs, metrics, traces or that bespoke data to everything else in your environment. So when you ask questions about users or errors are things happening with different services, LLM's AI is able to understand what that means and then provide a full picture of all of the different related telemetry for that question. **[12:38]** and disparit data. Yeah, you can tell there's going to be a lot of different sources of data. This is a problem that observability platforms are already solving. Being able to have all of your data into a unified store, which is what really enables easy correlation at an economical price. A lot of systems may have data more siloed and that is already difficult for providing economical correlations. It is not going to get easier in terms of trying to extract AI insights. So it is critical **[13:09]** that your observability or your AI solutions for observability are integrated with one another. And right I talked about the bottom line. We want to amplify insights not cost. It feels like today we'll pay any price tag for AI, but that is surely coming to an end. Already enterprise organizations are starting to provide these solutions as a paid for service **[13:40]** and thus the number of queries, the amount of compute that you're going to use will be build. But this also comes back to storing the data. Again, a problem with observability solutions today, we need to be able to store masses amounts of data economically and for a longer retention. AI is not going to be satisfied with looking at data over the last three days because you can't handle longer retention. We're going to need **[14:10]** economical modern architectures. And in the case of observe, we believe in building on top of a data lake, which is not an unheard of idea in this industry. And it's that ability there which gives you better cost separation of compute and storage but also the flexibility to use and manipulate this data in any which way or form and that is a rock solid foundation for building on a AI on top of that **[14:43]** and so right reiterating again observability should be tightly integrated if not 100% a part of your obser observability platform by adding additional layers of disparit tooling. It's only going to balloon cost. Plus, like we mentioned with correlating data from silos, that's an extra layer you have to work through. And then like I said before, queries cost compute, the architecture of how observability providers enable AI **[15:14]** observability is going to make a difference for end users. If you're familiar with the observability space today, costs are a very big component, especially for large organizations who are spending an incredible amount amount of money on these different solutions. It is only second or third to the cloud provider bill. And so now trying to leverage AI, it's going to be incredibly important that you're using a system or architecture that is optimized to **[15:44]** provide these capabilities at a reasonable price. so that the value makes sense. And then what I want to highlight as well is how much money is going to be saved by having improved the troubleshooting process by having to reduce the amount of training and expertise required to take advantage of observability platforms. It's not so much directly affecting the bottom line, but in an indirect way, these are really going to show a big difference in how engineering organizations **[16:16]** are productive. And just kind of click on this once more. This isn't a question about what do you want to do with AI. Certainly, everyone out there has some goals or initiative associated with what they're going to do with AI. But if we ask IT executives who are responsible for operations or system administration, what are your top goals regardless of **[16:48]** AI? And we see that it is mostly cost optimization, go figure, but also platform resilience and operational resilience. How can we have less downtime? How can we have our engineers and developers focusing on making new features as opposed to troubleshooting? And this is where AI observability is going to start to make huge improvements on the engineering organizations that employ this. **[17:20]** And so that's observability AI for you in a nutshell. It's going to dramatically supercharge productivity in engineering organizations, particularly with the software development life cycle. And folks who are able to use observability platforms that can leverage business context as well as the lower level application context, those are the folks who are going to be able to get the best answers faster. And then the cherry on top is using a solution that you can actually afford and that **[17:51]** ultimately provides you enough value to save you money. So, thank you so much for coming out here today and closing out ATO with me. I hope you all have a great one.