## Background
This video was published on YouTube by the channel Ai4 on August 18, 2026. Presented by Matt Henderson, CEO of Coral, the session explains why enterprises should build and control their own modular AI agent architectures in-house rather than renting third-party vertical SaaS bots.
## TL;DR
Matt Henderson presents the strategic, financial, and operational cases for building enterprise AI agents in-house rather than renting third-party SaaS solutions. Using an AI Site Reliability Engineering (SRE) agent as a practical example, he shows how an internal build outperforms commercial alternatives like Datadog Bits AI in accuracy while operating at a fraction of the cost. The talk breaks down a modular agent architecture into five switchable components and demonstrates how a dedicated open-source data runtime like Coral optimizes API calls, reduces token bloat, and retains derived enterprise intelligence.
## Atmosphere & style
The presentation is technical, strategic, and pragmatic, delivered with the clear, measured authority of an enterprise tech founder. Henderson presents a reasoned architectural argument rather than a flashy pitch, using concrete benchmarks, code-level breakdowns, and cost-comparison tables to make his point. The tone is encouraging and focused on developer empowerment, giving viewers a clear sense that building custom, highly accurate internal agents is well within reach using modern open-source tools.
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) Enterprises should build and own their AI agent architectures in-house rather than renting vertical SaaS bots to maintain control, accuracy, and cost efficiency.
- [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) Internal agent ownership is built on three core pillars: higher accuracy via deep data access, lower variable operational costs, and data sovereignty.
- [06:46](https://www.youtube.com/watch?v=VXJepWE1CwM&t=406s) The most accurate agents require full access to sensitive enterprise data sources, which companies are often unwilling to grant to third-party SaaS vendors.
- [06:46](https://www.youtube.com/watch?v=VXJepWE1CwM&t=406s) In a blind benchmark, a simple in-house AI SRE agent built with open-source tools drastically outperformed Datadog Bits AI in incident diagnosis accuracy at a fraction of the cost.
- [08:59](https://www.youtube.com/watch?v=VXJepWE1CwM&t=539s) A modern enterprise agent architecture consists of five modular, swappable components: UI, agent harness, model, data runtime, and data sources.
- [08:59](https://www.youtube.com/watch?v=VXJepWE1CwM&t=539s) The data runtime acts as an essential orchestration layer that mediates access control, unifies queries across tools, and optimizes data retrieval.
- [11:28](https://www.youtube.com/watch?v=VXJepWE1CwM&t=688s) Standard direct Model Context Protocol (MCP) integrations can lead to high context window bloat and excessive API overhead during complex retrieval tasks.
- [11:28](https://www.youtube.com/watch?v=VXJepWE1CwM&t=688s) Using Coral's data runtime instead of standard direct MCP integrations significantly lowers query costs and token consumption while improving accuracy.
- [11:28](https://www.youtube.com/watch?v=VXJepWE1CwM&t=688s) In-house agents build long-term value by compounding derived intelligence—such as schema mappings, permissions, and query optimizations—within the enterprise.
## Detailed walkthrough
Here is a detailed, faithful walkthrough of the transcript.
---
[00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) The Case for Building Enterprise Agents In-House
Matt Henderson, co-founder and CEO of Google Ventures-funded startup Coral, introduces the core philosophy behind building enterprise AI agents internally using modular, switchable, and generalizable tools. Headquartered in London with a team in Switzerland, Coral provides an open-source data retrieval runtime designed to solve complex enterprise data access challenges. Rather than buying proprietary, black-box SaaS bots, Henderson argues that composing agents internally offers immense strategic, financial, and operational advantages. Throughout the session, he illustrates this using an AI Site Reliability Engineering (SRE) agent as a practical, worked example, pointing viewers toward an open-source GitHub repository where they can test the implementation themselves.
```
+-------------------------------------------------+
| USER INTERFACE |
| (Slack / Interfaces) |
+-----------------------+-------------------------+
|
v
+-------------------------------------------------+
| AGENT HARNESS |
| (Pydantic AI / Prompts) |
+-----------+-------------------------+-----------+
| |
v v
+-----------------------+ +-----------------------+
| DATA RUNTIME | | MODEL CHOICE |
| (Coral Query Engine) | | (Anthropic / Other) |
+-----------+-----------+ +-----------------------+
|
v
+-------------------------------------------------+
| DATA SOURCES |
| (Slack, GitHub, Observability, Notion) |
+-------------------------------------------------+
```
- **Core thesis:** Enterprises should own and control their agent architecture rather than renting locked-down vertical SaaS solutions.
- **Three foundational pillars for ownership:**
- **Accuracy:** The most accurate agent is the one granted full, comfortable access to sensitive enterprise data sources (e.g., production databases). Internal ownership allows deep inspection and guarantees data never leaves the corporate environment.
- **Economics:** Internal builds carry a modest initial fixed setup cost, but deliver dramatically lower variable operational expenses and grant complete control over cost dials.
- **Sovereignty:** Enterprises retain the long-term derived intelligence—such as schema mappings, domain patterns, past queries, and optimizations—preventing vendor lock-in.
---
[04:06](https://www.youtube.com/watch?v=VXJepWE1CwM&t=246s) Benchmarking an AI SRE Agent Against SaaS Alternatives
To validate the internal build model, Coral benchmarked a straightforward AI SRE agent against Datadog Bits AI in a blind test. Triggered directly within Slack, the internal agent investigated incoming observability alerts by stating a plan and gathering context across the organization's toolchain. When evaluated on real-world incident resolution, the internally built agent dramatically outperformed Datadog Bits AI in diagnostic accuracy while running at a tiny fraction of the cost.
- **Data advantage:** The internal agent succeeded because it possessed broader data access, including deep repository analysis, past incident context across Slack channels, and internal documentation (such as engineering Notion pages).
- **Access boundaries:** Enterprises are naturally hesitant to grant third-party SaaS vendors access to 20+ sensitive tools, source code repositories, or production databases, artificially crippling external bots.
- **Cost performance:** Operating exclusively on direct token usage, the internal agent proved significantly cheaper using Anthropic models, with even further cost reductions achievable when paired with models like DeepSeek.
---
[08:59](https://www.youtube.com/watch?v=VXJepWE1CwM&t=539s) Modular Architecture and the Data Runtime
Henderson breaks down a modern enterprise agent into five switchable, modular components: the user interface, the agent harness, the swappable foundation model, the data runtime, and the underlying data sources. In the benchmarked SRE implementation, the setup utilized Slack for the interface, Pydantic AI for the inspectable agent harness, Anthropic (or DeepSeek) via an environment variable for the model, and Coral for the data runtime.
The data runtime serves as an essential, often overlooked orchestration layer. It mediates access controls and API permissions between the agent harness and sensitive systems while maintaining derived intelligence about how systems and data relate. Within Coral, a specialized query engine acts similarly to a database, unifying queries across disparate data sources and minimizing unnecessary API roundtrips.
- **Modular components:**
- **UI Interface:** Slack (handles incident alerts and developer interaction).
- **Agent Harness:** Pydantic AI (manages system prompts, execution loops, and memory inspectability).
- **Model Layer:** Swappable via environment variables (Anthropic Claude, DeepSeek, etc.).
- **Data Runtime:** Coral open-source core (manages data retrieval planning and access control).
- **Data Sources:** Observability tools, GitHub repos/PRs, Slack history, and Notion docs.
---
[11:28](https://www.youtube.com/watch?v=VXJepWE1CwM&t=688s) Optimizing Data Retrieval Costs and Performance
To demonstrate the efficiency of a dedicated data runtime, Henderson contrasts standard Model Context Protocol (MCP) data connections against Coral’s query engine using a project management task in Linear. When Claude Code executes a complex issue search across Linear via standard direct MCP integrations, it repeatedly calls the paginated Linear API to find and aggregate data. This fills the context window with superfluous payload data and drives up the interaction cost to $0.71.
By routing the exact same query through Coral's data runtime, the cost drops to $17.17 (a 76% reduction). Coral reduces context bloat and eliminates excess API overhead, providing the exact efficiency optimizations usually hidden inside expensive $1M+ commercial black-box agents in an unbundled, fully inspectable open-source format.
- **Direct MCPs:** High execution cost ($0.71 per query) due to redundant API calls and unoptimized context payload size.
- **MCP Gateways:** Marginally improves accuracy over direct connections but increases overall token expenses.
- **Coral Query Engine:** Delivers the highest accuracy with minimal token consumption by optimizing API execution and pruning irrelevant context.
- **Derived Value:** Storing memory, permissions, and query optimizations within your own infrastructure ensures that each agent execution compounds the long-term value of the enterprise's internal AI asset.
## Notable quotes
> [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) The answer isn’t renting another vertical SaaS bot. It should be an agent architecture you own and control. — Matt Henderson
> [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) The best performing agent is the one with the best access to all of your relevant data — Matt Henderson
> [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) wide-ranging access is best suited to agents you can fully inspect and control. — Matt Henderson
> [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) Internally built agents can achieve the highest accuracy and cost efficiency, while also providing strategic control. — Matt Henderson
> [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) You can own the asset that compounds in value from your usage — Matt Henderson
> [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) If that learning sits outside the enterprise, then switching vendors can mean starting over cold. If it stays inside, each agent run makes the next one stronger. — Matt Henderson
## Mentioned
Matt Henderson, Coral, Google Ventures, Slack, Datadog Bits AI, Anthropic, Claude, DeepSeek, Pydantic AI, Linear, Notion, GitHub, Model Context Protocol
## Video description
Matt Henderson - CEO, Coral
How should you deploy agents that can deeply understand your company’s fragmented data sources? The answer isn’t renting another vertical SaaS bot. It should be an agent architecture you own and control.
This session shows how to build enterprise agents as simple yet powerful modular systems. The architecture is broken into five switchable parts: the user interface where work begins, the agent harness that defines prompts and policies, the model that can be swapped, the data runtime that plans and executes retrieval, and the data sources that hold operational truth.
Internally built agents can achieve the highest accuracy and cost efficiency, while also providing strategic control. The best performing agent is the one with the best access to all of your relevant data, and wide-ranging access is best suited to agents you can fully inspect and control.
Using a devops agent that investigates alerts as the worked example, we will walk through a practical implementation using proven open source software and easily switchable models. An alert arrives in Slack; the agent states a plan; it queries observability data, error tracking, repo analysis, code changes, prior incident context; then it returns a concise diagnosis with evidence and mitigation options. Similar implementations can support security investigations, customer escalations, churn analysis, billing operations, sales operations, business intelligence, and other use cases where answers require data from many tools and systems.
The tools available now, from agent harnesses to agent data retrieval, transform the trade-offs in build-versus-buy enterprise AI decisions. You can own the asset that compounds in value from your usage; the derived intelligence mapping your systems, schemas, permissions, past queries, traces, and domain-specific patterns. If that learning sits outside the enterprise, then switching vendors can mean starting over cold. If it stays inside, each agent run makes the next one stronger.
Coral SRE Agent故障处理表现超越Datadog Bits AI
拥有完整数据访问权限的自研企业级AI智能体表现优于第三方SaaS替代方案，同时能降低运营检索成本。
Matt Henderson阐述了企业自研AI智能体而非租用第三方SaaS方案在战略、财务及运营层面的充分理由。他以AI网站可靠性工程（SRE）智能体为实际案例，展示了自研方案在准确率上超越Datadog Bits AI等商业竞品，且成本仅为其一小部分。演讲将模块化智能体架构拆解为五个可替换组件，并演示了Coral等专用开源数据运行时如何优化API调用、削减Token冗余并留存派生的企业情报。
Coral 联合创始人兼 CEO Matt Henderson 提出，企业应自主构建内部 AI Agent 架构而非租赁垂直 SaaS 机器人，通过掌握数据主权、降低长期可变运维成本并深度接入敏感数据来提升准确率。 (0:04)
在一项针对事件诊断的盲测中，基于开源工具构建的自研 AI SRE Agent 准确率大幅超越 Datadog Bits AI，且运行成本仅为后者的一小部分，核心优势在于其能安全访问仓库代码及内部文档。 (4:06)
现代企业 Agent 架构可解构为五大模块化组件：UI 交互层（如 Slack）、Agent 框架（如 Pydantic AI）、可插拔大模型（如 Anthropic 或 DeepSeek）、数据运行时（如 Coral）以及底层数据源。 (8:59)
相比标准 MCP 直连导致的上下文膨胀和高额 API 开销，Coral 的数据运行时通过优化查询计划与修剪冗余上下文，将复杂检索成本从每次 0.71 美元大幅降至 0.17 美元。 (11:28)
Reading summary
Matt Henderson, co-founder and CEO of Coral, argues that enterprises should compose AI agents in-house using modular, open-source architectures rather than renting proprietary SaaS solutions, citing significant gains in data access, operating costs, and long-term sovereignty.
The Core Pillars: Accuracy, Cost, and Sovereignty (0:04)
Henderson presents three foundational pillars to justify building enterprise agents internally instead of purchasing black-box vertical SaaS bots. The primary driver of agent accuracy is access to comprehensive, sensitive data sources, such as production databases and private repositories, which enterprises are generally unwilling to expose to external SaaS vendors. Retaining the agent inside the corporate perimeter allows organizations to inspect execution deeply while ensuring internal data never leaves.
From an economic standpoint, Henderson asserts that an in-house build incurs a modest fixed setup cost but provides dramatically lower variable operational costs, along with direct control over spending dials. Furthermore, data sovereignty ensures that derived organizational intelligence—including schema mappings, domain patterns, past query paths, and system optimizations—remains proprietary institutional knowledge rather than compounding value inside a vendor's locked platform.
Benchmarking In-House SRE Agents Against SaaS (4:06)
To test the viability of internal builds, Coral evaluated an in-house Site Reliability Engineering (SRE) agent against Datadog Bits AI in a blind test. Triggered via Slack alerts, the internal agent investigated real-world incidents by generating investigation plans and gathering context across the organization's existing toolchain. According to Henderson, the internally built agent dramatically outperformed Datadog Bits AI in diagnostic accuracy while operating at a tiny fraction of the cost.
Henderson attributes this performance gap directly to data access boundaries. While enterprises hesitate to grant third-party SaaS tools access to broad codebases, Slack channels, and internal Notion documentation, an internal agent can query across all of them. Running on direct token usage via models like Anthropic Claude or DeepSeek, the internal agent avoided SaaS subscription markups while diagnosing issues with broader context.
Modular Stack Design and the Data Runtime (8:59)
Henderson structures enterprise agents into five switchable components: the user interface, the agent harness, the foundation model layer, the data runtime, and the underlying data sources. In Coral's benchmarked implementation, Slack handled developer interactions, Pydantic AI served as an inspectable harness managing prompts and execution loops, and the model was swappable via environment variables between providers like Anthropic and DeepSeek.
The system relies on Coral's open-source query engine as a dedicated data runtime layer situated between the agent harness and sensitive data stores. Henderson describes the runtime as an orchestration engine that unifies queries across disconnected tools, regulates permissions, and reduces unnecessary API roundtrips, allowing enterprises to swap out models or user interfaces without rebuilding their data retrieval infrastructure.
Optimizing API Overhead and Retrieval Costs (11:28)
Henderson contrasts direct Model Context Protocol (MCP) tool integrations with a dedicated data runtime using a Linear issue search benchmark conducted via Claude Code. Under standard direct MCP connections, the agent makes multiple paginated API calls to aggregate data, which fills the model's context window with extraneous payload details and results in a per-query cost of $0.71.
Routing the identical query through Coral's query engine pruned context bloat and eliminated redundant API requests, lowering the execution cost to $0.17—a 76% expense reduction. Henderson argues that routing queries through a dedicated data runtime delivers the efficiency optimizations typically buried inside expensive proprietary agents, allowing teams to preserve context window capacity and compound query optimizations within their own infrastructure.
While Henderson maintains that internally composed agents outperform vertical SaaS across diagnostic accuracy and operating costs, the approach assumes an enterprise has the technical capability to deploy, integrate, and maintain its own orchestration layers and modular components.
## Background
本内容由 Ai4 频道于 2026 年 8 月 18 日发布在 YouTube 平台上。视频记录了 Coral 联合创始人兼 CEO Matt Henderson 的主题演讲，主要探讨企业为何不应租用封闭的垂直 SaaS 机器人，而应通过解耦的模块化架构在内部自研部署企业级智能体（Enterprise Agents），以实现对碎片化数据的高效整合与战略掌控。
## TL;DR
演讲指出，自主构建企业级智能体具备准确度、经济效益和数据主权三大核心优势，因为企业更愿意向可审计的内部系统开放全量核心数据。通过将自研 AI SRE 智能体与商业黑盒方案 Datadog Bits AI 进行盲测对比，证明了跨多源数据访问与解耦架构在诊断准确率与调用成本上的巨大优势。演讲详细拆解了由 UI 交互层、智能体控制框架（如 Pydantic AI）、可替换模型、数据运行时（Coral）及底层数据源构成的五层解耦架构，并阐明统一查询引擎如何大幅精简 Token 消耗并沉淀具有复利价值的企业派生智慧。
## Atmosphere & style
整场演讲风格严谨务实、直击痛点，充盈着资深技术创业者的架构洞察与工程实战气息。讲者叙述条理清晰且节奏紧凑，摒弃了空洞的 AI 营销话术，而是通过详实的基准测试数据、单次查询成本对比及解耦架构图进行层层推导。听众能够深刻感受到一种倡导“打破黑盒、重揽技术主权”的技术自信与工程师实用主义氛围。
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) 企业应当避免租赁市面上封闭的垂直类 SaaS 智能体，转而利用通用且可插拔的模块化组件在内部自研企业级智能体。
- [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) 自主掌握智能体拥有权的三大核心支柱是准确度（Accuracy）、经济效益（Economics）与数据主权（Sovereignty）。
- [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) 最强大的智能体永远是企业最放心授予敏感数据权限的智能体；内部可审计的自研智能体能够接入更广泛的生产数据，从而大幅提升准确度。
- [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) 自研智能体前期虽有固定配置成本，但可变运行成本极低，且企业可以自主掌控 Token 消耗与模型调用等成本杠杆。
- [04:06](https://www.youtube.com/watch?v=VXJepWE1CwM&t=246s) 在 Slack 告警调查的盲测中，自研 AI SRE 智能体凭借对代码库、历史复盘、Slack 讨论等多源数据的深度接入，在准确率和成本上均大幅超越 Datadog Bits AI。
- [07:37](https://www.youtube.com/watch?v=VXJepWE1CwM&t=457s) 企业智能体架构可解耦为五个可替换模块：用户界面（UI）、控制框架（Agent Harness）、模型层（Model）、数据运行时（Data Runtime）与底层数据源（Data Sources）。
- [07:37](https://www.youtube.com/watch?v=VXJepWE1CwM&t=457s) 采用解耦架构后，控制框架（如 Pydantic AI）与底层大模型（如 Anthropic、DeepSeek）可随技术迭代随时热插拔替换。
- [11:28](https://www.youtube.com/watch?v=VXJepWE1CwM&t=688s) 数据运行时（Data Runtime）充当安全权限中介并沉淀派生数据，有效解决了传统智能体通过直连 MCP 进行复杂查询时上下文冗余与成本高昂的问题。
- [11:28](https://www.youtube.com/watch?v=VXJepWE1CwM&t=688s) 引入具备聚合与过滤能力的统一查询引擎（如 Coral），可将单次典型任务查询成本从 0.71 美元大幅降低至 0.17 美元。
- [16:07](https://www.youtube.com/watch?v=VXJepWE1CwM&t=967s) 智能体长期运行沉淀的架构映射、系统理解和执行记忆构成了企业的核心“派生智慧”（Derived Intelligence），保留在内部才能形成持续复利效应。
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) 自研企业级智能体的核心价值与三大支柱
在企业智能体（Enterprise Agents）的构建与部署上，企业不应再去租赁市面上封闭的垂直类 SaaS 机器人，而是应该通过通用且可替换、可插拔的模块化工具进行自研搭建。演讲者 Matt Henderson（Coral 联合创始人兼 CEO，总部位于伦敦、在瑞士设有团队，由 Google Ventures 领投）指出，过去一年技术门槛已大幅下降，企业自主掌握智能体架构不仅在战略上更具优势，而且在准确率和成本效益上也显著优于第三方黑盒方案。
自主掌握智能体拥有权（Ownership）有三大核心支柱：
1. **准确度（Accuracy）**：市面上最强大的智能体，永远是那个企业最放心授予敏感数据访问权限的智能体。如果智能体完全在企业内部构建、运行且全程可审查，企业就更愿意向其开放生产数据库或核心敏感数据，而不用担心数据流向外部 SaaS 厂商；访问的数据越深越广，智能体的输出表现就越好。
2. **经济效益（Economics）**：虽然自主搭建需要承担一定的固定成本与初始配置时间，但在过去一年中，构建高可用、高效率智能体的门槛断崖式下跌。换来的是极低的可变成本（主要是底层的 Token 消耗等基础设施费用），企业还能亲自调节成本杠杆，无需向外部黑盒软件支付巨额溢价。
3. **数据主权（Sovereignty）**：随着智能体在业务中的持续使用，所积累的上下文、系统映射、架构理解和交互优化将沉淀为企业的战略资产。未来企业无论更换哪家底层大模型供应商或数据系统，这些长期积累的优化价值依然完整保留在企业内部，避免被外部厂商绑定。
```mermaid
flowchart TD
accTitle: 自主拥有企业级智能体的三大支柱
subgraph Ownership["自主拥有智能体 (Agent Ownership)"]
direction TB
Acc["1. 准确度 (Accuracy)<br/>数据权限开放更广<br/>内部可审计、不出域"]
Econ["2. 经济效益 (Economics)<br/>固定投入换低边际成本<br/>基础设施支出可控"]
Sov["3. 数据主权 (Sovereignty)<br/>派生智慧长期沉淀<br/>避免外部供应商锁定"]
end
```
---
### [04:06](https://www.youtube.com/watch?v=VXJepWE1CwM&t=246s) 实战案例：自研 AI SRE 对比 Datadog Bits AI
为了验证内部搭建智能体的实际表现，Coral 团队构建了一个用于告警调查的 AI SRE 智能体，并在 Slack 生产环境中运行。他们将该智能体与主流的商业黑盒解决方案 Datadog Bits AI 进行了双盲基准测试（Blind Benchmark）。测试结果显示，自研智能体不仅在准确度上实现了大幅超越，在调用成本上也展现出惊人的经济性。
自研智能体大幅胜出的核心原因在于**更广泛的数据访问能力**。团队不仅让其读取监控数据，还接入了完整的代码仓库、历史告警相关的 Slack 频道讨论、既往故障复盘记录，甚至是工程师在 Notion 文档中记录的技术细节。现实中，客户或许愿意向某个 SaaS 厂商开放两三个数据源，但绝不愿意将二十多个数据源、全量代码库及生产数据库都全盘托出。在成本方面，自研方案仅需支付纯 Token 成本。即使在测试中使用 Anthropic 的模型，其费用仍远低于商业套件，若切换至 DeepSeek 等高性价比模型，成本优势更会呈数量级放大。
- **盲测对比要点**：自研 AI SRE 相比 Datadog Bits AI 实现了更高的诊断准确率与极大幅度的成本压缩。
- **关键数据接入**：GitHub 代码库、Pull Requests、历史故障 Slack 频道上下文、工程师 Notion 笔记、可观测性监控指标。
- **重型算力归属**：绝大多数智能体能力直接来自前沿基础大模型（Frontier Model）与企业内部数据的结合，第三方黑盒封装的神秘优化远不如优质数据接入来得实在。
---
### [07:37](https://www.youtube.com/watch?v=VXJepWE1CwM&t=457s) SaaS 智能体与自研架构的战略对比及模块化解耦
在面对企业级用例时，外部 SaaS 智能体的 Prompt（提示词）完全不透明，数据访问范围与方式不受企业控制，且从长期运行中提取的知识经验完全被锁定在供应商系统中，一旦更换厂商就意味着“一切从零开始”。相比之下，自研智能体可以随意调度前沿模型和通用 Agent Harness（如 Pydantic AI、Claude Code、Codex 等），在保留极高透明度与审查能力的同时，把记忆（Memory）与数据运行时（Data Runtime）完全保留在自有环境内。
以开源的 AI SRE 智能体为例，其架构由五个高度解耦、可热插拔的模块构成：
1. **用户交互层（UI Interface）**：工作流发起的界面，支持在 Slack 中自动监听可观测性告警并进行对话式提问。
2. **智能体控制框架（Agent Harness）**：负责定义 Prompt、执行循环与记忆管理。团队选用了开源且完全可审查的 Pydantic AI。
3. **可替换模型层（Swappable Model）**：通过环境变量灵活切换，支持 Anthropic 模型、DeepSeek 等多种底层 LLM。
4. **数据运行时（Data Runtime）**：负责规划、协调并执行检索操作的核心中枢，承载 API Scope 权限管理与知识派生逻辑，此部分由 Coral 引擎驱动。
5. **底层数据源（Data Sources）**：包含存储真实业务状态的各类系统（如 GitHub、Slack、可观测性平台、数据库等）。
```mermaid
flowchart LR
accTitle: 企业智能体五层模块化解耦架构
subgraph Ingest["交互与编排"]
UI["用户界面 (UI)<br/>Slack 告警与提问"] --> Harness["智能体控制框架 (Harness)<br/>Pydantic AI (Prompt/Loop)"]
end
subgraph Core["智能与调度"]
Harness <--> Model["基础模型层 (Model)<br/>Anthropic / DeepSeek"]
Harness <--> Runtime["数据运行时 (Data Runtime)<br/>Coral 查询引擎 / 权限中介"]
end
subgraph Storage["数据底座"]
Runtime <--> Sources["底层数据源 (Data Sources)<br/>GitHub / Slack / 可观测系统"]
end
```
---
### [11:28](https://www.youtube.com/watch?v=VXJepWE1CwM&t=688s) 数据运行时（Data Runtime）与统一查询引擎的提效机制
黑盒智能体服务商经常声称产品能“随使用不断自我强化”，这种长期学习实质上体现在两个方面：一是基于已处理案例的历史记忆沉淀；二是逐渐理解企业数据源的分布位置及跨源关联关系。自研体系中的“数据运行时”（Data Runtime）正是承载这一过程的载体，它扮演着安全权限中介的角色（统一托管各类 API Token 与访问范围），并持续沉淀用于高效检索的“派生数据”（Derived Data）。
传统智能体在对接工具（如通过标准 MCP 协议连接项目管理软件 Linear）时，若要查询或聚合多个 Issue，往往会陷入“反复盲目调用 API”的循环。由于存在分页与多次筛选，智能体会拉取大量无用的上下文，导致单次简单查询成本高达 0.71 美元。而在引入具备数据库特性的统一查询引擎（Query Engine，如 Coral）后：
- 查询引擎代为处理底层的跨数据源交互、数据过滤与分页聚合；
- 智能体上下文窗口避免被冗余无用的数据塞满，API 调用次数断崖式减少；
- 在完全相同的 Claude Code + Opus 组合下，单次任务成本直接从 0.71 美元骤降至 0.17 美元；
- 昂贵的黑盒智能体内部所隐藏的各类查询优化工程技巧，企业完全可以通过开源组件和解耦架构低成本复现。
| 方案模式 | 单次查询成本 | 准确度表现 | Token 消耗效率 | 架构特点 |
|:--- |:--- |:--- |:--- |:--- |
| **直接 MCP 直连** (Direct MCP) | 偏高 (~$0.71) | 良好 | 较低（拉取大量多余数据） | 简单但存在大量冗余 API 调用与分页开销 |
| **MCP / API 网关** (API Gateway) | 略高 | 略微提升 | 略微降低 | 增加集中路由管理，但缺乏深度查询优化 |
| **Coral 统一查询引擎** (Query Engine) | 极低 (~$0.17) | 显著提升 | 极高（精简上下文） | 统一抽象多源异构数据，具备聚合与记忆能力 |
---
### [16:07](https://www.youtube.com/watch?v=VXJepWE1CwM&t=967s) 沉淀企业核心派生智慧与开源实践
演说的尾声强调，企业在运行智能体过程中所沉淀的记忆、知识图谱、架构定义以及调试 Trace，构成了智能体带来的“派生智慧”（Derived Intelligence）。如果这些数据沉淀在外部平台，企业将永远受制于人；只有将其保存在企业可控的统一数据运行时中，每一次智能体的执行与交互才能为下一次调用赋能，让整体系统产生复利效应。
- **开源生态访问**：演示中提及的 AI SRE 开源实现以及用于高效数据检索的开源核心（Open-source Core）均已通过官方渠道开源，相关资源可访问 `withcoral.com` 及其 GitHub 代码仓库进行验证体验。
- **总结论点**：自主构建绝非重新发明轮子，而是通过解耦的模块化组件将控制权收回企业内部，在实现超高准确度与极低运行成本的同时，牢牢守住企业的数据资产与战略主权。
## Notable quotes
> [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) 市面上最强大的智能体，永远是那个企业最放心授予敏感数据访问权限的智能体。 — Matt Henderson
> [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) 如果智能体完全在企业内部构建、运行且全程可审查，企业就更愿意向其开放生产数据库或核心敏感数据，而不用担心数据流向外部 SaaS 厂商；访问的数据越深越广，智能体的输出表现就越好。 — Matt Henderson
> [00:04](https://www.youtube.com/watch?v=VXJepWE1CwM&t=4s) 随着智能体在业务中的持续使用，所积累的上下文、系统映射、架构理解和交互优化将沉淀为企业的战略资产。 — Matt Henderson
> [04:06](https://www.youtube.com/watch?v=VXJepWE1CwM&t=246s) 自研智能体大幅胜出的核心原因在于更广泛的数据访问能力。 — Matt Henderson
> [04:06](https://www.youtube.com/watch?v=VXJepWE1CwM&t=246s) 现实中，客户或许愿意向某个 SaaS 厂商开放两三个数据源，但绝不愿意将二十多个数据源、全量代码库及生产数据库都全盘托出。 — Matt Henderson
> [04:06](https://www.youtube.com/watch?v=VXJepWE1CwM&t=246s) 绝大多数智能体能力直接来自前沿基础大模型（Frontier Model）与企业内部数据的结合，第三方黑盒封装的神秘优化远不如优质数据接入来得实在。 — Matt Henderson
> [07:37](https://www.youtube.com/watch?v=VXJepWE1CwM&t=457s) 外部 SaaS 智能体的 Prompt（提示词）完全不透明，数据访问范围与方式不受企业控制，且从长期运行中提取的知识经验完全被锁定在供应商系统中，一旦更换厂商就意味着“一切从零开始”。 — Matt Henderson
> [11:28](https://www.youtube.com/watch?v=VXJepWE1CwM&t=688s) 昂贵的黑盒智能体内部所隐藏的各类查询优化工程技巧，企业完全可以通过开源组件和解耦架构低成本复现。 — Matt Henderson
> [16:07](https://www.youtube.com/watch?v=VXJepWE1CwM&t=967s) 如果这些数据沉淀在外部平台，企业将永远受制于人；只有将其保存在企业可控的统一数据运行时中，每一次智能体的执行与交互才能为下一次调用赋能，让整体系统产生复利效应。 — Matt Henderson
> [16:07](https://www.youtube.com/watch?v=VXJepWE1CwM&t=967s) 自主构建绝非重新发明轮子，而是通过解耦的模块化组件将控制权收回企业内部，在实现超高准确度与极低运行成本的同时，牢牢守住企业的数据资产与战略主权。 — Matt Henderson
## Mentioned
Matt Henderson, Coral, Google Ventures, Datadog, Datadog Bits AI, Slack, GitHub, Notion, Anthropic, DeepSeek, Pydantic AI, Claude Code, Codex, Linear, MCP
## Video description
Matt Henderson - CEO, Coral
How should you deploy agents that can deeply understand your company’s fragmented data sources? The answer isn’t renting another vertical SaaS bot. It should be an agent architecture you own and control.
This session shows how to build enterprise agents as simple yet powerful modular systems. The architecture is broken into five switchable parts: the user interface where work begins, the agent harness that defines prompts and policies, the model that can be swapped, the data runtime that plans and executes retrieval, and the data sources that hold operational truth.
Internally built agents can achieve the highest accuracy and cost efficiency, while also providing strategic control. The best performing agent is the one with the best access to all of your relevant data, and wide-ranging access is best suited to agents you can fully inspect and control.
Using a devops agent that investigates alerts as the worked example, we will walk through a practical implementation using proven open source software and easily switchable models. An alert arrives in Slack; the agent states a plan; it queries observability data, error tracking, repo analysis, code changes, prior incident context; then it returns a concise diagnosis with evidence and mitigation options. Similar implementations can support security investigations, customer escalations, churn analysis, billing operations, sales operations, business intelligence, and other use cases where answers require data from many tools and systems.
The tools available now, from agent harnesses to agent data retrieval, transform the trade-offs in build-versus-buy enterprise AI decisions. You can own the asset that compounds in value from your usage; the derived intelligence mapping your systems, schemas, permissions, past queries, traces, and domain-specific patterns. If that learning sits outside the enterprise, then switching vendors can mean starting over cold. If it stays inside, each agent run makes the next one stronger.
[Source](https://www.youtube.com/watch?v=VXJepWE1CwM)
Source quotes
[0:04] Matt Henderson: 市面上最强大的智能体，永远是那个企业最放心授予敏感数据访问权限的智能体。
[0:04] Matt Henderson: 如果智能体完全在企业内部构建、运行且全程可审查，企业就更愿意向其开放生产数据库或核心敏感数据，而不用担心数据流向外部 SaaS 厂商；访问的数据越深越广，智能体的输出表现就越好。
[0:04] Matt Henderson: 随着智能体在业务中的持续使用，所积累的上下文、系统映射、架构理解和交互优化将沉淀为企业的战略资产。
[4:06] Matt Henderson: 自研智能体大幅胜出的核心原因在于更广泛的数据访问能力。
[4:06] Matt Henderson: 现实中，客户或许愿意向某个 SaaS 厂商开放两三个数据源，但绝不愿意将二十多个数据源、全量代码库及生产数据库都全盘托出。
[4:06] Matt Henderson: 绝大多数智能体能力直接来自前沿基础大模型（Frontier Model）与企业内部数据的结合，第三方黑盒封装的神秘优化远不如优质数据接入来得实在。
[7:37] Matt Henderson: 外部 SaaS 智能体的 Prompt（提示词）完全不透明，数据访问范围与方式不受企业控制，且从长期运行中提取的知识经验完全被锁定在供应商系统中，一旦更换厂商就意味着“一切从零开始”。
[11:28] Matt Henderson: 昂贵的黑盒智能体内部所隐藏的各类查询优化工程技巧，企业完全可以通过开源组件和解耦架构低成本复现。
[16:07] Matt Henderson: 如果这些数据沉淀在外部平台，企业将永远受制于人；只有将其保存在企业可控的统一数据运行时中，每一次智能体的执行与交互才能为下一次调用赋能，让整体系统产生复利效应。
[16:07] Matt Henderson: 自主构建绝非重新发明轮子，而是通过解耦的模块化组件将控制权收回企业内部，在实现超高准确度与极低运行成本的同时，牢牢守住企业的数据资产与战略主权。
Source quotes
[0:04] Matt Henderson: The answer isn’t renting another vertical SaaS bot. It should be an agent architecture you own and control.
[0:04] Matt Henderson: The best performing agent is the one with the best access to all of your relevant data
[0:04] Matt Henderson: wide-ranging access is best suited to agents you can fully inspect and control.
[0:04] Matt Henderson: Internally built agents can achieve the highest accuracy and cost efficiency, while also providing strategic control.
[0:04] Matt Henderson: You can own the asset that compounds in value from your usage
[0:04] Matt Henderson: If that learning sits outside the enterprise, then switching vendors can mean starting over cold. If it stays inside, each agent run makes the next one stronger.
Original transcript
[0:04] Hey everyone. So, I'm going to talk to
you today about building agents in-house,
[0:09] composing them in-house using generalizable tools,
and using tools that are replaceable, switchable.
[0:17] And there's a few reasons why you should
do that that I'm going to describe,
[0:21] and also a bit about how you should do it. And at
some different points during the presentation, I'm
[0:28] going to describe an example of an AISRE agent.
Um one of many examples, but this particular one
[0:36] uh it's useful as a worked example, and then we've
got a link to an open-source repo that you can use
[0:41] to go and just try implementing it yourself if
you want to give it a try. Um my name's Matt. I'm
[0:48] the co-founder and CEO of a startup called
Coral. Coral is a Google Ventures-funded
[0:55] startup. We're headquartered in London. Uh
we've got a team in Switzerland, as well.
[1:00] Um we provide a sort of a a part of the puzzle.
We have an open-source core that helps with the
[1:06] data retrieval part of the agent implementation.
So, I'm going to talk a little bit about that, um
[1:12] but mostly I'm going to talk about these different
interchangeable parts that enable you to compose
[1:16] agents internally, why that's strategically better
for you, why it's more cost-efficient for you,
[1:22] why it can be more accurate, as well, for your
agents, as well. So, uh let's jump in. So,
[1:29] first up, why ownership matters. And there's kind
of three main reasons here. So, one is accuracy,
[1:36] and the simple thing about accuracy is the best
agent is the one that you feel most comfortable
[1:44] giving access to all of your sensitive
data sources. And within an enterprise,
[1:51] you feel far much better about giving access to
a production database or some sensitive source,
[1:58] if you can inspect and control exactly how that
access is happening, if you can see what the
[2:05] agent's doing, and if you know that it's not going
out of your environment to a different vendor.
[2:12] And so, we've seen time and again that
uh agents that are composed internally
[2:18] often end up getting granted more and additional
data sources that give them advantages.
[2:23] Uh and I'll I'll talk more about an example of
that as well. Um second reason is economics. So,
[2:29] when you uh compose the agent internally, you
take on a bit of fixed cost, some implementation
[2:37] setup time. Um a year ago, I would have said
go work with one of the 100 companies in the
[2:44] exhibition hall that will sell you a black box
agent that will somewhat work out of the box.
[2:50] Um but what's happened over the past year is
that the the implementation hurdle of building
[2:56] a really high-performing, highly efficient agent
has come way, way down over time such that uh
[3:05] it's it's much easier and worthwhile to do it now.
And in exchange, you get lower variable costs.
[3:10] You get agents where uh not only do you only
get exposed to then the infrastructure costs,
[3:17] but also you have control of the dials to
tweak those infrastructure costs as well.
[3:23] And then the third reason is sovereignty.
This one's a bit more sort of fuzzy,
[3:26] but but essentially uh you get to retain the
value that accrues from the way that your usage
[3:36] drives optimizations in the agent over time. And
that is something that becomes a strategic asset.
[3:41] It's something that means that in the future,
you can work with a different model provider,
[3:46] you can work with different data source
providers, you can work with any different
[3:50] vendor part of the puzzle, but still retain
the optimizations they've generated over time.
[3:57] Um so, I'll go into a bit more detail with each.
I mentioned a AI SRE agent. Um so, this is one
[4:06] with a fairly simple implementation that we
used ourselves as an example of it working.
[4:13] And we also benchmarked it. And And this is the
one that I'll um provide a link to the GitHub repo
[4:20] for. We benchmarked it against Datadog Bits AI.
What's that, sorry? Sure. Uh This one here? So,
[4:32] this is a screenshot of it running in our Slack.
And I'm going to talk a little bit about the
[4:39] different sort of pieces of what data sources it's
using and how it's working and so on in a moment.
[4:44] Um but when we blind benchmarked that
simple AI agent against Datadog Bits AI,
[4:55] it was dramatically more accurate and it
was like ridiculously cheaper. And And
[5:03] uh and so, part of the reason a big part of the
reason it was more accurate is because it had
[5:08] access to and could understand a lot more of our
repo. It had access to more of our Slack channels
[5:15] that had contextual information about past alerts
and past uh incident channels. It had access to
[5:22] uh a couple of other bits of information that
one of our engineers wrote on a Notion doc.
[5:27] It had like these little things that just we we
hadn't given in the setup to uh to to Datadog.
[5:34] And frankly, uh the more customers we
speak to, they don't mind having one, two,
[5:41] three data sources with a particular SaaS vendor,
but they don't want to give it 20 data sources.
[5:45] They don't want to give it their whole reaper,
they don't want to give it access to production
[5:49] databases and so on. And so, this was a lot
of the difference in accuracy. There was a
[5:55] a data retrieval technique that was helping to
drive accuracy as well. And and that's kind of
[6:01] where our product comes in. Um but but a lot of
it was simply the access to the good data sources.
[6:06] So, that's for accuracy and for cost efficiency,
um this was uh partly because the only thing we
[6:14] were paying for here was token costs. So, uh and
actually sometimes we use the model with uh with a
[6:21] uh we used the agent with DeepSeek, which is even
cheaper again. But this cost benchmark was with
[6:26] one of the um Anthropic uh models. And uh and
yet it still ended up being that much cheaper.
[6:35] Okay. So, I mentioned most accurate agent
is is often like the one that has the best
[6:40] data access. So, uh again in the exhibit
hall, people will talk about all their like
[6:46] uh sort of proprietary optimizations and so on.
But like most of the heavy lifting in an agent
[6:52] is done by the frontier model or your data. It's
it's the optimizations like help to make it a bit
[6:59] better, help to make it a bit more efficient. But
most of it's your data, most of it's the model,
[7:04] and then the just the accumulated lessons learned
from tons and tons of usage over time. And so,
[7:11] uh if you can have an agent that you get
breadth of data sources, it makes a difference.
[7:17] If you can have an agent that then also
gets to infer information from a bunch of
[7:22] those data sources through its usage uh like
you see in these derived intelligence boxes
[7:28] uh there, then then that makes a difference
as well. Um So, on the strategic advantage,
[7:37] uh you know, I mentioned about about sovereignty
and kind of accruing the the uh the the value
[7:43] from having control of your own agent. Um this
table sort of provides a comparison between uh
[7:51] if you were to get like a feature, I don't want to
just gang up on let's AI, but but uh like that but
[7:57] also for other use cases as well. But a SAS agent
um the prompt is opaque. The the way that the
[8:06] data access is given is out of your hands. Um the
the lessons that it accrues from all of your usage
[8:15] is locked into their product. If you ever want to
switch to a different vendor, then you're sort of
[8:21] starting from scratch. Um if you control it, you
can still use a frontier model. You can still use
[8:31] a general harness like uh Claude code or Codex or
something like that. Um but the uh the additional
[8:39] bits they provide a lot more inspectability
and the additional pieces around memory,
[8:45] around the data runtime, and so on, you get to uh
just store them in your own environment and in a
[8:51] way that you can reuse whenever you want. Uh so uh
the the kind of architecture of the agent. So here
[8:59] is where it starts getting a bit more concrete.
The example of the AI SRE that I showed before
[9:06] uh and I'll give you the the repo at the end has
this structure where there's a UI interface uh
[9:14] where it is responding to um to like
alerts, to to observability alerts in Slack.
[9:22] Um and you can also ask it questions in Slack
as well. So it has a UI piece. It then has um
[9:29] the actual agent harness itself. And so uh we
I'm going to provide some of the information
[9:36] on the different pieces of the technology we use,
but but in this example, we use Pydantic AI as an
[9:42] open-source agent harness. You could use anything.
Um and the the the prompt, the loop, the memory,
[9:50] uh one of the advantages of of harnesses like that
is that it's all very inspectable. You can plug in
[9:55] external bits to it if you want. The data runtime
is often not discussed much, um but but is where
[10:03] I'll dive into a bit more uh because it's it's
where our own product's expertise lies. Um and
[10:09] then uh you can often have a kind of a a swappable
um like environment variable for the model. That
[10:16] means that you can just switch between models
as you want to try using different uh different
[10:21] models. And then um in the case of the the example
project, it uses these different data sources. So,
[10:27] you can see um observability, uh GitHub repo,
and pull requests, um some contextual data from
[10:35] Slack history, stuff like that. Depending on your
use case, you'd have different data sources. Um
[10:41] but because even with this one use case, it covers
a range of sensitive data, you can see why it is
[10:47] an advantage in in having an agent that doesn't
require you to send all of that outside uh your
[10:53] environment. So, these were the pieces we used
in the in the given example, Slack, Pydantic AI,
[10:59] uh these two models were ones that we
started using back in uh May was when we um
[11:04] was when we did that benchmark. Um Carl is the is
the data runtime, which is our product. There's an
[11:11] open-source core, so it still sort of uh adheres
to this uh free, inspectable, and so on. Um and
[11:20] uh and then these were the different data sources
that we used as well. Um Okay, so data retrieval.
[11:28] Uh what happens in the data runtime? So, so
when you have when you use like a rented agent
[11:35] and they'll they'll say
like okay, it's a black box,
[11:38] but trust us it gets better over time and
it's going to learn from examples and so on.
[11:43] There is kind of two main different ways
that it learns over time. One is that
[11:49] the it learns from a kind of retained memory from
the examples that it's already worked through.
[11:57] And the other way is that it it works out more
information about your data sources and sort of
[12:03] where to find stuff and what relationships exist
between one data source and another data source
[12:10] and stuff like that. And so in the data runtime,
you could think of that as both a way that that
[12:19] mediates access controls between the agent and
your data sources. It will hold things like
[12:26] the API scopes to different data sources,
for example. And it will also store this
[12:32] like derived data that helps it to interrogate
the data sources more effectively. And then
[12:39] in in the case of Coral, it has this thing called
a query engine and what what that does is it works
[12:46] a bit like a database and it enables the agent
to query what are quite different data sources,
[12:51] but to do it in a more unified way and then this
software handles the actual interactions with the
[12:57] underlying data sources. So, that's a bit about
what the data runtime actually does and and here
[13:06] is why it makes a difference. So, this is the same
agent, it's Claude code using the same Opus model
[13:15] asking a question which relates to so
linear data. Linear is like a like Jira,
[13:21] it's project management software. So, we do a
ton of benchmarking. Uh we compared even just
[13:30] with the single data source, Claude code connected
to linear through an MCP, which many of you will
[13:36] know is just like a standard sort of form of
API connection from a data source to an agent.
[13:42] Uh when you ask Claude information about a linear
issue, then um or about multiple linear issues,
[13:50] it calls the linear API a ton of times. It needs
to work out where is the data I'm looking for.
[13:58] Uh sometimes it'll need to perform an aggregation.
Their API is kind of paginated, so you need to
[14:03] accumulate back information, and it costs 71
cents. And and that may not seem like much money,
[14:10] but if you have a lot of people with a
lot of agents doing a lot of queries,
[14:14] then this sure accumulates very quickly. And
uh so when uh we use the same data source,
[14:22] same model, same agent, same everything, same
question via Coral, it costs 17 cents instead.
[14:31] And the difference is that it didn't have
to make as many calls to the linear API.
[14:37] It didn't have to uh pull back as much superfluous
data into its context window of its agent. Um
[14:45] and uh and you can do this uh with a bit of open
source software that essentially just helps the
[14:51] agents to act more efficiently. Um and these
sorts of tricks are actually the same kind of
[14:57] tricks that, you know, uh the the the folks that
are spending a lot of money building black box
[15:04] agents and then selling them to you for millions
of dollars, they're using those techniques
[15:09] within their black box agent. And here you get
to use it in an unbundled way combined with any
[15:16] general agent, so that you get to uh sort of
you get to get the benefit of that efficiency.
[15:23] Um Here's how uh that aggregates up in terms
of um across many different examples. And
[15:34] here's how that aggregates across many examples.
So, direct MCPs means how does your agent perform
[15:41] in terms of accuracy and cost if you connect
the agent just directly to the underlying data
[15:48] sources. It still does pretty well. If you want
to use uh an API gateway and an MCP gateway, um
[15:54] then it will it'll make the costs the token costs
of the AI a little bit more expensive, but you get
[16:00] a tiny bit more accuracy. Um but our open source
query engine is a lot more accurate and a lot more
[16:07] token efficient. And then, I'm almost done. Uh you
get to inspect what's happening with the queries.
[16:16] These sort of white boxes uh the key bits
where you get to store memories and is one
[16:22] of the reasons why you get derived intelligence
that you can reuse across all of your agents. And
[16:30] just emphasizing the message that you want to
retain those accrued memories, those accrued
[16:36] optimizations across all of your agents so that
that becomes a strategic asset for your company.
[16:43] And then, if you go to uh if you go to
withcoral.com, there's a link to our GitHub.
[16:50] On GitHub, there's a link to the example
AI SRE if you want to give that one a try.
[16:55] Uh and there's also the open source core if you
want to try the data retrieval engine. And I'll
[16:59] be outside if you want some more questions, and I
hope you enjoy the rest of the event. Thank you.
