Hapax Architect Links Enterprise AI Wins to Codified Context Models

Beyond the Model: Building the Conditions for Enterprise Intelligence With Hapax — Ai4

Ai4

Standard document retrieval pipelines fail operational workflows unless companies replace passive filing cabinets with living, proprietary enterprise models that codify business rules and definitions.

AI-assisted summary of Beyond the Model: Building the Conditions for Enterprise Intelligence With Hapax — original source. Check the original for full context.

Source published:

Detailed notes

## Background Published on YouTube by Ai4 on August 17, 2026, this presentation features John De Oliveira, AI Architect at Hapax, discussing a systems perspective on enterprise AI. According to the description, the talk explores how seemingly disparate investments in RAG, enterprise memory, and knowledge governance address the same underlying problem, arguing that the greatest enterprise value lies in the conditions built around foundation models rather than the models themselves.

## TL;DR John De Oliveira explains why organizations using identical foundation models often see radically different business results, pointing to the intermediate context architecture as the primary differentiator. Rather than relying on naive RAG pipelines that fetch unchecked documents from a digital filing cabinet, enterprises must build an intentional 'enterprise model' that eliminates semantic ambiguity, maps systems of record, and codifies business policies. A customer support case study demonstrates how this structured approach prevents hallucinated approvals and properly enforces human-in-the-loop exception handling. Maintained like a continuous software development lifecycle, this proprietary enterprise context becomes a living, defensible moat that cannot be bought off the shelf.

## Atmosphere & style The presentation begins with lighthearted, self-deprecating humor before shifting into a crisp, pragmatic architectural breakdown. De Oliveira employs a vivid manufacturing campus metaphor to make abstract AI concepts intuitive and relatable for business and engineering leaders alike. The tone is refreshingly grounded and free of empty AI hype, offering a clear, methodical blueprint for operationalizing language models safely in enterprise environments.

## Key takeaways - [00:04](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=4s) Teams deploying the identical underlying foundation models frequently experience vastly different business outcomes due to disparities in their intermediate context architecture. - [00:04](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=4s) Enterprise AI can be conceptualized as a manufacturing campus where generic model intelligence acts as the raw material, transformed by the context layer into measurable business outcomes. - [02:07](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=127s) Conventional RAG pipelines function like passive document carts, packaging raw intelligence with unverified, potentially outdated attachments without checking for consistency or accuracy. - [02:07](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=127s) Organizations must transition from basic document retrieval to an intentional enterprise model that standardizes terminology, operational workflows, and authoritative systems of record. - [02:07](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=127s) Critical AI qualities such as grounding, accountability, traceability, and consistent execution cannot be bought out-of-the-box from model vendors; they must be engineered within enterprise conditions. - [04:56](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=296s) In complex workflows, naive RAG pipelines often produce polished but incorrect outputs by inferring business logic from stale documentation and bypassing human oversight checkpoints. - [04:56](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=296s) An upfront enterprise model enables AI agents to query live records, apply unambiguous policies, and cleanly escalate exception cases to human managers with full provenance. - [04:56](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=296s) Reliable automated reasoning and grounded action emerge systematically from clear business architecture rather than clever prompt engineering. - [07:50](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=470s) Developing an enterprise model is not a static documentation task but a continuous operational lifecycle of building, operating, inspecting failures, and iterating. - [07:50](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=470s) Future improvements in baseline foundation model intelligence will not automatically resolve internal organizational misalignment or context fragmentation. - [07:50](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=470s) A customized, living enterprise model that codifies decentralized institutional knowledge serves as a durable competitive moat that competitors cannot buy.

## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=4s) The Manufacturing Campus: Beyond Generic Model Intelligence

John De Oliveira opens with a tongue-in-cheek promise to completely fix every single issue with enterprise AI in ten minutes flat—before quickly dialing back the ambition: "Oh, wait. That's the 20-minute version. Sorry. Let me lower the bar a bit here." The real goal is to impart an enduring perspective shift. Over recent years, engineers and practitioners have become exceptionally skilled at building scaffolding around large language models—constructing harnesses, agent frameworks, context windows, and memory modules. Yet across enterprise deployments, teams deploying the exact same underlying foundation models frequently achieve vastly different business outcomes. If the raw intelligence entering these systems is identical, something critical in the intermediate architecture must be driving the divergence.

```mermaid flowchart LR accTitle: The Enterprise AI Manufacturing Campus subgraph InputStage["Raw Materials"] LLM["Generic Intelligence<br/>(Language Model)"] end subgraph MiddleStage["Intermediate Layer"] Context["The Context Building<br/>(Enterprise Model)"] end subgraph OutputStage["Finished Products"] Outcomes["Business Outcomes<br/>(Lower CAC, ARR Growth)"] end LLM --> Context Context --> Outcomes ```

To make abstract concepts like intelligence, growth, and costs tangible, De Oliveira introduces an analogy of a physical manufacturing campus designed to produce concrete business results, such as reduced customer acquisition cost (CAC) or month-over-month ARR growth. At the entry gate sits the raw material: generic intelligence delivered by the foundation model. At the final stage stand the enterprise AI applications delivering business value. Occupying the center of the campus is a large, unadorned building representing the context layer—the intermediate structure that organizations are currently rushing to assemble, though its internal workings vary wildly from one company to the next.

[02:07](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=127s) Peeling Back the Context Layer: The Document Cart vs. The Enterprise Model

Peeling the roof off a conventional context layer reveals a simplistic, assembly-line setup. Generic intelligence arrives, a worker pulls relevant-looking documents from a filing cabinet and places them onto a cart (retrieval-augmented generation, or RAG), passes them past a short-term memory station, and wheels them directly to the downstream AI application. While real work is being done, the raw material exits virtually unchanged, merely bundled with a few unverified attachments. The system lacks any mechanism to evaluate whether the retrieved data is accurate, up-to-date, or internally consistent.

```mermaid flowchart TD accTitle: Conventional RAG vs Enterprise Model subgraph Conventional["Conventional Context Layer"] C1["Raw Model Intelligence"] --> C2["Document Filing Cabinet (RAG)"] C2 --> C3["Memory Station"] C3 --> C4["Unchecked Output with Attachments"] end subgraph EnterpriseModel["Intentional Enterprise Model"] E1["Disambiguation<br/>(Standardized Terminology)"] E2["Authoritative Systems of Record"] E3["Codified Policies & Rules"] E4["Ownership & Provenance Traceability"] end ```

To turn raw LLM capability into true enterprise intelligence, organizations must replace this passive document conveyor with an intentional "enterprise model." Inside this optimized environment, teams actively stamp out linguistic ambiguity across communication channels, agreements, and web copy so that core concepts like "active customer" or "closed deal" have singular, unified definitions that the AI can interpret reliably. Elsewhere on the floor, teams establish authoritative systems of record, articulate organizational goals, codify business rules, map operational workflows, and attach clear ownership and provenance to every data point. Rather than emerging out-of-the-box from model vendors, essential capabilities—such as grounding, consistency, accountability, traceability, and reliable action—are earned directly through the conditions built within the enterprise.

- Off-the-shelf foundation models possess generic intelligence; they become enterprise-smart only through deliberately engineered business conditions. - Upfront disambiguation and policy codification can largely be executed in plain English with AI assistance. - Grounding and traceability downstream depend directly on the structural clarity established within the enterprise model.

[04:56](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=296s) Case Study: Standard RAG vs. The Enterprise Model in Customer Support

To illustrate the stark contrast between these two paradigms, De Oliveira walks through a customer support scenario: a user submits a request for a free trial upgrade to a premium product tier, but records show the user has previously utilized a trial. Internal policy dictates that repeat trials require explicit managerial sign-off. Resolving this request demands multiple synchronized operations: classifying customer status, routing to the appropriate team, verifying eligibility, and halting automated processing to escalate the exception to a human supervisor.

```mermaid flowchart TD accTitle: Customer Support Workflow Under Both Paradigms Req["Request: Free Trial Upgrade for Previous Trial User"] --> Split{"Context Architecture"}

subgraph StandardRAG["Standard RAG Pipeline"] S1["Model Infers Process from Stale PDF"] S2["Guesses Definition of 'Upgrade'"] S3["Bypasses Human Checkpoint"] S4["Fails: Beautifully Written False Approval"] S1 --> S2 --> S3 --> S4 end

subgraph EnterprisePipeline["Enterprise Model Pipeline"] M1["Queries Live System of Record"] M2["Applies Disambiguated Business Rules"] M3["Identifies Exception & Escalates to Manager"] M4["Succeeds: Governed, Accountable Action"] M1 --> M2 --> M3 --> M4 end

Split -->|"Naive Retrieval"| StandardRAG Split -->|"Structured Context"| EnterprisePipeline ```

When handed to a standard agent setup relying on document retrieval over internal files, the system produces a well-phrased reply that fails across every substantive dimension. It guesses the definition of "upgrade," applies an obsolete rule retrieved from a stale PDF, and automatically grants approval instead of routing the case to a manager. This represents the "map of the average"—superhuman linguistic capability applied blindly to unverified, generalized context.

Conversely, when processed through an upfront enterprise model, the identical language model and harness succeed. Key terms are locked down and queried directly from authoritative systems of record rather than guessed from static documents. The workflow recognizes the exception condition, immediately suspends automated execution, and deliberately hands off the task to a manager, with every reasoning step tied to an owner and an audit trail.

- Procedural knowledge and codified rules replace guesswork and stale PDF lookups. - Centralizing business logic within the enterprise model ensures consistent vocabulary and rules across all scripts and automation workflows. - Core capabilities—grounding, consistency, reliable action, accountability, and traceability—emerge organically as properties of the system rather than prompt hacks.

[07:50](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=470s) The Continuous Operational Loop and the Enterprise Moat

Building an enterprise model is not a one-time documentation exercise, but an active, continuous feedback loop analogous to the Software Development Life Cycle (SDLC). Organizations must identify necessary capabilities, build the operational conditions to generate them, deploy the system into live workflows, observe where the model holds or breaks, and iterate continuously. Treating the model like a static catalog guarantees it will become obsolete.

```mermaid flowchart LR accTitle: Continuous Enterprise Model Lifecycle C["1. Determine Needed Capabilities"] --> B["2. Build Operational Conditions"] B --> O["3. Operate & Monitor Live Systems"] O --> I["4. Inspect Failures & Edge Cases"] I --> C ```

Because the enterprise model captures nuanced procedural knowledge, exceptions, and institutional definitions distributed across an organization, it cannot be completely outsourced. De Oliveira emphasizes that companies should welcome this reality: "A living model only you can build is one that no competitor can buy. It's your moat." While foundational technologies like ontologies, knowledge graphs, and complex data engineering form the implementation layer, the overarching mandate remains human-driven and cross-departmental.

- Smarter baseline models will not automatically solve context fragmentation or eliminate the need for internal alignment. - Domain expertise is decentralized: employees across every department hold critical fragments of business meaning, edge cases, and workflow rules. - Attendees and practitioners interested in enterprise context architecture are invited to continue the conversation with John De Oliveira and his colleague Johnny at the Hapax booth on row 1,000.

## Notable quotes > Every week brings another breakthrough model, agent framework, or enterprise AI product. — John De Oliveira

> These can feel like separate trends competing for attention—but what if they're all attempts to solve different parts of the same problem? — John De Oliveira

> [00:04](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=4s) Oh, wait. That's the 20-minute version. Sorry. Let me lower the bar a bit here. — John De Oliveira

> [02:07](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=127s) Off-the-shelf foundation models possess generic intelligence; they become enterprise-smart only through deliberately engineered business conditions. — John De Oliveira

> [02:07](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=127s) Upfront disambiguation and policy codification can largely be executed in plain English with AI assistance. — John De Oliveira

> [04:56](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=296s) Procedural knowledge and codified rules replace guesswork and stale PDF lookups. — John De Oliveira

> [07:50](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=470s) Building an enterprise model is not a one-time documentation exercise, but an active, continuous feedback loop analogous to the Software Development Life Cycle (SDLC). — John De Oliveira

> [07:50](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=470s) A living model only you can build is one that no competitor can buy. It's your moat. — John De Oliveira

> [07:50](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=470s) Smarter baseline models will not automatically solve context fragmentation or eliminate the need for internal alignment. — John De Oliveira

## Mentioned John De Oliveira, Hapax, Ai4, Johnny

## Video description John De Oliveira - AI Architect, Hapax

Every week brings another breakthrough model, agent framework, or enterprise AI product. At the same time, organizations are investing in RAG, governance, enterprise memory, knowledge graphs, provenance, and LLM-native knowledge formats. These can feel like separate trends competing for attention—but what if they're all attempts to solve different parts of the same problem? This talk offers a systems perspective on enterprise AI, arguing that the greatest opportunities lie beyond the model itself. Rather than comparing technologies, it introduces a practical way to think about the conditions that allow enterprise intelligence to emerge. Whether you're building AI products, advising enterprises, or deciding where to invest, you'll leave with a new way of thinking about why these technologies matter, how they fit together, and where the next generation of enterprise AI is likely to be created.

[Source](https://www.youtube.com/watch?v=kcHdwpeTwLI)

中文简报

Hapax 架构师：企业 AI 落地成效取决于规范化上下文模型 除非企业用固化业务规则与定义的动态专有企业模型取代被动的文件柜，否则标准文档检索管道无法支持实际业务工作流。 John De Oliveira 解释了为何采用相同基础模型的企业往往会产生截然不同的业务成效，并指出中间上下文架构是核心差异所在。企业不能依赖仅从数字文件柜中提取未经校验文档的简易 RAG 管道，而必须构建专门的“企业模型”，以消除语义歧义、映射核心记录系统并规范业务策略。一项客户支持案例表明，这种结构化方法可以防止因幻觉导致的错误审批，并妥善执行“人在回路”（human-in-the-loop）的异常处理机制。这一专有企业上下文如同持续的软件开发生命周期一样进行维护，将演化为无法通过现成采购获得的动态防御壁垒。 John De Oliveira 指出，采用相同底层基础模型的企业往往取得截然不同的业务成效，关键差异在于中间的上下文架构；企业应将通用大模型智能视作原材料，借助上下文层将其转化为可衡量的业务成果。 (0:04) 传统的 RAG 流程仅像被动运送未验证文档的“文件推车”，缺乏准确性验证机制；企业必须过渡到有意识构建的“企业模型”，主动消除术语歧义并确立权威的记录系统与权责溯源。 (2:07) 在客户支持案例对比中，基础 RAG 会因依赖过时文档推断逻辑而错误批准违规请求，而企业模型能直接联动实时记录系统，精准识别政策例外并安全转交人工主管审批。 (4:56) 企业模型的构建并非一次性任务，而是类似软件开发生命周期（SDLC）的持续迭代闭环；由于凝聚了组织内部高度分散的专有业务规则与流程细节，它将构成竞对无法直接购买的核心护城河。 (7:50)

Reading summary

John De Oliveira of Hapax argues that enterprise AI performance diverges not because of the underlying foundation models, but because organizations fail to build an intentional intermediate "enterprise model" that codifies terminology, business rules, and data provenance. The Manufacturing Campus Analogy (0:04) De Oliveira uses a manufacturing campus analogy to explain why identical foundation models yield drastically different business results, such as customer acquisition cost (CAC) reduction or ARR growth. Generic intelligence from the language model serves as the raw material entering the facility, while enterprise applications represent finished outputs. The decisive factor lies in the intermediate "context building," where organizations process that raw intelligence. Standard RAG Conveyors vs. Enterprise Models (2:07) A conventional retrieval-augmented generation (RAG) setup functions like a document conveyor: it pulls relevant-looking files from a cabinet, bundles them with short-term memory, and delivers them to the application without verifying accuracy, currency, or consistency. As a result, the model's raw intelligence exits virtually unchanged alongside unverified attachments. To achieve true enterprise intelligence, De Oliveira asserts that organizations must replace passive retrieval with an intentional enterprise model. This environment resolves linguistic ambiguity around terms like "active customer," establishes authoritative systems of record, articulates goals, maps operational workflows, and attaches clear data provenance. System attributes like grounding, consistency, traceability, and reliable action must be cultivated through internal organizational conditions rather than expected out-of-the-box from model vendors. Customer Support Failure Modes and Governed Execution (4:56) To contrast the two paradigms, De Oliveira outlines a scenario where an existing customer requests a repeat free trial upgrade to a premium tier, an action requiring managerial sign-off under company policy. A standard RAG setup relying on internal document retrieval infers policy from a stale PDF, guesses the definition of "upgrade," and automatically generates a well-phrased approval that bypasses the mandatory human checkpoint. In contrast, the enterprise model routes the request through live systems of record with standardized terminology and codified procedural rules. It detects the repeat-trial exception, halts automated execution, and escalates the decision to a manager while preserving an audit trail of ownership for each reasoning step. Continuous Model Lifecycles as Proprietary Moats (7:50) Maintaining an enterprise model requires an active feedback loop comparable to the software development life cycle: determining required capabilities, building operational conditions, deploying and monitoring live workflows, and inspecting failures or edge cases. De Oliveira warns that treating the model as a static document catalog guarantees rapid obsolescence. Because domain expertise, edge cases, and workflow logic are distributed across decentralized business teams, this context cannot be fully outsourced. According to De Oliveira, smarter future foundation models will not resolve internal context fragmentation, making an internally engineered enterprise model a proprietary competitive moat that cannot simply be purchased off the shelf. De Oliveira emphasizes that while ontologies, knowledge graphs, and data engineering execute the enterprise model, its ultimate effectiveness relies on ongoing, human-led cross-departmental alignment rather than passive tooling upgrades.

精炼阅读摘要

Hapax 的 John De Oliveira 指出，企业部署相同的基础大语言模型却产生巨大业务差异，其关键不在于底层模型的通用智能，而在于中间上下文架构；企业必须从被动的文档检索转向主动构建“企业模型”，才能将通用智能转化为可靠的业务成果。 上下文架构是决定业务成效的核心中枢 (0:04) De Oliveira 运用制造园区的比喻来解释企业人工智能的运行机制：基础大语言模型提供的通用智能如同入口处的原材料，而降低客户获取成本（CAC）或提高月度经常性营收（ARR）则是最终成品。在整个园区中央，连接原材料与最终应用的关键设施是组织正在搭建的上下文层建筑。 尽管工程技术人员在围绕大语言模型构建 Agent 框架、上下文窗口和记忆模块方面已十分熟练，但使用完全相同基础模型的企业在最终业务回报上仍呈现巨大差距。De Oliveira 认为，当进入系统的底层智能完全一致时，产出的分化主要归因于中间上下文层的架构差异，该架构决定了通用能力能否有效适配具体的商业场景。 从被动文档检索转向意图化企业模型 (2:07) 常规的检索增强生成（RAG）机制往往类似于简陋的流水线作业：系统接收通用智能后，从文件柜中调取看似相关的文档放入小车，掠过短期记忆站便直接输送给下游应用。这种操作仅完成了文档的被动抓取与拼凑，无法评估检索到的数据是否准确、最新或在逻辑上前后一致，导致模型输出容易失真。 为将通用能力转化为真正的企业智能，企业需要构建一个具备明确意图的“企业模型”（Enterprise Model）。这一架构要求团队主动消除沟通渠道和协议中的语言歧义，对“活跃客户”或“已结单”等核心概念确立统一定义；同时建立权威记录系统，将业务政策、工作流与操作规则转化为结构化代码，并为数据关联清晰的所有权与溯源路径，从而让准确性与可追溯性成为系统内生属性。 规则编码防范自动化推断偏差 (4:56) 以客户支持业务为例，当曾体验过试用期的用户申请高级版本试用时，内部政策明确规定重复试用必须经过主管审批。标准 RAG 架构仅依赖过期的内部 PDF 文档推测流程，自行揣测“升级”的含义，最终绕过人工审批检查点，生成了一份措辞优雅但实质违规的自动批准答复，暴露出缺乏结构化约束的通用模型在应对边缘用例时的缺陷。 相反，在企业模型架构下，相同的大语言模型直接查询权威记录系统并应用标准化规则，能够准确识别出重复试用属于例外情况，进而立即暂停全自动处理并转交主管审批。该方案通过集中管理业务逻辑，使整个推理与执行过程具备清晰的责任归属和审计追踪记录，避免了对非结构化文档的盲目猜测。 闭环迭代与不可替代的企业壁垒 (7:50) 构建企业模型并非一次性的文档整理工作，而是一个对标软件开发生命周期（SDLC）的持续循环。企业必须经历明确所需能力、搭建对应运营条件、在实际业务流中监控运行、以及针对失效与边缘用例进行审查与迭代的完整过程，防止模型因信息停滞而迅速失效。 De Oliveira 强调，由于细致的流程知识、例外情况和业务定义高度分散在企业各部门员工的日常经验中，企业模型无法完全依赖外部采购。这种需要跨部门长期协同沉淀、由企业自主构建的活态运营模型，正是竞争对手无法直接通过购买通用技术所复制的核心竞争壁垒。 演讲总结表明，基础语言模型的能力提升无法自动消除企业内部的上下文碎片化；企业要实现真正可靠的智能化应用，必须持续投入资源，自底向上建立规范的业务规则与上下文治理体系。

Detailed notes — zh

## Background 本视频由 Ai4 于 2026 年 8 月 17 日发布在 YouTube 平台上，内容为 Hapax 公司的 AI 架构师 John De Oliveira 的主题演讲。演讲探讨了企业级 AI 落地的系统性视角，指出决定业务成败的关键不在于底层大语言模型本身，而在于如何构建让企业智能真正涌现的中间条件体系（即企业模型）。 ## TL;DR 演讲围绕“为何使用相同的 LLM 却产出天差地别的业务结果”这一核心悖论展开，用生动的工业制造园区隐喻拆解了从通用智能原材料到实际业务成效的转化路径。讲者指出，传统 RAG 仅做简单文档搬运，无法解决歧义、过期规则与责任归属等关键问题；而精心构建的“企业模型（Enterprise Model）”通过统一词汇定义、确立权威源与特例拦截机制，能够赋予系统事实锚定与可靠行动等五大核心能力。最后，讲者强调企业模型不是一次性的静态资产，而是一个由全员参与、持续迭代演进的工程闭环，构成了企业独一无二的核心竞争护城河。 ## Atmosphere & style 演讲氛围轻松幽默且兼具极强的工程务实感。开场以调侃时长的段子迅速破冰拉近距离，随后通过高度具象化的“制造园区与厂房”隐喻将晦涩的技术架构化繁为简。整体叙事节奏紧凑洗练、层层递进，既有对传统 RAG 局限性的犀利针砭，也有对人本协同与系统工程的真诚倡导，给听众带来既接地气又具启发性的系统级思考体验。 ## Key takeaways - [00:04](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=4s) 企业 AI 领域存在核心悖论：不同团队使用完全相同的底层大语言模型（LLM），最终获得的业务成效却天差地别，表明模型与成效之间存在关键的中间机制。 - [01:06](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=66s) 将企业 AI 视作制造园区：LLM 是运入园区的通用原材料，最终业务结果（如降低 CAC 或提高 ARR）是成品，而中间的上下文层（Context Layer）是决定成败的核心厂房。 - [02:07](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=127s) 传统的上下文层仅包含基础 RAG 检索和简易记忆站，本质上只是原封不动地搬运文档，缺乏对信息真实性、准确性及前后一致性的质检机制。 - [02:07](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=127s) 打造企业级智能的核心在于构建“企业模型（Enterprise Model）”，其首要任务是消除 Slack、邮件及协议等日常沟通中的语义歧义，确保业务术语定义全域统一。 - [02:07](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=127s) 企业模型需明确界定权威真实源头（System of Record），清晰记录企业战略规则、业务流转逻辑、权责归属以及结论的回溯链路。 - [02:07](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=127s) 借助现代 AI 工具，企业模型大部分规则和定义可直接以自然语言编写沉淀，构建门槛不高，关键在于早期的刻意梳理与构建。 - [03:49](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=229s) 企业级智能所需的五大核心能力包括：基础事实锚定（Grounding）、一致性（Consistency）、责任归属（Accountability）、可追溯性（Traceability）和可靠行动（Reliable Action）。 - [03:49](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=229s) 在客户支持案例中，普通 RAG 依赖平均概率猜测且易套用过时文档，而企业模型能准确识别异常策略并主动触发人工审批与熔断机制。 - [07:50](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=470s) 企业模型的建设不是一次性的静态文档编纂，而是一个包含“确定能力-构建条件-投入运行-观察断裂点”的持续动态工程闭环。 - [07:50](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=470s) 由于企业模型深度根植于组织独有的规则与流程共识，它无法被直接采购或外包，是企业最坚固的专属竞争护城河。 - [08:57](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=537s) 更聪明的通用模型无法代替人类厘清业务本质，企业模型的构建是一项以人为核心（Human-powered）、需要全员协同参与的系统工程。 ## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=4s) 破冰承诺与核心悖论：相同的模型，为何带来截然不同的业务结果？ 演讲开场时，Hapax 的 AI 架构师 John De Oliveira 用一句幽默的玩笑拉近了与观众的距离。他调侃称，如果台下有企业正在使用 AI，那么在他接下来短短 10 分钟的演讲结束后，大家就能彻底解决所有的业务痛点——紧接着他话锋一转笑道：“抱歉，那是 20 分钟版本的演讲内容，我还是把预期调低一点吧。”他希望观众能带着一种全新的、深刻且难以磨灭的系统性视角离开会场。 在过去几年中，AI 开发者们极其擅长围绕大语言模型（LLM）搭建外围脚手架，包括测试控制组件（Harnesses）、智能体（Agents）、上下文注入（Context）以及记忆模块（Memory）。然而，在大量的企业级 AI 落地项目中存在一个普遍而令人困惑的悖论：不同的团队采用完全相同的底层语言模型，最终获得的业务成效却天差地别。“输入的是同等水平的智能，产出的结果却大相径庭。”这表明在底层模型与最终业务产出之间，必然存在某种关键的中间机制在发挥决定性作用。 ```mermaid flowchart LR accTitle: Enterprise AI Campus Model accDescription: A comparison showing generic intelligence passing through the enterprise model layer to generate business outcomes. subgraph InputStage["输入端"] LLM["通用语言模型<br/>（原始智能原材料）"] end subgraph MiddleStage["核心中间层（园区厂房）"] EM["企业模型 Enterprise Model<br/>• 消除歧义与统一词汇<br/>• 权威数据源与规则策略<br/>• 业务流程与所有权追溯"] end subgraph OutputStage["产出端"] System["企业级 AI 系统"] Outcomes["最终业务成效<br/>• 降低获客成本 CAC<br/>• 推动 ARR 月度增长"] end LLM --> EM EM --> System System --> Outcomes ``` --- ### [01:06](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=66s) 制造园区隐喻：从通用原材料到业务产出 为了让抽象的概念落地，讲者建立了一个具象化的比喻：不要把企业 AI 看作一堆运行的代码和流动的数据，而应将其想象成一座工业制造园区，园区内坐落着不同的厂房，里面有工人在协同作业。这个制造园区的终极产成品并非代码，而是具体的业务成效，例如客户获取成本（CAC）的降低或经常性月度收入（ARR）的持续增长。 在这个制造园区中： - 位于园区左下角的是**大语言模型**，它就像被卡车运进园区的通用工业原材料，代表着最基础的通用智能。 - 位于园区顶端的是**企业 AI 系统及其业务结果**，代表成品出库。 - 位于两者正中间的，则是一栋巨大的空白厂房——**上下文层（Context Layer）**，也是当前各大企业正竞相争夺和构建的核心枢纽。由于每家企业构建上下文的方式大相径庭，这栋厂房往往像个黑盒。 --- ### [02:07](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=127s) 掀开典型上下文层的屋顶：传统 RAG 的局限与“企业模型”的引入 掀开当前大多数团队搭建的“典型上下文厂房”的屋顶，其内部运转模式极其单薄：当来自语言模型的原材料进入后，工人仅仅是从文件柜里翻出几份看起来相关的企业文档放在手推车上（即检索增强生成 RAG），再经过一个记录过往交互的简易“记忆站”，随后便打包送往上游系统。整个流水线虽然必不可少，但本质上只是把原材料原封不动地搬运了一遍，没有任何质检环节来验证调取的文档是否真实、准确或保持前后一致。 为了将通用的 LLM 智能真正升华为“企业级智能”，企业需要的是一座被精心设计的厂房，即**企业模型（Enterprise Model）**。在这座厂房内部，工作重心发生了根本性转变： - **消除语义歧义**：团队致力于彻底消除日常交流中的模糊地带。无论是 Slack 聊天、内部邮件、客户协议还是官网文案，确保关键术语在全公司范围内拥有唯一且明确的定义。当全公司对“活跃客户（Active Customer）”或“已成交订单（Closed Deal）”的定义达成绝对一致时，AI 才能真正理解其精确含义。 - **确立权威源与规则策略**：明确界定哪些系统属于权威真实源头（System of Record），清晰记录企业的战略目标、制度规则、真实的业务执行流程、责任人归属以及每条结论的回溯链路。 - **低门槛构建**：这些梳理工作在当下并不繁重，借助现代 AI 工具，大部分内容都可以直接用自然语言编写和沉淀，关键在于前期的刻意构建。 --- ### [03:49](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=229s) 五大核心能力与具体客户支持案例剖析 通用的开箱即用模型只具备泛化智能，唯有在企业内部建立起严密的条件体系，才能生长出真正的企业级核心能力。这些能力包括：**基础事实锚定（Grounding）**、**一致性（Consistency）**、**责任归属（Accountability）**、**可追溯性（Traceability）** 和 **可靠行动（Reliable Action）**。 | 评估维度 | 传统构建方式（普通智能体 + 基础 RAG） | 依托“企业模型”构建的方式 | |:--- |:--- |:--- | | **术语解析** | 靠大模型猜测“升级（Upgrade）”的模糊含义 | 术语严格对齐业务定义，语义全域统一 | | **规则读取** | 检索到废弃过期的旧 PDF 并错误套用规则 | 直接从权威记录系统（System of Record）读取有效策略 | | **异常拦截** | 忽略“曾试用用户需经理审批”的特例，直接盲目自动批准 | 敏锐识别业务特例，果断触发熔断机制并主动移交人工审批 | | **责任追溯** | 黑盒输出，措辞优美但结论完全错误 | 每个决策步骤均具备清晰的数据来源与权责所有者 | 讲者通过一个典型的客户支持场景进行了对照分析：一位曾经参与过免费试用的客户再次发来申请，希望升级至某高级产品版本的免费试用期。根据公司的既定政策，重复试用属于异常情况，必须经过经理签字批准。 在传统搭建方式下，通用模型即便语言组织得极其流畅漂亮，却完全基于“平均概率”进行推测，错误采纳了过时文档并直接通过了审批，在每一个关键节点上全部溃败；而在具备企业模型的体系中，智能体能够精确识别客户类型、自动校验资格并在触发异常时主动交接给人工，每一步都做到有据可查、权责明确。 --- ### [07:50](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=470s) 持续演进的工程闭环与企业专属的竞争护城河 企业模型的建设并非一劳永逸的静态任务，而是一个必须长期参与的动态闭环（类似软件开发生命周期 SDLC）： ```mermaid flowchart TD accTitle: Enterprise Model Continuous Lifecycle accDescription: A continuous cycle of deciding capabilities, building conditions, operating, and refining. A["1. 确定所需能力<br/>（Decide Capabilities）"] --> B["2. 构建支撑条件<br/>（Build Conditions）"] B --> C["3. 投入实际业务运行<br/>（Operate in Production）"] C --> D["4. 观察系统承载与断裂点<br/>（Observe & Monitor）"] D --> A ``` - **避免静态文档化陷阱**：如果将企业模型视作一次性的产品目录，完成之后便束之高阁，它很快就会失效过时。其生命力恰恰来自于企业在运行闭环中的持续迭代。 - **不可外包的独特护城河**：由于该模型深植于企业特有的业务规则、流程细节与组织共识中，它无法被完全外包给第三方，竞争对手也无法直接花钱买到。“一个唯有你自己才能构建的鲜活模型，就是企业最深厚的竞争护城河。” --- ### [08:57](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=537s) 人工驱动的共建工程与结语 在演讲尾声，John 说明了为何自己刻意避开了本体论（Ontologies）、知识图谱（Knowledge Graphs）以及底层具体工程实现的细节——因为当理念落地到每家企业独特的技术栈、数据架构和团队组织时，具体实施路径各有不同，需要单独深入探讨。 构建企业模型是一项扎实而持续的工作，并且它必然是“以人为核心（Human-powered）”的。更聪明的模型并不能代替人去厘清业务本质，这也不是单一工程师或单个部门就能独立完成的任务。从业务定义、特例处理到真实的业务流转，企业内的每一位员工都掌握着拼凑企业真实全貌的一块拼图。每个人都需要参与到这套模型的构建、提纯与纠偏中。 在致谢环节，John 表示 Hapax 团队长期深耕于企业模型领域，并热情邀请对该领域感兴趣的与会嘉宾在会后通过邮件或前往 Ai4 大会 1000 号展位与他及同事 Johnny 展开进一步交流。 ## Notable quotes > [00:04](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=4s) 抱歉，那是 20 分钟版本的演讲内容，我还是把预期调低一点吧。 — John De Oliveira > [00:04](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=4s) 输入的是同等水平的智能，产出的结果却大相径庭。 — John De Oliveira > [01:06](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=66s) 不要把企业 AI 看作一堆运行的代码和流动的数据，而应将其想象成一座工业制造园区，园区内坐落着不同的厂房，里面有工人在协同作业。 — John De Oliveira > [02:07](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=127s) 整个流水线虽然必不可少，但本质上只是把原材料原封不动地搬运了一遍，没有任何质检环节来验证调取的文档是否真实、准确或保持前后一致。 — John De Oliveira > [02:07](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=127s) 当全公司对‘活跃客户（Active Customer）’或‘已成交订单（Closed Deal）’的定义达成绝对一致时，AI 才能真正理解其精确含义。 — John De Oliveira > [03:49](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=229s) 通用模型即便语言组织得极其流畅漂亮，却完全基于‘平均概率’进行推测，错误采纳了过时文档并直接通过了审批，在每一个关键节点上全部溃败。 — John De Oliveira > [07:50](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=470s) 如果将企业模型视作一次性的产品目录，完成之后便束之高阁，它很快就会失效过时。其生命力恰恰来自于企业在运行闭环中的持续迭代。 — John De Oliveira > [07:50](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=470s) 一个唯有你自己才能构建的鲜活模型，就是企业最深厚的竞争护城河。 — John De Oliveira > [08:57](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=537s) 更聪明的模型并不能代替人去厘清业务本质，这也不是单一工程师或单个部门就能独立完成的任务。 — John De Oliveira > [08:57](https://www.youtube.com/watch?v=kcHdwpeTwLI&t=537s) 从业务定义、特例处理到真实的业务流转，企业内的每一位员工都掌握着拼凑企业真实全貌的一块拼图。 — John De Oliveira ## Mentioned John De Oliveira, Hapax, Ai4, Johnny, Slack, 大语言模型 (LLM), 检索增强生成 (RAG), 知识图谱 (Knowledge Graphs), 本体论 (Ontologies), 权威真实源系统 (System of Record), 软件开发生命周期 (SDLC) ## Video description John De Oliveira - AI Architect, Hapax Every week brings another breakthrough model, agent framework, or enterprise AI product. At the same time, organizations are investing in RAG, governance, enterprise memory, knowledge graphs, provenance, and LLM-native knowledge formats. These can feel like separate trends competing for attention—but what if they're all attempts to solve different parts of the same problem? This talk offers a systems perspective on enterprise AI, arguing that the greatest opportunities lie beyond the model itself. Rather than comparing technologies, it introduces a practical way to think about the conditions that allow enterprise intelligence to emerge. Whether you're building AI products, advising enterprises, or deciding where to invest, you'll leave with a new way of thinking about why these technologies matter, how they fit together, and where the next generation of enterprise AI is likely to be created. [Source](https://www.youtube.com/watch?v=kcHdwpeTwLI)

Source quotes

[0:04] John De Oliveira: 抱歉，那是 20 分钟版本的演讲内容，我还是把预期调低一点吧。 [0:04] John De Oliveira: 输入的是同等水平的智能，产出的结果却大相径庭。 [1:06] John De Oliveira: 不要把企业 AI 看作一堆运行的代码和流动的数据，而应将其想象成一座工业制造园区，园区内坐落着不同的厂房，里面有工人在协同作业。 [2:07] John De Oliveira: 整个流水线虽然必不可少，但本质上只是把原材料原封不动地搬运了一遍，没有任何质检环节来验证调取的文档是否真实、准确或保持前后一致。 [2:07] John De Oliveira: 当全公司对‘活跃客户（Active Customer）’或‘已成交订单（Closed Deal）’的定义达成绝对一致时，AI 才能真正理解其精确含义。 [3:49] John De Oliveira: 通用模型即便语言组织得极其流畅漂亮，却完全基于‘平均概率’进行推测，错误采纳了过时文档并直接通过了审批，在每一个关键节点上全部溃败。 [7:50] John De Oliveira: 如果将企业模型视作一次性的产品目录，完成之后便束之高阁，它很快就会失效过时。其生命力恰恰来自于企业在运行闭环中的持续迭代。 [7:50] John De Oliveira: 一个唯有你自己才能构建的鲜活模型，就是企业最深厚的竞争护城河。 [8:57] John De Oliveira: 更聪明的模型并不能代替人去厘清业务本质，这也不是单一工程师或单个部门就能独立完成的任务。 [8:57] John De Oliveira: 从业务定义、特例处理到真实的业务流转，企业内的每一位员工都掌握着拼凑企业真实全貌的一块拼图。

Source quotes

John De Oliveira: Every week brings another breakthrough model, agent framework, or enterprise AI product. John De Oliveira: These can feel like separate trends competing for attention—but what if they're all attempts to solve different parts of the same problem? [0:04] John De Oliveira: Oh, wait. That's the 20-minute version. Sorry. Let me lower the bar a bit here. [2:07] John De Oliveira: Off-the-shelf foundation models possess generic intelligence; they become enterprise-smart only through deliberately engineered business conditions. [2:07] John De Oliveira: Upfront disambiguation and policy codification can largely be executed in plain English with AI assistance. [4:56] John De Oliveira: Procedural knowledge and codified rules replace guesswork and stale PDF lookups. [7:50] John De Oliveira: Building an enterprise model is not a one-time documentation exercise, but an active, continuous feedback loop analogous to the Software Development Life Cycle (SDLC). [7:50] John De Oliveira: A living model only you can build is one that no competitor can buy. It's your moat. [7:50] John De Oliveira: Smarter baseline models will not automatically solve context fragmentation or eliminate the need for internal alignment.

Original transcript

[0:04] Quick quick promise up front. If you use  AI in your business, by the time I'm done, [0:09] 10 minutes from now, you'll have completely fixed  everything about it. Every one of you, all fit [0:16] Oh, wait. That that's the 20-minute version.  Sorry. Uh let me lower the bar a bit here. So, how [0:21] about you'll leave with a different perspective  that hopefully will be hard to shake. So, um [0:29] all of us building with AI have spent the past  few years getting very good at building around the [0:35] language model, right? Harnesses, agents, context,  memory, all the scaffolding we wrap around it. [0:42] But, here's what I kept seeing across our  enterprise AI projects. Uh teams relying on [0:47] the same language model would end up with very  different business outcomes. Same intelligence [0:52] going in, very different outcomes coming out.  So, something in between is doing important work. [0:59] What is that something? So, I want to try  to shift the perspective with you here [1:06] for the next few minutes. Instead of picturing  running code and data moving, picture the whole [1:11] path as buildings on a manufacturing campus with  people doing work inside. So, this is a campus [1:18] whose finished product is business outcomes.  Outcomes like lower customer acquisition costs or [1:26] month-over-month growth in ARR. The  trouble with all these intangibles, growth, [1:32] costs, intelligence, they all feel so intangible.  So, let's pretend we're making something physical. [1:40] So, down there, the language  model in the lower left, you see, [1:44] generic intelligence shipped in like raw material.  Up in the top is your enterprise AI systems and [1:50] the outcomes they produce. And in the middle,  this big blank building, the context layer, [1:55] the part everyone's racing to build right now.  So, the context building's blank here because [2:01] how context actually gets built varies a great  deal from one company to another. So, let's do [2:07] the obvious thing. Let's look inside. First, we  take the roof off of a typical context layer. [2:14] Pretty straightforward in here. The building  does one clean simple job. It pulls in company [2:19] documents that look relevant, moves them along.  Raw material comes in from the language model. [2:24] Someone pulls documents out of a filing cabinet,  sets them on the cart. That's retrieval, rag. [2:30] Then, there's a memory station holding on  to a bit of what happened before and it [2:34] heads out there to your AI systems. So, it's  all real and necessary work and uh but look [2:39] what's actually going on though in the building.  Things move through it. Raw material comes in and [2:44] pretty much leaves the way it came in with a few  documents attached. Nothing in here checks whether [2:50] what it grabbed is actually right or actually  consistent. And to be fair, it's pretty much [2:56] what most teams are doing today. I you know, I  simplified it. The details differ shop to shop, [3:02] but that's the shape of it. So, let's take another  pass at what goes on inside inside of something [3:09] more intelligible. Something No, something  more intentional. Something that can turn [3:14] LLM intelligence into enterprise intelligence.  So, here's what it looks like inside. [3:20] We call it the enterprise model. What goes on in  here? Well, down in one corner, you've got people [3:26] working to stomp out ambiguity. Getting on the  same page about what all the words mean that fly [3:32] around in Slack and email and that land everywhere  from customer agreements to website copy. [3:39] So, when active customer or closed deal mean  one thing across the whole company, the AI [3:44] can finally mean it, too. So, that's one kind  of work. Around the rest of the floor, you got [3:49] others doing things that are also important like  selling what counts as the authoritative source [3:56] pinning down what the business is actually trying  to achieve writing the rules and policies down [4:01] capturing how the work really gets done who  owns what where each answer traces back to [4:09] None of it has to be hard. A lot of it can be done  in plain English nowadays with the help of AI. [4:15] It's upfront work and it's everything done in  here sharpens the intelligence that's delivered [4:22] downstream. Downstream is up in the picture. [4:26] And that's the whole point. These are the  conditions that produce capabilities. Capabilities [4:33] like grounding, consistency, accountability,  traceability, reliable action. An off-the-shelf [4:40] model is generically smart. It becomes enterprise  smart only when it gains these. And they don't [4:47] come from the language model. They're earned by  the conditions that you build in your business. [4:56] But let's make this concrete now. Customer  support gets a request for an upgrade to free [5:03] trial of some premium level of your product and  they're getting this request from someone who's [5:08] already had a free trial before which your policy  says that means manager sign off. So you know [5:13] it's got a various set of things going on. And  behind the request a few things have to happen. [5:20] Figure out what kind of customer they are,  route them to the right team, check eligibility, [5:24] and because there's an exception here,  know when to stop and bring in a person. [5:31] Let's look at uh one way it gets done. Here's  the agent built the usual way. A capable model [5:40] retrieval over internal documents  left to infer the process. [5:46] So what goes wrong? It provides a decent-looking  answer. It just happens to be wrong. [5:52] It guessed what upgrade means. It applied a rule  from some stale PDF. And the one case that should [5:58] have stopped for a human, it just went ahead and  approved it. You know, it had a beautifully worded [6:03] reply, but it sent it along when it shouldn't  have. So, this is the map of the average. This is [6:10] superhuman from the from the LLMs, but applied to  kind of what's common and what's not specifically [6:17] known. And in this extreme example, it  fails every single in every single way. [6:25] So, here is the same request, same language model  and harness, but the enterprise model was built [6:31] up front. This time, the terms are pinned  down. Upgrade, customer type, eligible. Each [6:40] means something specific. Read from the system  of record rather than guessed from a document. [6:48] The exceptions recognized, so the agent stops and  hands it over deliberately. Every step traces back [6:55] to a source and an owner. Now, you've already  done some of this in in your one-off scripts [7:00] and documented processes. When you build them  into the enterprise model deliberately, the [7:06] vocabulary matches across the script every script  you build, and the same rules apply everywhere. [7:15] So, procedural knowledge like this is a big part  of the enterprise model, but it's only a part. [7:20] So, everything that's in green the green column  traces back to a model that the business built on [7:25] purpose. And each of these clusters is one of the  capabilities from inside the building. Grounding, [7:34] consistency, reliable action, accountability,  traceability, they apply, they come up, [7:40] they happen in the actual work as a result  of the conditions that you built on purpose. [7:50] So, one caution with this is that  this is a loop that you stay in. [7:57] You decide the capabilities you need. You build  the conditions that produce those capabilities. [8:03] You operate, watch where the enterprise model  holds and where it breaks, and then you go again. [8:08] So, SDLC has a cycle, this has a cycle. If you  treat it like a catalog, you finish it once, [8:14] it goes stale. The continuity comes from  your ongoing participation in the loop, [8:21] which is also why it can't be fully  outsourced. And you want it that way. [8:26] A living model only you can build is one  that no competitor can buy. It's your moat. [8:35] So, laid out the beginnings of a framework, one  that's less about moving information to the model [8:44] and more about building a real model of your  business. We spent just a few minutes inside [8:50] a picture, inside a manufacturing campus, to see  what this layer is and why it's worth building. [8:57] What I haven't touched is the how. The ontologies,  knowledge graphs, the real engineering underneath. [9:04] And that's deliberate. The  how is its own conversation. [9:09] The point where this steps out of the picture  and into your stack, your data, your team, [9:14] with plenty more to learn for when you're  ready to actually build it for real. [9:18] So, building your enterprise model is  real work and it stays human-powered. [9:24] Smarter models won't do it for you, and it's  not uh one-person job. This is uh not even [9:29] a one-department job. Everyone in the business  holds a piece of what the business actually means. [9:36] A definition here, and exception there, the  way work truly happens. So, everyone has a part [9:43] in building this model, refining it, keeping it  honest. And the question is, what part is yours? [9:52] So, I've worked in and around this topic for years  and the last few I've really gotten to dig into it [9:58] uh into this um space um my company ha uh Habit's  works in this space. And if it intrigues you the [10:06] way it does me, I'd love to uh continue the  conversation after the session or by email. [10:11] Or you you know, I'm John or you  could talk to Johnny, who's here. [10:15] Uh and and um or stop by Habit's. We're  on uh row 1,000. You'll find us there. [10:22] Um but it's been a pleasure  talking with you today. Thank you.