UnifyApps Unveils Framework to Move Enterprise AI to Production

Presentation by UnifyApps: Join the 5%: What Gets Enterprise AI to Production in Weeks With UnifyApp — Ai4

Ai4

Enterprise AI initiatives fail at a 95% rate because raw model intelligence accounts for only 20% of scaling requirements, requiring a horizontal operating system to bridge the 80% architectural gap.

AI-assisted summary of Presentation by UnifyApps: Join the 5%: What Gets Enterprise AI to Production in Weeks With UnifyApp — original source. Check the original for full context.

Source published: 2026-08-14

Detailed notes

## Background Published on YouTube by Ai4 on August 14, 2026, this presentation features Waseem Bhatti, Principal Solutions Architect at UnifyApps. According to the page description, the session explores why nearly 95% of enterprise AI initiatives stall in the pilot phase and provides a blueprint for building a sovereign, scalable AI foundation using a Horizontal AI Operating System.

## TL;DR Waseem Bhatti examines the structural bottlenecks that keep enterprise AI projects trapped in pilot purgatory, arguing that 80% of scaling challenges stem from system architecture rather than raw LLM capabilities. Through real-world case studies, such as a major retailer spending $2 million on invoice automation, he demonstrates the flaws of rigid, bespoke code and fragmented data. He introduces a dual-axis decoupling framework that combines an Enterprise Context Graph with an assembly-first, modular design to achieve rapid production scaling. Finally, Bhatti outlines a strategic deployment methodology that prioritizes high-ROI lighthouse use cases before establishing a Center of Excellence.

## Atmosphere & style The presentation carries an authoritative, pragmatic, and highly technical tone typical of elite enterprise architecture keynotes. Bhatti speaks with the grounded confidence of an experienced practitioner, using stark statistical contrasts, crisp operational diagrams, and realistic financial figures to debunk common AI adoption myths. The narrative moves fluidly from high-level strategic diagnosis to detailed blueprinting, creating an engaging and educational experience for CIOs and enterprise architects seeking actionable solutions.

## Key takeaways - [00:04](https://www.youtube.com/watch?v=FR7r95C65kg&t=4s) Enterprise AI success depends 80% on the surrounding architecture/OS and only 20% on the underlying LLM or raw model intelligence. - [00:04](https://www.youtube.com/watch?v=FR7r95C65kg&t=4s) According to a 2025 MIT study, 95% of enterprise AI pilot projects stall before reaching production, creating massive wasted capital. - [00:04](https://www.youtube.com/watch?v=FR7r95C65kg&t=4s) Organizations face a two times higher failure rate when building custom AI infrastructure internally compared to leveraging established frameworks. - [02:46](https://www.youtube.com/watch?v=FR7r95C65kg&t=166s) Pilot projects fail primarily due to a lack of a single source of truth across siloed systems and the reliance on rigid, tightly coupled custom code. - [02:46](https://www.youtube.com/watch?v=FR7r95C65kg&t=166s) Hardcoded AI implementations create severe technical debt because they cannot adapt as human-in-the-loop oversight shifts toward autonomous execution. - [04:37](https://www.youtube.com/watch?v=FR7r95C65kg&t=277s) A Top 5 US Retailer spent over $2 million and 2 years attempting to automate invoice processing due to unbudgeted architectural and integration complexities. - [04:37](https://www.youtube.com/watch?v=FR7r95C65kg&t=277s) Moving from pilot to production expanded a single invoice processing workflow into over 220 distinct operational workflows. - [04:37](https://www.youtube.com/watch?v=FR7r95C65kg&t=277s) Deploying the invoice solution at scale required 10 distinct user interfaces and a multi-agent hierarchy consisting of context, sub-, and orchestration agents. - [10:57](https://www.youtube.com/watch?v=FR7r95C65kg&t=657s) To break out of pilot purgatory, enterprises must execute dual-axis decoupling: horizontal decoupling of data and vertical decoupling of workflow components. - [12:08](https://www.youtube.com/watch?v=FR7r95C65kg&t=728s) The Enterprise Context Graph provides unified data reconciliation through three layers: Knowledge, Governance (RBAC), and Actionability (write-backs). - [12:08](https://www.youtube.com/watch?v=FR7r95C65kg&t=728s) An assembly-first architecture enables swap-in capability for new LLMs as models improve or token costs decline without rewriting core application code. - [14:38](https://www.youtube.com/watch?v=FR7r95C65kg&t=878s) A scalable enterprise AI OS must support deployment flexibility (cloud, VPC, on-prem) alongside protocol interoperability like the Model Context Protocol (MCP). - [16:26](https://www.youtube.com/watch?v=FR7r95C65kg&t=986s) AI agents must adhere to the exact same security and compliance governance controls as human workers, with the ability to be instantly pulled from production. - [16:26](https://www.youtube.com/watch?v=FR7r95C65kg&t=986s) Using UnifyApps, a client transitioned to production in 2 months with ~143 FTEs, processing over 50,000 invoices on day one and expanding to 20+ use cases. - [17:29](https://www.youtube.com/watch?v=FR7r95C65kg&t=1049s) Organizations should avoid establishing a Center of Excellence (COE) too early; they must first execute a high-ROI lighthouse use case to build the AI flywheel.

## Detailed walkthrough Here is part 1 of the walkthrough covering the session's opening architectural analysis:

[00:04](https://www.youtube.com/watch?v=FR7r95C65kg&t=4s) Moving Enterprise AI From Pilot to Production

Waseem Bhatti, Principal Solutions Architect at UnifyApps, opens the presentation by outlining the primary challenge facing modern enterprises: moving AI initiatives out of the experimental "pilot" phase and into scalable production in a matter of weeks. Drawing on a decade of experience in digital transformation and automation workflows within the federal government, Bhatti introduces UnifyApps' core offering—the "Enterprise AI Operating System for the CIO."

``` Enterprise AI Success Equation ┌───────────────────────────────┬───────────────────────────────┐ │ LLM / Model Layer │ Enterprise OS / Arch. │ │ (20%) │ (80%) │ └───────────────────────────────┴───────────────────────────────┘ ```

Addressing the stark reality of current adoption trends, Bhatti highlights two core figures: **95%** and **80/20**. Citing a 2025 MIT study, he points out that 95% of enterprise AI pilot projects stall before reaching production, resulting in massive wasted capital. Studies indicate that organizations face a **two times higher failure rate** when attempting to build custom production-grade AI infrastructure internally rather than leveraging an established framework.

- **Market Potential:** Analyst metrics project an addressable market of **$40 billion by 2030**, capable of unlocking over **$4 trillion annually** in value across business processes, where **60% to 70%** of knowledge work is estimated to be automatable by AI. - **The 80/20 Rule:** Raw model intelligence (the LLM) accounts for only **20%** of what is required to scale an AI use case; the remaining **80%** depends entirely on the surrounding architecture.

[02:46](https://www.youtube.com/watch?v=FR7r95C65kg&t=166s) The Architectural Bottlenecks of Production AI

Bhatti explains that pilot projects do not fail because of model limitations. Instead, failure stems from two fundamental architectural weaknesses that emerge when moving into a live production environment:

1. **Lack of a Single Source of Truth:** Live enterprise workflows require AI agents to reconcile inputs across dozens of disparate data sources (such as ERPs, CRMs, and ticketing platforms). Without a unified data layer, agents receive conflicting signals—for example, SAP recording one payment amount for a vendor while a separate SKU database reflects a promotional discount rate. 2. **Rigid "All-in-One" Custom Code:** Organizations frequently build bespoke, tightly coupled solutions wrapped around a specific model. This creates massive technical debt. As processes mature, the balance between human-in-the-loop oversight and autonomous execution shifts (e.g., moving from 30% autonomy on day one to 80% as accuracy increases). Hardcoded systems cannot adapt to these changing operational parameters or accommodate new model releases (such as switching from Anthropic to Google) without requiring a complete rebuild.

[04:37](https://www.youtube.com/watch?v=FR7r95C65kg&t=277s) Case Study: The $2 Million Invoice Processing Trap

To ground these concepts in real-world numbers, Bhatti walks through the experience of a Top 5 US Retailer attempting to automate invoice processing. Handling over **2 million invoices annually** across hundreds of thousands of monthly transactions, the retailer spent **$15 million per year** in loaded labor costs, which added **3 full days** to their month-end financial close.

``` Retailer's Projected vs. Actual Journey

PILOT HYPOTHESIS ACTUAL PRODUCTION REALITY ┌─────────────────────────┐ ┌──────────────────────────┐ │ Time: 3 Months │ │ Time: 2 Years │ │ Cost: $150,000 │ ───► │ Cost: $2,000,000+ │ │ Scope: 1 Workflow │ │ Scope: 220+ Workflows │ └─────────────────────────┘ └──────────────────────────┘ ```

Based on an initial two-week pilot, leadership estimated that **3 months, $150,000, and a small team of engineers** would fully resolve the problem. Once deployed to production, the hidden 80% architectural overhead derailed their timeline and budget across multiple stages:

- **System Integration (Months 1–3 | $180,000 spent):** The team had to connect **23 legacy systems** using hundreds of custom APIs. Open-source platforms lacked supported connectors for their enterprise suite, forcing engineers to manually handle API builds, edge cases, and token expiration logic. - **Data Standardization (Month 7 | ~$500,000 spent):** Invoices arrived in dozens of unstandardized formats with inconsistent purchase order (PO) numbers, while vendor names were logged across systems in multiple variations, requiring complex multi-way matching. - **Orchestration & Workflows (Month 12 | $720,000 spent):** The single workflow evaluated in the pilot expanded into **over 220 distinct operational workflows** in production. The team had to build custom deterministic rules, auto-approval thresholds, and write-back procedures. - **Human-in-the-Loop & Multi-Agent Architecture (Year 2 | $1.8 Million spent):** The system required **10 distinct user interfaces** across frontline workers, auditors, AP clerks, and external vendors across Microsoft Teams, SaaS tools, and email. Furthermore, a single agent could not process 200,000 monthly global invoices; engineers had to design a multi-agent hierarchy featuring sub-agents, context agents, and orchestration agents alongside guardrails and evaluation frameworks. - **System Write-Back & Governance (Final Cost: $2M+):** The system required bi-directional transactional write-backs to core systems of record like Oracle and Ariba with full survivorship and auditing. CISO compliance reviews nearly halted the project due to requirements around SOC 2 compliance, data deletion protocols, regional model residency, and audit trails.

The most critical takeaway was that despite spending over $2 million and two years on a single project, the retailer had **over 100 additional enterprise use cases** remaining (including 25 within the finance department alone). Because their initial build was rigid and bespoke, none of the underlying infrastructure could be reused.

[10:57](https://www.youtube.com/watch?v=FR7r95C65kg&t=657s) The Boeing Engine Analogy & Decoupling Architectures

Bhatti compares an enterprise LLM to a commercial jetliner. The raw AI model is like a **Rolls-Royce jet engine**—a high-performance component—but passengers sit in, interact with, and rely on the complete **Boeing aircraft** surrounding it. Without the fuselage, seating, safety systems, and avionics, the engine alone cannot transport passengers.

To break out of pilot purgatory and join the 5% of organizations successfully scaling AI, enterprises must execute two structural architectural shifts:

``` Dual-Axis Decoupling Architecture

┌──────────────────────────────────────────────────────────────┐ │ VERTICAL DECOUPLING │ │ Assembly-First: Modular Agents, UI Views, Atomic Workflows │ ├──────────────────────────────────────────────────────────────┤ │ HORIZONTAL DECOUPLING │ │ Enterprise Context Graph & Unified System Actionability │ └──────────────────────────────────────────────────────────────┘ ```

1. **Horizontal Decoupling:** Establishing a unified abstraction layer above underlying systems of record (SAP, CRMs, document repositories). This layer governs access permissions, maintains a unified semantic data model, and enables transactional write-backs. 2. **Vertical Decoupling:** Adopting an "assembly-first" methodology. Individual components—such as connectors, agent logic, UI components, and context blocks—are built as modular building blocks. Following an $N+1$ design pattern, work completed for the first use case serves as reusable infrastructure for every subsequent build.

[12:08](https://www.youtube.com/watch?v=FR7r95C65kg&t=728s) The Enterprise Context Graph & Assembly-First Design

To resolve conflicting data across platforms—such as a CRM recording a specific sales amount, SAP listing a raw bill of materials, and an unstructured DocuSign agreement noting a custom 10% discount—organizations require an **Enterprise Context Graph** structured into three functional layers:

``` Enterprise Context Graph Layers

┌──────────────────────────────────────────────────────┐ │ 3. Actionability Layer (Bi-directional Write-Back) │ ├──────────────────────────────────────────────────────┤ │ 2. Governance Layer (RBAC, Scoped Agent Access) │ ├──────────────────────────────────────────────────────┤ │ 1. Knowledge Graph (Structured + Unstructured Data) │ └──────────────────────────────────────────────────────┘ ```

- **Knowledge Layer:** Combines structured database entries with unstructured semantic content into a unified knowledge graph. - **Governance Layer:** Enforces granular role-based access control (RBAC), restricting agent data queries strictly to the context authorized for a given request. - **Actionability Layer:** Manages bi-directional execution, enabling agents to retrieve context and safely post transactional state updates back to underlying records.

This architecture creates a compounding speed advantage. Once an organization links its core systems into an Enterprise Context Graph for an initial project (such as invoice reconciliation), subsequent projects (such as inventory rebalancing) can be deployed almost immediately by consuming the existing semantic layer.

Building on an assembly-first model allows teams to swap underlying models seamlessly as token prices decrease or superior frontier models emerge. It also enables teams to adjust human-in-the-loop parameters or transition components to full autonomy without rewriting underlying cloud application code.

[14:38](https://www.youtube.com/watch?v=FR7r95C65kg&t=878s) Technical Blueprint for a Scalable AI OS

Bhatti concludes the first half of his talk by presenting the technical requirements for an enterprise-ready AI Operating System. The platform must remain deployment-agnostic (supporting cloud SaaS, private Virtual Private Clouds, or on-premise physical servers) while supplying a full suite of platform services:

- **Unified Data & Knowledge Infrastructure:** Capabilities must include native ETL/reverse-ETL processing, master data management, data lineage mapping, cataloging, and automated survivorship rules. - **Modular Application Builders:** Low-code/no-code builder interfaces for workflow functions, human-in-the-loop interfaces (embedded within Salesforce, standalone web tools, or mobile push alerts), and single/multi-agent orchestrators. - **Protocol Interoperability & Governance:** Built-in support for invoking third-party agents and exposing internal functionality through protocols like the Model Context Protocol (MCP). End-to-end governance must track agent conversations, enforce strict guardrails, and comply with evolving industry-specific frameworks (such as emerging financial sector AI compliance mandates).

Here is a detailed, faithful walkthrough of the provided transcript segment:

[16:26](https://www.youtube.com/watch?v=FR7r95C65kg&t=986s) Governance, Enterprise OS Architecture, and a Case Study Success

Waseem Bhatti emphasizes that true enterprise AI requires strict, end-to-end governance. Organizations must ask themselves how their AI agents adhere to the exact same controls that govern their human workforce and IT systems—and if an agent fails to meet those standards, the architecture must allow it to be ripped out of production immediately. Presenting the UnifyApps platform architecture slide, he explains that clients deploy the solution directly into their existing workflows to scale use cases in a no-code manner with built-in enterprise capabilities.

He references a real-world client that had previously been stuck among the 95% of failed enterprise AI initiatives when trying to build on their own. After partnering with UnifyApps, they successfully transitioned into the 5% that reach production. The transformation took two months and involved approximately 143 FTEs to construct and launch the complete solution. On day one of going live, the system processed over 50,000 invoices by focusing on a specific subset of variance. That same client has since scaled to running over 20 distinct production use cases on the platform.

``` +--------------------------------+ | Enterprise Systems & Controls | +---------------+----------------+ | v +--------------------------------+ | UnifyApps AI OS (No-Code) | +---------------+----------------+ | v +--------------------------------+ | 50,000+ Invoices Processed/Day | | (Scaling 20+ Production) | +--------------------------------+ ```

- **Time to Production:** 2 months with ~143 FTEs involved in the build. - **Day One Scale:** Over 50,000 invoices processed immediately upon going live. - **Ongoing Scale:** The client actively runs and expands across 20+ live use cases today.

[17:29](https://www.youtube.com/watch?v=FR7r95C65kg&t=1049s) Deployment Methodology: The Flywheel and COE Strategy

Scaling AI into production extends beyond technology alone; it requires a structured operational framework. UnifyApps assigns dedicated forward-deployed engineers to assist clients during implementation. Bhatti warns against a common mistake made by enterprise organizations: establishing a Center of Excellence (COE) too early. Starting with a COE often leads to disconnected use cases that fail to gain traction across different business units.

The recommended approach begins with identifying a single, high-impact "lighthouse use case" driven by a clear ROI hypothesis. Once that initial pilot achieves success and value is proven, the enterprise can build out the COE. This sequence allows the client to own the AI flywheel, rapidly ingesting new use cases into production using a defensible, repeatable operational framework that can be confidently presented to executive boards.

- **Client Base:** UnifyApps serves over 100 enterprise customers, including public sector organizations in Dubai, major financial services institutions in the US and globally, and leading healthcare providers. - **Operational Sequence:** 1. Identify a high-ROI lighthouse use case. 2. Prove value and build confidence. 3. Establish the Center of Excellence (COE). 4### Strict Governance and Architecture for the 5%

Waseem Bhatti stresses the critical need for enterprise-grade control over AI implementations. Organizations must demand a level of governance where AI agents are subjected to the exact same rigorous security and operational checks as human employees and existing IT systems. If an agent fails to meet these strict compliance controls, enterprise architects need the capability to immediately "rip it out of production." The displayed UnifyApps architecture demonstrates how clients can deploy solutions directly into their existing operational workflows with out-of-the-box, no-code capabilities, bridging the gap between raw models and scalable enterprise execution.

Reflecting on the real-world client case study, Bhatti details how the company transitioned from the 95% of stalled AI pilots into the elite 5% that reach production. By partnering with UnifyApps, the organization transformed its trajectory in just two months using a team of roughly 143 full-time equivalents (FTEs). On day one of going live, the system successfully processed over 50,000 invoices by targeting a specific subset of process variance. Today, that same client has expanded its operations with UnifyApps to scale over 20 distinct enterprise use cases.

- **Governance Requirement:** AI agents must pass identical enterprise security controls as human operators and legacy systems. - **Implementation Timeline:** 2 months to move from a stalled pilot to live production. - **Scale at Launch:** Processed 50,000+ invoices on day one of deployment. - **Current Production Footprint:** Scaled across 20+ active enterprise use cases.

[17:29](https://www.youtube.com/watch?v=FR7r95C65kg&t=1049s) Execution Strategy, Flywheels, and Global Impact

Deploying enterprise AI successfully requires a balance of advanced technology and a structured deployment methodology. UnifyApps provides dedicated forward-deployed engineers to work alongside client teams and guide their operational strategy. Bhatti warns against a common organizational pitfall: establishing a Center of Excellence (COE) too early. Setting up a COE before proving value often leads to disconnected use cases across different business units. The ideal sequence starts with finding a single, high-impact "lighthouse" use case with a clear ROI hypothesis. Once that initial project proves successful, companies can build the COE to manage a self-sustaining innovation flywheel.

UnifyApps currently serves over 100 enterprise clients globally across diverse industries, including the public sector in Dubai, major financial services firms in the United States and abroad, and healthcare giants. This architecture provides executive leadership teams with defensible metrics and operational clarity when presenting AI investments to their boards.

- **Deployment Model:** Assigns dedicated forward-deployed engineers to guide setup and execution. - **Strategic Phasing:** Focus on a lighthouse use case first; establish the Center of Excellence (COE) second. - **Customer Base:** 100+ active enterprise clients spanning US and international financial services, healthcare, and Dubai public sector organizations.

[18:27](https://www.youtube.com/watch?v=FR7r95C65kg&t=1107s) The Master Catalog and Actionable Next Steps

For organizations evaluating potential AI initiatives, UnifyApps maintains a Master Agent Application Catalog featuring over 125 fully documented, live customer use cases. Unlike theoretical frameworks or pilot concepts, every entry outlines the specific process area, the deployed production solution, the measured

## Notable quotes > [00:00](https://www.youtube.com/watch?v=FR7r95C65kg&t=0s) Why do nearly 95% of enterprise AI initiatives stall in the pilot phase despite widespread adoption? — Waseem Bhatti

> [00:00](https://www.youtube.com/watch?v=FR7r95C65kg&t=0s) The bottleneck is not the model itself, but a pre-AI architecture that bolts intelligence onto fragmented systems and siloed data. — Waseem Bhatti

> [00:00](https://www.youtube.com/watch?v=FR7r95C65kg&t=0s) To unlock scalable value, organizations must look beyond raw model intelligence—which is only 20% of the puzzle—and address the 80% architectural challenge by establishing a Horizontal AI Operating System. — Waseem Bhatti

> [00:04](https://www.youtube.com/watch?v=FR7r95C65kg&t=4s) Raw model intelligence (the LLM) accounts for only 20% of what is required to scale an AI use case; the remaining 80% depends entirely on the surrounding architecture. — Waseem Bhatti

> [02:46](https://www.youtube.com/watch?v=FR7r95C65kg&t=166s) Lack of a Single Source of Truth — Waseem Bhatti

> [02:46](https://www.youtube.com/watch?v=FR7r95C65kg&t=166s) Rigid "All-in-One" Custom Code — Waseem Bhatti

> [10:57](https://www.youtube.com/watch?v=FR7r95C65kg&t=657s) The raw AI model is like a Rolls-Royce jet engine—a high-performance component—but passengers sit in, interact with, and rely on the complete Boeing aircraft surrounding it. — Waseem Bhatti

> [16:26](https://www.youtube.com/watch?v=FR7r95C65kg&t=986s) Organizations must ask themselves how their AI agents adhere to the exact same controls that govern their human workforce and IT systems—and if an agent fails to meet those standards, the architecture must allow it to be ripped out of production immediately. — Waseem Bhatti

> [17:29](https://www.youtube.com/watch?v=FR7r95C65kg&t=1049s) The recommended approach begins with identifying a single, high-impact "lighthouse use case" driven by a clear ROI hypothesis. — Waseem Bhatti

## Mentioned Waseem Bhatti, UnifyApps, Ai4, MIT, SAP, Anthropic, Google, Microsoft Teams, Oracle, Ariba, Boeing, Rolls-Royce, DocuSign, Salesforce

## Video description Waseem Bhatti - Principal Solutions Architect, UnifyApps

Why do nearly 95% of enterprise AI initiatives stall in the pilot phase despite widespread adoption? The bottleneck is not the model itself, but a pre-AI architecture that bolts intelligence onto fragmented systems and siloed data. To unlock scalable value, organizations must look beyond raw model intelligence—which is only 20% of the puzzle—and address the 80% architectural challenge by establishing a Horizontal AI Operating System.

This session delivers a blueprint to horizontally decouple your data and vertically move toward an assembly-first methodology using modular workflows, apps, and agents.

Join us to walk away with a concrete architectural strategy to stop optimizing past limitations and start building a sovereign foundation for scalable enterprise intelligence.

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

中文简报

UnifyApps推出将企业AI推向生产环境的框架企业AI项目的失败率高达95%，原因在于原始模型智能仅占扩展需求的20%，需要一个横向操作系统来弥合80%的架构差距。 Waseem Bhatti深入剖析了导致企业AI项目深陷“试点泥潭”的结构性瓶颈，指出80%的扩展挑战源于系统架构而非原始LLM能力。通过真实案例研究（例如某大型零售商耗资200万美元进行发票自动化），他指出了僵化定制代码和碎片化数据的缺陷。他提出了一种双轴解耦框架，将企业上下文图谱（Enterprise Context Graph）与组装优先的模块化设计相结合，以实现快速的生产级扩展。最后，Bhatti概述了一种战略部署方法论，主张在建立卓越中心（Center of Excellence）之前，优先落实高ROI的灯塔用例。企业级AI的成功80%取决于周边的架构/操作系统，仅有20%取决于底层的LLM或原始模型智能。 (0:04) 2025年MIT的一项研究显示，95%的企业级AI试点项目在进入生产阶段前陷入停滞，造成了巨额资金浪费。 (0:04) 与借助成熟框架相比，企业自主在内部构建定制AI基础设施时的失败率要高出两倍。 (0:04) 试点项目的失败主要源于各孤立系统之间缺乏单一事实来源，以及对僵化、紧耦合定制代码的依赖。 (2:46) 硬编码的AI实施方式会带来严重的技术债务，因为当“人在回路”监督转向自主执行时，它们无法随之适应。 (2:46)

Reading summary

Waseem Bhatti of UnifyApps argues that 95% of enterprise AI pilots fail not due to model limitations, but because organizations lack a decoupled operating architecture to handle data integration, governance, and operational workflows. The 80/20 Architectural Imbalance in Enterprise AI (0:04) Citing a 2025 MIT study, Bhatti states that 95% of enterprise AI pilot projects stall before reaching live deployment, with internal custom builds facing double the failure rate of established frameworks. He frames this through an 80/20 rule: raw foundation models provide only 20% of the intelligence needed to scale, while the surrounding enterprise architecture accounts for the remaining 80%. Even though analysts project an addressable market of $40 billion by 2030 and up to $4 trillion in unlocked annual value, pilots collapse under the architectural burden of reconciling disparate operational systems and maintaining brittle custom code. The Operational Cost of Bespoke AI Integration (4:37) A case study of a Top 5 US retailer demonstrates how internal bespoke builds deviate from initial estimates. Initially anticipating that a three-month, $150,000 project would automate an invoice workflow costing $15 million annually across 2 million documents, the organization spent more than $2 million over two years. The pilot expanded from a single workflow into over 220 operational paths, requiring custom API connections to 23 legacy systems, multi-way data matching, and 10 separate user interfaces. Decoupling Architectures Through Context Graphs (10:57) Comparing an LLM to a high-performance jet engine that cannot function without a surrounding airframe, Bhatti advocates a dual-axis decoupled architecture. Horizontal decoupling establishes an Enterprise Context Graph—comprising knowledge, governance, and bidirectional actionability layers—above core platforms such as SAP and CRMs to resolve conflicting inputs. Vertical decoupling follows an assembly-first approach where modular components like user interfaces, orchestration agents, and connectors can be reused across use cases. Governance and the Lighthouse Deployment Model (16:26) Bhatti emphasizes that enterprise AI agents must adhere to the same operational and security standards as human employees and legacy systems, including capabilities to immediately remove failing agents from production. Rather than launching a Center of Excellence upfront—a pitfall that often causes disconnected use cases—enterprises are advised to deploy a high-ROI 'lighthouse' project first. UnifyApps cites an engagement where a client moved from a stalled pilot to production in two months using roughly 143 full-time equivalents, processing over 50,000 invoices on day one and expanding to more than 20 production use cases. While UnifyApps reports serving over 100 enterprise customers with a catalog of 125 documented production use cases, the framework relies on access to modular orchestration infrastructure and forward-deployed engineering support, leaving open how purely internal teams can replicate these operating layers without specialized vendor software.

精炼阅读摘要

UnifyApps首席解决方案架构师Waseem Bhatti指出，当前企业人工智能落地的核心瓶颈在于系统架构而非底层模型能力；高达95%的企业试点项目因缺乏统一数据层和死板的代码封装而停滞，企业需借助双轴解耦架构与先试点后卓越中心的实施路径实现规模化生产。试点停滞根源与80/20架构法则 (0:04) Bhatti援引2025年麻省理工学院（MIT）的研究指出，95%的企业人工智能试点项目无法推进到生产阶段，导致大量资本浪费。分析机构预测，到2030年该领域可触达市场规模将达400亿美元，每年有望在业务流程中释放超过4万亿美元价值，60%至70%的知识工作被评估为可被AI自动化。然而，内部自建生产级AI基础设施的企业面临高达两倍的失败率。 Bhatti提出“80/20法则”，即底层大语言模型（LLM）的智能仅占AI应用落地所需要素的20%，其余80%完全取决于外围企业架构。当前试点失败主要源于两大架构缺陷：一是缺乏单一事实来源，AI代理在ERP、CRM等分散系统中经常面临冲突数据；二是企业倾向于围绕特定模型编写硬编码定制系统，导致系统既无法随流程成熟动态调整人机协同比例，也无法在更换底层模型时免除全盘重构的技术债务。发票自动化案例：两百万美元的自建陷阱 (4:37) Bhatti以全美前五大零售商的发票自动化项目为例，展示了低估架构难度的代价。该零售商每年处理超200万张发票，人工支出达1500万美元，且使月度财务结算周期延长3天。管理层最初基于两周试点，预计投入15万美元、由小型团队在3个月内完成单一工作流；但最终实际耗时2年，花费超过200万美元。项目在生产阶段全面失控：团队耗资18万美元将23个遗留系统通过定制API接入；花费约50万美元处理杂乱的格式、采购订单编号及供应商名称匹配；原本的单项工作流在生产中激增至220多项业务流程，消耗72万美元；为了覆盖一线员工、审计员和供应商，不得不构建10个交互界面和多代理层级架构，耗资增至180万美元。最终，系统还面临双向写入Oracle与Ariba的存续性审计及SOC 2合规审查。更为严重的是，由于系统架构高度固化，该零售商剩余的100多个潜在应用场景完全无法复用这套耗费巨资的基础设施。双轴解耦与企业语境图谱 (10:57) 针对模型与企业系统的集成难题，Bhatti将LLM比作罗尔斯·罗伊斯喷气发动机，而企业级AI操作系统则是搭载乘客所需的波音整机，仅有高性能引擎无法直接安全载客。企业若要进入成功落地AI的5%行列，必须在架构上完成横向与纵向的双轴解耦。横向解耦是指在底层记录系统之上建立统一抽象层，核心为包含三层结构的“企业语境图谱”：一是融合结构化数据库与非结构化语义数据的知识层；二是执行细粒度基于角色的访问控制（RBAC）的治理层；三是管理上下文检索并安全回写业务状态的操作层。纵向解耦则采用“组装优先”模式，将连接器、代理逻辑和交互界面模块化，实现N+1设计复用。这种架构允许企业在模型降价或新前沿模型推出时无缝热插拔，且无需重写业务应用代码即可调整自动化程度。实施飞轮与企业级治理策略 (16:26) 在治理与管控层面，Bhatti强调生产级AI代理必须遵循与人类员工和传统IT系统同等严苛的安全控制标准，一旦代理无法满足合规要求，架构必须支持立即将其从生产环境中撤除。依托统一的操作系统架构，客户能够以无代码方式直接在其业务流程中部署并扩展AI能力。在落地方法论上，Bhatti警告企业切忌过早设立卓越中心（COE），否则容易导致各业务单元的用例碎片化且无法产生实效。推荐的推进顺序为：首先聚焦一个具备明确ROI假设的高影响力“灯塔用例”以证明业务价值；在建立信心后，再组建COE以掌握创新的运转飞轮，从而向董事会展示可防御且可复制的实施路径。目前UnifyApps在全球服务超100家企业客户，并沉淀了包含125个以上实际生产用例的应用目录；某此前自建失败的企业通过该模式在2个月内动用约143名全职人力完成重构，上线首日即处理逾50,000张发票，现已扩展至20多个在线生产用例。 Bhatti论证了企业AI规模化依赖于平台级解耦架构与务实的灯塔试点策略，但对于遗留系统极其陈旧、接口标准严重缺失的传统企业，如何以合理成本完成初始语境图谱的数据清洗与双向写回集成，仍需在实践中进一步评估。

Detailed notes — zh

## Background 本内容由 Ai4 频道于 2026 年 8 月 14 日发布在 YouTube 平台上，演讲人为 UnifyApps 首席解决方案架构师 Waseem Bhatti。页面描述指出，近 95% 的企业级 AI 项目因底层架构滞后和数据孤岛而停滞在试点阶段，本场演讲旨在通过横向解耦数据与“组装优先”的模块化方法，为企业构建可落地的企业级 AI 操作系统。 ## TL;DR 演讲指出了企业 AI 落地面临的“80/20 法则”：大模型智能仅占 20%，而系统集成、数据治理与流程编排等底层架构挑战占据了 80% 的成败关键。演讲通过全美前五大零售商自研陷入 200 万美元泥潭的真实案例，揭示了数据孤岛与刚性单体架构的痛点，并提出了水平解耦（构建企业上下文图谱）与垂直解耦（组装优先、模型无感知）的破局方案。最后，演讲者结合 UnifyApps 在 2 个月内上线发票处理用例的实战经验，强调应先通过“灯塔用例”验证 ROI 再搭建 AI 卓越中心（COE），从而推动企业 AI 规模化投产。 ## Atmosphere & style 整场演讲风格干练、务实且极具工程实战洞见，演讲者凭借深厚的企业级架构经验，以生动形象的“发动机与客机”比喻直击行业痛点。叙事节奏紧凑有力，从剖析惨痛的自研“血泪史”逐步过渡到体系化的架构破局方案，情绪上从揭示行业困局的警醒转变为提供清晰落地蓝图的笃定与自信。观众在聆听时能深切感受到这是一场直面真实工程挑战、拒绝概念空转的企业 AI 落地指南。 ## Key takeaways - [00:04](https://www.youtube.com/watch?v=FR7r95C65kg&t=4s) MIT 2025 年研究显示，近 95% 的企业 AI 试点项目无法成功走向生产环境，完全自研落地系统的失败概率是采用成熟架构平台的两倍。 - [00:04](https://www.youtube.com/watch?v=FR7r95C65kg&t=4s) 企业 AI 落地遵循“80/20 法则”：LLM 模型本身的智能仅占 20%，而决定项目能否规模化落地的核心瓶颈在于其余 80% 的底层架构与工程支撑能力。 - [02:46](https://www.youtube.com/watch?v=FR7r95C65kg&t=166s) 试点走向生产的第一大破裂点是缺乏企业级单一真实数据源（Single Source of Truth），多系统数据冲突会导致输入给 Agent 的上下文失真并引发幻觉与错误决策。 - [02:46](https://www.youtube.com/watch?v=FR7r95C65kg&t=166s) 第二大破裂点是刚性单体构建（Rigid All-in-One Build），将模型、业务规则与交互流程深度硬绑定会导致系统无法动态调整人机协同比例，且无法自由替换底层模型。 - [04:37](https://www.youtube.com/watch?v=FR7r95C65kg&t=277s) 某全美零售巨头的发票对账案例表明，由于低估了接口集成、数据标准化、分支流程激增及合规治理的复杂度，自研项目耗时超 2 年、花费突破 200 万美元且代码无法复用。 - [09:39](https://www.youtube.com/watch?v=FR7r95C65kg&t=579s) LLM 就像波音客机搭载的劳斯莱斯发动机，仅提供 20% 的核心动力，企业必须构建承载整个业务安全运行的 80% 飞机机身（企业级 AI 操作系统）。 - [09:39](https://www.youtube.com/watch?v=FR7r95C65kg&t=579s) 破局需要实现水平解耦（构建企业上下文图谱以统一连接、权限与回写）与垂直解耦（组装优先开发范式，实现模型热插拔与资产 N+1 级复用）。 - [12:08](https://www.youtube.com/watch?v=FR7r95C65kg&t=728s) 企业上下文图谱（ECG）融合了结构化与非结构化语义数据、细粒度数据访问权限以及双向安全回写能力，可产生显著的复合交付速度（Compounding Speed）。 - [14:38](https://www.youtube.com/watch?v=FR7r95C65kg&t=878s) 面向未来的企业 AI 操作系统涵盖模型无感知部署、异构系统数据连接、低代码构建器矩阵（工作流/HITL/多 Agent 编排与 MCP 支持）及端到端治理体系。 - [16:26](https://www.youtube.com/watch?v=FR7r95C65kg&t=986s) 企业必须对 AI Agent 实施与人类员工和现有系统同等严格的管控与随时下线机制；UnifyApps 助力客户将发票对账项目在 2 个月内落地并横向扩展至 20 多个场景。 - [17:29](https://www.youtube.com/watch?v=FR7r95C65kg&t=1049s) 企业应规避先建 AI 卓越中心（COE）再找业务场景的脱节陷阱，正确路径是先打赢代表性“灯塔用例”验证 ROI，再顺势建立 COE 推动飞轮效应。 - [18:27](https://www.youtube.com/watch?v=FR7r95C65kg&t=1107s) 企业挑选切入用例可采取双轨策略：要么从 125+ 生产级 Agent 目录中像点餐一样快速复用成熟范式，要么直接攻坚痛点最深、ROI 最高的硬骨头场景。 ## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=FR7r95C65kg&t=4s) 企业 AI 的困境：95% 的失败率与 80/20 法则 UnifyApps 首席解决方案架构师 Waseem Bhatti 拥有十年在联邦政府从事数字化转型与工作流自动化的实战经验。他开门见山地指出，当今企业在推进 AI 时普遍面临一个残酷的现实：绝大多数企业投入大量资金的试点项目（Pilot）最终都无法成功走入生产环境。UnifyApps 的定位正是为企业的 CIO 打造一套“企业级 AI 操作系统”，帮助客户在短短数周内将用例从原型推向生产，从而真正跻身那成功实现规模化落地的 5% 领跑企业之列。根据 MIT 在 2025 年发布的研究报告，高达 95% 的企业 AI 试点项目在迈向生产阶段时停滞不前，造成了巨大的资金与资源浪费。数据显示，企业如果选择完全“自研自建”（Build it yourself），其生产落地失败率会直接飙升两倍。这背后的核心症结在于企业 AI 领域的“80/20 法则”：在实现 AI 规模化落地的全过程中，模型（LLM）本身的智能水平只占 20% 的比重，而决定项目生死成败的其余 80%，完全取决于底层架构与工程支撑能力。尽管落地困难重重，但企业布局 AI 的驱动力显而易见。各大分析机构一致预测，到 2030 年，企业级 AI 的潜在市场规模（TAM）将达到 400 亿美元，每年有望在知识工作领域创造超过 4 万亿美元的经济价值。当前企业内部 60% 至 70% 的业务流程和知识工作都可以被 AI 自动化。企业并不是看不到价值，也不是缺乏尝试的意愿，而是全部被困在了那致命的“80% 架构泥潭”中。 - **MIT 2025 研究数据**：近 95% 的企业 AI 试点项目未能成功在生产环境中规模化落地。 - **自研风险**：企业完全自研 AI 落地系统的失败概率是采用成熟架构平台的 2 倍。 - **80/20 规律**：模型选型只决定 20% 的成效，80% 的成败取决于系统集成、数据治理与编排架构。 - **市场预期**：到 2030 年市场空间达 400 亿美元，每年释放超 4 万亿美元价值，60%-70% 业务流程具备自动化潜力。 --- ### [02:46](https://www.youtube.com/watch?v=FR7r95C65kg&t=166s) 试点走向生产的两大破裂点：数据孤岛与刚性单体架构当 AI 用例从原型演示走向严苛的生产环境时，系统往往不是在模型层崩溃，而是在两个关键维度上彻底失控。第一个破裂点是**缺乏企业级单一真实数据源（Single Source of Truth）与巨大的数据方差**。在简单的 Demo 中，模型处理几条规整的数据十分顺畅；但在实际生产中，一个简单的理赔审核或产能规划决策往往涉及调用 20 多个业务系统，各系统返回的数据常常互相矛盾。比如，SAP 系统记录对某供应商的付款金额是一笔数字，而采购系统却根据特定促销 SKU 规则给出了另一个金额。没有统一的上下文调和层，输入给 Agent 的信息互相冲突，必然导致严重的决策错误与幻觉。第二个破裂点则是**刚性单体构建（Rigid All-in-One Build）导致的不可维护性**。许多团队在开发初期把所有业务规则、人机协同（Human-in-the-Loop, HITL）流程、异常升级机制以及特定大模型代码完全硬编码、硬绑定在一起。然而，企业 AI 应用的演进是一个动态过程：项目上线第一天可能只有 30% 走全自动流程，70% 需要人工介入；随着准确率与置信度提升，自动化比例会逐步扩大。如果整个系统是铁板一块，每一次流程微调都会演变成灾难性的重构。更糟糕的是，如果代码深度绑定了某一家厂商的模型（如 Anthropic Claude），当市场上出现性价比更高或性能更强的新模型（如 Google 新发布的模型）时，企业根本无法敏捷替换，彻底丧失了“组装优先”（Assembly-First）的重用与演进能力。 ```mermaid flowchart TD accTitle: 试点与生产环境的落差示意图 subgraph Pilot["试点环境 (20% 模型层)"] A["简单受控数据"] --> B["单一前沿模型 (LLM)"] B --> C["单一路径演示成功"] end subgraph Production["生产环境 (80% 架构层挑战)"] D["20+ 异构系统 / 数据冲突"] --> E["企业上下文缺失"] E --> F["刚性单体硬编码"] F --> G["系统崩溃 / 治理失效 / 无法扩展"] end Pilot -. "进入生产阶段".-> Production ``` --- ### [04:37](https://www.youtube.com/watch?v=FR7r95C65kg&t=277s) 真实血泪史：全美前五大零售商的 200 万美元落地泥潭为了具象化说明这一困境，Waseem 分享了一家全美前五大零售商的真实案例。该客户挑选了一个极具代表性的“灯塔用例”——发票对账与处理。该零售商每月需要处理数十万张发票，年处理量超过 200 万张，为此每年背负超过 1500 万美元的人工劳动力成本，且月底关账需要额外耗费 3 天时间向 CFO 汇报。在仅进行了为期两周的快速 PoC 验证后，团队乐观地推断：只需 3 个月时间、15 万美元预算和几名工程师，就能利用大模型完美解决该问题。然而，一旦进入真实生产阶段，残酷的“80% 架构陷阱”开始全面显现： 1. **连接层泥潭（第 3 个月，支出 18 万美元）**：生产环境需要对接 23 个遗留系统和数百个 API。开源集成工具根本无法支持如此多复杂的企业级接口，团队不得不从零造轮子，陷入了 API 凭证管理、Token 过期处理等无休止的底层接口开发中，此时项目尚未涉及任何智能逻辑，预算就已经超支。 2. **数据标准化泥潭（第 7 个月，累计支出近 50 万美元）**：同一供应商名称在各系统中存在四种不同写法，发票格式五花八门，采购订单（PO）编号在跨系统匹配时频繁错位。为了完成多方对账（Multi-Way Matching），团队花费数月进行数据清洗与主数据标准化。 3. **流程编排泥潭（第 12 个月，累计支出 72 万美元）**：试点阶段只有 1 条理想化工作流，但生产环境由于各种业务变体，衍生出了超过 220 条分支工作流。系统不仅要处理自动审批、升级上报与跨系统回写，还必须构建确定性函数（Deterministic Functions），因为团队不可能让高昂且不可控的 LLM 去逐一处理每一个确定性的业务逻辑步骤。 4. **人机协同泥潭（第 1 年以上，累计支出超 100 万美元）**：业务需要覆盖一线操作员、审计员、业务经理、应付账款（AP）文员及外部供应商等 10 种不同角色的 UI 体验。有人习惯在 Microsoft Teams 协同，有人使用专有 SaaS，有人依赖邮件交互，如何让同一个用例适配多样化的交互形态成为巨大工程负担。 5. **多 Agent 编排泥潭（第 2 年，累计支出 180 万美元）**：试点中用 1 个单一 Agent 处理小批量发票行得通，但在每月 20 万张复杂发票的冲击下彻底失效。团队必须重构为多 Agent 体系（上下文 Agent、子任务 Agent、主编排 Agent），并自行摸索 Guardrails 护栏、用量计量、效果评测等工具链。 6. **回写与治理泥潭（耗时超 2 年，总支出突破 200 万美元）**：系统必须将最终交易结果可靠地回写至 Oracle、SAP Ariba 等核心记录系统（System of Records），并确保审计留痕与数据存活机制（Survivorship）。在临门一脚时，甚至可能遭遇 CISO（首席信息安全官）的一票否决——因缺乏 SOC 2 合规证明、数据删除机制、模型区域使用合规性审计及防数据泄漏机制，整个项目随时面临被叫停的风险。最令人绝望的是，发票处理仅仅是该零售商规划中的 100 多个 AI 用例之一（仅财务部门就有 25 个）。由于他们采用的是刚性单体自研架构，这些耗费 200 多万美元堆砌出来的代码几乎没有任何可复用性，下一个用例仍需从头踩一遍所有的坑。 --- ### [09:39](https://www.youtube.com/watch?v=FR7r95C65kg&t=579s) 破局之道：劳斯莱斯发动机与波音飞机的隐喻，以及两大架构解耦针对上述灾难性局面，Waseem 提出了一个生动的工程比喻：“许多人搭乘波音客机来到大会现场。飞机上搭载的劳斯莱斯发动机（Rolls-Royce Engine）就像是 LLM，它是强大的动力源；但旅客实际接触、乘坐、登机以及体验座舱服务的整架波音飞机，才是真正载你抵达目的地的系统。”如果把大模型当作系统的全部，就如同以为拥有了一台喷气式发动机就能直接翱翔蓝天一样荒谬。模型只贡献了 20% 的核心动力，其余 80% 的系统与工程架构才是确保安全稳定运行的前提。要摆脱 95% 失败的命运并进入前 5% 的成功行列，企业必须完成两大关键的架构解耦转变： ```mermaid flowchart LR accTitle: 企业 AI 架构的两大解耦维度 subgraph Horizontal["水平解耦 (Horizontal Decoupling)"] H1["连接 20+ 底层业务系统"] --> H2["企业上下文图谱 (ECG)"] H2 --> H3["统一人身/权限治理与动作回写"] end subgraph Vertical["垂直解耦 (Vertical Decoupling)"] V1["模型无感知 (可任意热插拔)"] V2["工作流 / 确定性逻辑解耦"] V3["HITL 人机协同组件化"] V4["资产与连接器 N+1 级复用"] end Horizontal <--> Vertical ``` - **水平解耦（Horizontal Decoupling）**：将底层错综复杂的系统连接、数据标准化、安全治理以及双向动作执行从业务逻辑中抽离出来，在横向上构建统一的企业上下文图谱，为上层所有 Agent 提供真正权威的单一事实来源，根除数据冲突与幻觉。 - **垂直解耦（Vertical Decoupling）**：抛弃从前到后硬编码的单体构建模式，采用“组装优先”（Assembly-First）的模块化开发理念。将模型调用、业务编排、人机交互与工具执行完全解耦，遵循“N+1 理论”——为第一个用例打通的基础设施和连接组件，能够直接无缝复用到后续的第 N 个用例中，实现指数级的交付加速。 --- ### [12:08](https://www.youtube.com/watch?v=FR7r95C65kg&t=728s) 企业上下文图谱与组装优先的敏捷开发范式在水平解耦的具体落地中，企业需要构建一个包含三个核心层次的**企业上下文图谱（Enterprise Context Graph, ECG）**： 1. **统一知识图谱层**：将 CRM（销售记录）、ERP（如 SAP 中的物料清单 BOM）等结构化数据，与 DocuSign 合同、邮件备注等非结构化语义数据融为一体，自动消除跨系统的数据歧义与冲突。 2. **细粒度治理与安全层**：精确定义并执行数据访问权限。当某个 Agent 发起跨系统查询时，系统能够动态裁定该 Agent 是否具备相应的数据读取权限，确保合规与隔离。 3. **双向可操作性与回写层（Actionability）**：赋予 Agent 不仅能读、更能安全回写事务的能力，形成闭环的端到端调和上下文。这种架构带来了显著的**复合交付速度（Compounding Speed）**。当企业为了“发票对账”用例打通了系统连接、建立了语义层和上下文图谱后，接下来若要推进“库存重平衡（Inventory Rebalancing）”等全新用例，团队无需重复进行繁重的底层数据管道开发，直接调用已有图谱即可在极短时间内完成搭建。在垂直层面上，组装优先的设计让团队拥有了前所未有的灵活性。开发人员无需将业务逻辑死死绑定在某一款特定大模型的专有 SDK 上，而是可以根据任务特性自由热插拔底层模型：在需要极高推理能力的分支使用最顶尖的前沿模型，在简单分类步骤无缝切换为低成本的轻量原子模型；同时，系统能够随业务成熟度动态滑动“自主化控制杆”——在初期配置紧密的人机协同审核，在置信度达标后一键切换为全自主运行，全程无需进行任何底层重构。 --- ### [14:38](https://www.youtube.com/watch?v=FR7r95C65kg&t=878s) 面向未来的企业级 AI 操作系统全景架构为了从根本上支撑企业级 AI 的规模化落地，现代 AI 基础设施必须具备高度通用、灵活解耦的平台能力。架构设计必须保持前瞻性，以应对模型代际更迭与 Token 成本持续骤降的行业趋势，确保企业的业务资产独立于底层的具体模型实现。一个健全的企业 AI 操作系统涵盖以下核心支柱： - **模型无感知与全环境部署**：系统必须完全解耦于具体的底层基础模型，同时支持物理机私有化部署、企业专属 VPC 托管以及全托管 SaaS 等多种部署形态，满足不同合规等级要求。 - **异构系统连接与统一数据知识层**：全面连接结构化数据库、非结构化文档池与日常业务活动系统；向上构建包含主数据存活机制（Survivorship）、ETL 与逆向 ETL（Reverse ETL）回写、数据目录与数据血缘在内的完整上下文层。 - **全栈低代码/无代码构建器矩阵**： - **工作流构建器**：用于编排确定性函数与业务规则，分担大模型不必要的推理开销。 - **人机协同构建器**：可一键将审核界面嵌入员工现有的工作流中（如嵌入 Salesforce、推送移动端通知、或生成独立 UI）。 - **多 Agent 编排引擎**：支持构建单 Agent、多 Agent 协作网络、调度第三方外部 Agent，并全面支持通过模型上下文协议（MCP, Model Context Protocol）进行工具与能力的双向调用和开放暴露。 - **全生命周期治理与可观测性**：提供覆盖从底层数据连接、Agent 交互内容实时监控、敏感词与安全护栏（Guardrails）拦截，到严格满足金融、医疗等行业最新监管框架的端到端治理体系。 ### [16:26](https://www.youtube.com/watch?v=FR7r95C65kg&t=986s) 企业级 AI 治理与 UnifyApps 架构落地案例企业在部署 AI Agent 时，必须建立与现有系统和人工流程同等级别的严格治理与管控体系。如果系统能够通过合规审查，人类员工也能遵守安全规范，那么 AI Agent 同样必须经受住这些考验；一旦 Agent 达不到标准，企业必须具备随时将其从生产环境中“直接撤下”的治理能力。UnifyApps 的平台架构正是为了满足这种严苛的企业级管控而设计，支持客户在任何需要开展业务的地方即时部署，并以无代码（No-code）的方式开箱即用，快速扩展各类高阶 AI 场景。 ```mermaid flowchart TD accTitle: UnifyApps 落地与飞轮扩展流程 subgraph Phase1["第一阶段：灯塔用例破局"] A["寻找灯塔用例\n(Lighthouse Use Case)"] --> B["验证 ROI 假设\n(FDE 前线部署)"] B --> C["2 个月投产上线\n(首日处理 50,000+ 发票)"] end subgraph Phase2["第二阶段：构建 COE 与飞轮"] C --> D["组建 AI 卓越中心\n(COE)"] D --> E["启动业务飞轮\n(横向扩展 20+ 场景)"] E --> F["形成可向董事会\n汇报的防御性业务成果"] end ``` 演讲者回顾了此前提到的典型客户案例：该客户最初自行摸索试点用例时，一度陷入了那 95% 停滞不前的困境中。随后 UnifyApps 介入并派出前线部署工程师（Forward Deployed Engineers, FDE）进行深度支持，历时 2 个月、投入约 1 至 2 名全职工程师资源（FDE），成功将客户带入了实现生产落地的 5% 行列。该项目在上线首日即处理了超过 50,000 张发票，并从特定的差异子集切入逐步攻坚。如今，该客户已经在 UnifyApps 上横向扩展了超过 20 多个业务用例。 - **快速投产成效**：仅耗时 2 个月即实现生产级上线，上线首日即稳定处理逾 50,000 张发票。 - **无代码开箱即用**：所有核心治理与编排能力均原生内置，业务团队无需底层重构即可快速复制。 - **扩展规模**：从最初单一的发票场景扩展到目前超过 20 个跨部门的生产级活跃用例。 --- ### [17:29](https://www.youtube.com/watch?v=FR7r95C65kg&t=1049s) 规避 COE 陷阱与构建业务飞轮将 AI 成功推向生产环境并实现规模化，关键不仅在于底层技术本身，更在于交付和落地的组织方法论。很多企业常常犯一个严重错误——在业务用例尚不明确时就先急于组建 AI 卓越中心（COE, Center of Excellence），导致 COE 与组织其他部门的实际业务用例严重脱节。正确的演进路径应该是：首先找到一个极具代表性的“灯塔用例”（Lighthouse Use Case），建立清晰且可量化的 ROI 假设，由专业的工程力量保障其取得实质性突破；在首战告捷之后再顺理成章地搭建 COE，进而掌控整个业务飞轮。借助正确的底层架构，企业可以把源源不断涌现的新需求迅速转化为投产应用，并建立起一套能够从容向执行董事会（Executive Board）汇报、经得起检验的运营框架。目前，UnifyApps 已在迪拜公共部门、美国及海外顶尖金融服务机构、大型医疗健康集团等超过 100 家客户中成功验证了该模式。 --- ### [18:27](https://www.youtube.com/watch?v=FR7r95C65kg&t=1107s) 125+ 生产级 Agent 目录与用例选择策略 UnifyApps 整理了一份涵盖 125 多个已在客户生产环境中稳定运行的“Master Agent 应用程序目录”（Master Agent Application Catalog）。该目录不仅列出了具体的业务流程领域和实时运行的解决方案，还详细披露了可衡量的实际 ROI 以及对应的落地客户（在保密协议 NDA 允许的范围内公开）。演讲者强调，这些都不是停留在概念验证阶段的实验或假设，而是实打实的生产级业务成果。 ```mermaid flowchart LR accTitle: 选定 AI 用例的双轨路径 subgraph SelectionPath["用例选择策略"] direction TB P1["路径一：目录点餐\n(参考 125+ 生产用例，如 Cheesecake Factory 菜单)"] P2["路径二：难题攻坚\n(直接带来痛点最深、ROI 最高的硬骨头问题)"] end SelectionPath --> V["基于 UnifyApps 架构快速交付高商业价值"] ``` 在挑选切入用例时，企业主要有两种策略路径： 1. **菜单式点选**：查阅包含 125 多个生产用例的 Agent 目录，像翻阅“芝士蛋糕工厂（Cheesecake Factory）菜单”一样，直接挑选成熟范式进行复用。 2. **硬骨头攻坚**：直接把企业目前面临的最大痛点和最棘手难题抛出来。依托 UnifyApps 的解耦架构，攻克 ROI 预期最高的复杂难题，往往能以最快速度验证商业价值并确立先发优势。演讲最后，Waseem Bhatti 邀请现场参会者前往 929 号展位交流探讨，并表示非常乐意与大家进行一对一深度交流，共同规划具体的 AI 生产落地路径。 ## Notable quotes > [00:04](https://www.youtube.com/watch?v=FR7r95C65kg&t=4s) 在实现 AI 规模化落地的全过程中，模型（LLM）本身的智能水平只占 20% 的比重，而决定项目生死成败的其余 80%，完全取决于底层架构与工程支撑能力。 — Waseem Bhatti > [00:04](https://www.youtube.com/watch?v=FR7r95C65kg&t=4s) 企业完全自研 AI 落地系统的失败概率是采用成熟架构平台的 2 倍。 — Waseem Bhatti > [09:39](https://www.youtube.com/watch?v=FR7r95C65kg&t=579s) 许多人搭乘波音客机来到大会现场。飞机上搭载的劳斯莱斯发动机（Rolls-Royce Engine）就像是 LLM，它是强大的动力源；但旅客实际接触、乘坐、登机以及体验座舱服务的整架波音飞机，才是真正载你抵达目的地的系统。 — Waseem Bhatti > [09:39](https://www.youtube.com/watch?v=FR7r95C65kg&t=579s) 如果把大模型当作系统的全部，就如同以为拥有了一台喷气式发动机就能直接翱翔蓝天一样荒谬。模型只贡献了 20% 的核心动力，其余 80% 的系统与工程架构才是确保安全稳定运行的前提。 — Waseem Bhatti > [09:39](https://www.youtube.com/watch?v=FR7r95C65kg&t=579s) 为第一个用例打通的基础设施和连接组件，能够直接无缝复用到后续的第 N 个用例中，实现指数级的交付加速。 — Waseem Bhatti > [16:26](https://www.youtube.com/watch?v=FR7r95C65kg&t=986s) 如果系统能够通过合规审查，人类员工也能遵守安全规范，那么 AI Agent 同样必须经受住这些考验；一旦 Agent 达不到标准，企业必须具备随时将其从生产环境中‘直接撤下’的治理能力。 — Waseem Bhatti > [17:29](https://www.youtube.com/watch?v=FR7r95C65kg&t=1049s) 很多企业常常犯一个严重错误——在业务用例尚不明确时就先急于组建 AI 卓越中心（COE, Center of Excellence），导致 COE 与组织其他部门的实际业务用例严重脱节。 — Waseem Bhatti > [17:29](https://www.youtube.com/watch?v=FR7r95C65kg&t=1049s) 首先找到一个极具代表性的‘灯塔用例’（Lighthouse Use Case），建立清晰且可量化的 ROI 假设，由专业的工程力量保障其取得实质性突破；在首战告捷之后再顺理成章地搭建 COE，进而掌控整个业务飞轮。 — Waseem Bhatti > [18:27](https://www.youtube.com/watch?v=FR7r95C65kg&t=1107s) 查阅包含 125 多个生产用例的 Agent 目录，像翻阅‘芝士蛋糕工厂（Cheesecake Factory）菜单’一样，直接挑选成熟范式进行复用。 — Waseem Bhatti ## Mentioned UnifyApps, Waseem Bhatti, Ai4, MIT, Anthropic Claude, Google, SAP, SAP Ariba, Oracle, Microsoft Teams, Salesforce, DocuSign, Model Context Protocol (MCP), Enterprise Context Graph (ECG), Rolls-Royce, Boeing ## Video description Waseem Bhatti - Principal Solutions Architect, UnifyApps Why do nearly 95% of enterprise AI initiatives stall in the pilot phase despite widespread adoption? The bottleneck is not the model itself, but a pre-AI architecture that bolts intelligence onto fragmented systems and siloed data. To unlock scalable value, organizations must look beyond raw model intelligence—which is only 20% of the puzzle—and address the 80% architectural challenge by establishing a Horizontal AI Operating System. This session delivers a blueprint to horizontally decouple your data and vertically move toward an assembly-first methodology using modular workflows, apps, and agents. Join us to walk away with a concrete architectural strategy to stop optimizing past limitations and start building a sovereign foundation for scalable enterprise intelligence. [Source](https://www.youtube.com/watch?v=FR7r95C65kg)

Source quotes

[0:04] Waseem Bhatti: 在实现 AI 规模化落地的全过程中，模型（LLM）本身的智能水平只占 20% 的比重，而决定项目生死成败的其余 80%，完全取决于底层架构与工程支撑能力。 [0:04] Waseem Bhatti: 企业完全自研 AI 落地系统的失败概率是采用成熟架构平台的 2 倍。 [9:39] Waseem Bhatti: 许多人搭乘波音客机来到大会现场。飞机上搭载的劳斯莱斯发动机（Rolls-Royce Engine）就像是 LLM，它是强大的动力源；但旅客实际接触、乘坐、登机以及体验座舱服务的整架波音飞机，才是真正载你抵达目的地的系统。 [9:39] Waseem Bhatti: 如果把大模型当作系统的全部，就如同以为拥有了一台喷气式发动机就能直接翱翔蓝天一样荒谬。模型只贡献了 20% 的核心动力，其余 80% 的系统与工程架构才是确保安全稳定运行的前提。 [9:39] Waseem Bhatti: 为第一个用例打通的基础设施和连接组件，能够直接无缝复用到后续的第 N 个用例中，实现指数级的交付加速。 [16:26] Waseem Bhatti: 如果系统能够通过合规审查，人类员工也能遵守安全规范，那么 AI Agent 同样必须经受住这些考验；一旦 Agent 达不到标准，企业必须具备随时将其从生产环境中‘直接撤下’的治理能力。 [17:29] Waseem Bhatti: 很多企业常常犯一个严重错误——在业务用例尚不明确时就先急于组建 AI 卓越中心（COE, Center of Excellence），导致 COE 与组织其他部门的实际业务用例严重脱节。 [17:29] Waseem Bhatti: 首先找到一个极具代表性的‘灯塔用例’（Lighthouse Use Case），建立清晰且可量化的 ROI 假设，由专业的工程力量保障其取得实质性突破；在首战告捷之后再顺理成章地搭建 COE，进而掌控整个业务飞轮。 [18:27] Waseem Bhatti: 查阅包含 125 多个生产用例的 Agent 目录，像翻阅‘芝士蛋糕工厂（Cheesecake Factory）菜单’一样，直接挑选成熟范式进行复用。

Source quotes

[0:00] Waseem Bhatti: Why do nearly 95% of enterprise AI initiatives stall in the pilot phase despite widespread adoption? [0:00] Waseem Bhatti: The bottleneck is not the model itself, but a pre-AI architecture that bolts intelligence onto fragmented systems and siloed data. [0:00] Waseem Bhatti: To unlock scalable value, organizations must look beyond raw model intelligence—which is only 20% of the puzzle—and address the 80% architectural challenge by establishing a Horizontal AI Operating System. [0:04] Waseem Bhatti: Raw model intelligence (the LLM) accounts for only 20% of what is required to scale an AI use case; the remaining 80% depends entirely on the surrounding architecture. [2:46] Waseem Bhatti: Lack of a Single Source of Truth [2:46] Waseem Bhatti: Rigid "All-in-One" Custom Code [10:57] Waseem Bhatti: The raw AI model is like a Rolls-Royce jet engine—a high-performance component—but passengers sit in, interact with, and rely on the complete Boeing aircraft surrounding it. [16:26] Waseem Bhatti: Organizations must ask themselves how their AI agents adhere to the exact same controls that govern their human workforce and IT systems—and if an agent fails to meet those standards, the architecture must allow it to be ripped out of production immediately. [17:29] Waseem Bhatti: The recommended approach begins with identifying a single, high-impact "lighthouse use case" driven by a clear ROI hypothesis.

Original transcript

[0:04] What we want to talk about is how you can take those enterprise AI use cases from that pilot [0:10] pilot investment into that production phase in weeks and help join that 5% of clients and [0:15] organizations that are really scaling AI. Um a little bit of on my side spent the last 10 years [0:20] more in the federal government side doing digital transformation and a lot of automation workflows. [0:25] At Unify Apps what we're providing organizations is what we call the enterprise AI operating system [0:31] for the CIO. Knowing that what it takes to actually scale these use cases is more than [0:36] just an LLM or a good lighthouse use case but what the actual architecture is that's needed [0:41] and I'll be spending the next 20 minutes taking you guys through what we've seen [0:45] and kind of how you can be part of that success we're seeing with more and more organizations. [0:50] Now to start I wanted to just put two figures on the screen and [0:54] the figure in the top left that 95% I'm sure many of you probably know what that represents [0:59] but then in the bottom right I have a figure of 80/20 and that really drives a separate figure. [1:05] Um in the top left that 95% is around that MIT study done in 2025. [1:10] Now depending who you speak to some may agree or may disagree but everyone does [1:14] align that the amount of pilot use cases that are going into production and not scaling and [1:19] are being wasted dollars is extremely high. The studies have shown that about you have a two times [1:24] higher failure rate of taking your pilot use case to production when trying to build it yourself. [1:29] And that drives into that bottom 80/20 percentage that I have. We call this the 80/20 of enterprise [1:35] AI when when you look at what it takes to scale your use case it is only 20% dependent [1:41] on the model itself. The other 80% is what's going to define if you are successful or not. [1:46] And I'll walk us through some examples to show the architecture what we've actually seen around this. [1:50] But two things to really think about are these signals and these numbers as we discuss today. [1:55] Um but before we jump in, really, what's what's the value or what's the potential here [2:01] that's really driving a lot of today's discussion and why so many people are here? [2:05] No matter what analyst you speak to, they all have very credible signals that say, "We're looking at [2:10] a potential addressable market of $40 billion by 2030 with over $4 trillion yearly in annual [2:17] value that it will create within knowledge work and specifically the work that we all do in our [2:21] business processes and organization today. That 60 to 70% of it could be automatable by AI." [2:27] And so we are looking at many different credible data points that believe there's a concentration [2:32] of high value. And so when you think about the failure rates that organizations are seeing, [2:38] it's not from a lack of seeing the value or attempts, it's falling back to that 80%. [2:46] And when we look at where specifically things begin to break down, when you go into the pilot [2:52] phase, there's two things we see. Things are not breaking at the model level. It's breaking at two [2:57] key things. Number one, when you take that use case into production, you realize when you look [3:02] at a process the variance of the data and the information, and AI does not have that single [3:07] source of truth. Whether it's looking at 20-plus systems and having to reconcile that information [3:12] to help you make a decision on something as simple as a claims process or maybe looking at [3:18] um capacity planning for your for your vertical within your organization. And so you have inputs [3:23] coming back to the agents without this enterprise single source of truth that could conflict. You [3:29] have one system, your SAP says, "I paid the vendor this much." You have another system that says, [3:33] "No, the vendor is part of a special that we have, the SKU says pay them this much." Then separately, [3:38] we have another challenge of this rigid all-in-one build where you may be going you build your use [3:43] case. You have tried to put it out in production, but it's a complex build. You have bolted on all [3:49] the different rules. You bolted on the human in the loop. You bolted on the escalation. [3:53] But the value of AI when you look at it is as you mature the process and you get more value, [3:59] the experience changes. Maybe day one when you deploy it, 30% of the use cases are autonomous, [4:06] the other 70% is still human in the loop. But as that value and accuracy goes up, [4:10] you'll notice that you leave more for the autonomous work. How are you able to modify that [4:14] that solution you built? Or today you are using a frontier model, maybe you're using Anthropic. [4:20] Tomorrow Google releases a model that you really like and you want to be able to be [4:24] more assembly first and change it. Well, if you coded everything around the specific model, [4:28] you are now stuck. So you're not able to reuse, rebuild, and have an assembly first mindset. [4:33] And these are the things that's really driving a lot of the failure within clients. [4:37] And um just to go into a real story rather than being theoretical, we had a client come up to us. [4:42] Um top five US retailer. And they went and found a great lighthouse use case. They said, "Look, [4:49] we do hundreds of thousands of invoices per month. We do over 2 million per year. I'm spending over [4:54] $15 million in in and loaded labor cost and it adds three days to my monthly year end on my [5:00] month end close that I have to roll up to my CFO." They had a pilot for 2 weeks and they extrapolated [5:07] from that pilot that with 3 months, 150k, and just a few engineers that I could solve this and [5:13] unlock so much AI value in dollars. Unfortunately, the reality was once they took it to production [5:19] is that 80% started creeping up. Number one, they had 23 systems and hundreds of APIs [5:25] and they had to start figuring out how to connect all of that. They realized that well, [5:29] we can't look at any type of open source integration platform because they're not [5:32] going to have the support or availability of the APIs of my 23 enterprise systems. So I'm going [5:37] to have to start creating and building these items out. And now they're looking at, "Okay, what about [5:42] token expiration? What tools do I utilize?" So at this point, 3 months into the project, [5:47] they actually had already spent 180k, and this was just to start getting the systems connected. [5:53] The next part of their journey was, "Okay, well, we need to standardize the data itself. [5:57] I have structured data, unstructured data." Anyone that's dealt with invoices before, [6:01] you have a multi-way matching to make sure the information is even accurate. So, they had to [6:04] standardize the data. Maybe vendors appeared in four different ways from the same vendor. [6:09] Different formats of the invoices. The PO numbers didn't match across systems. So, [6:13] now they had to start looking at these items and understanding how we're going to do those as well. [6:18] And now they're looking at 7 months into the project in production, [6:21] and they're close to half a million dollars they had invested at that point. [6:25] Once they finally got the data right, they had to think about orchestration because in the pilot, [6:29] they had only one workflow, but in production, it was over 220 workflows based on all the variants, [6:35] the different type of invoices they had coming in. So, now they had to think about auto approval, [6:40] escalation, writing back to systems. I had I need to have a workflow builder cuz I need to create [6:45] deterministic functions for the agent because I don't want to get an LLM just to figure out [6:49] every deterministic step. At this point, they were close to a year and at 720k. And remember, [6:54] the budget started at 150k from their hypothesis from the pilot. The next step was, "Okay, well, [7:00] we have the human in the loop layer." They needed 10 different UI experiences for different people. [7:06] Maybe there is the frontline worker working through these invoices. Then there's the auditor, [7:10] the manager, the AP clerk, the vendor. And so, they needed to have different visibility [7:14] experiences. Some work in Microsoft Teams, some work within a SaaS tool, some want to work through [7:19] email. How are they making sure that the same use case is meeting all the different human in [7:24] the loop needs? At this point, they were over a year, they were over a million dollars into case, [7:29] and they still are not done getting this where they need. Because then the next step was what [7:33] they thought was the easy part was, "Well, I'm going to build agents now. I have my process." [7:37] But once again, in their pilot, they had one agent that took the whole scope of the use case. [7:43] That works well when you maybe throw a few hundred invoices in a very controlled environment, [7:48] but we were talking over 200,000 a month from all the different parts of the world. [7:52] They needed to have a multi-agent orchestration. So, they needed sub-agents, context agent, [7:57] orchestration agent. They needed to start figuring out what a agent builder looks [8:00] like. What are guardrails, metering, evaluation? How do I interchange? Now, they're looking again [8:04] at open source tools, different tools to start building that. At this point, they're almost 2 [8:08] years in and 1.8 million dollars. And then really to close out what they needed to do, [8:14] they had to write back to systems. At the end of the day, they still have system of records. [8:18] They still need to be able to show the transaction. They need to have survivorship. [8:24] Excuse me. They need to know if the transaction itself is auditable. And so, they had to still [8:29] build all of this out. They had Oracle, Ariba. They had their unstructured systems where they [8:33] keep the contracts. And at this point, they were over 2 million dollars and they were too far ahead [8:38] into this where they can say, "Hey, we want to stop now." They needed a complete production use [8:42] case. And then lastly, they still had to do the governance. And this is the part when we work [8:48] with our clients in which you can have a CISO review that will kill your use case on the spot [8:53] because they needed to look at SOC 2 compliance. What happens if data is deleted? How do we know [8:57] that that agent is running an underlying model that's allowed to be used that region? [9:01] How do we understand there's audit trails, explainable data leaks? And so, for them, [9:05] they had to try to build all of these pieces in production after they left the pilot phase [9:10] because they didn't realize this is what it takes to actually scale an enterprise use case. [9:16] And the biggest kicker for them was that was one of over 100 use cases. And so, the way they had it [9:23] built, going back to that two signals of failure I called, they had a rigid all-in-one build. And so, [9:29] they're going to have to redo all of that again for each use case. They literally had 25 in the [9:33] finance shop alone. So, they had no reusability, no assembly-first capability. [snorts] [9:39] And everything that I just talked through in that moment it or and through those through [9:43] those slides is the 80%. So, if you take that use case they had, the model itself, the LLM, [9:49] yes, it looked good in the pilot. It allows a lot of non-deterministic value that we haven't had [9:54] in a societal sense, but the other 80% is table stakes to your success from the connection of your [10:00] systems, the normalization and ontology or master data management of the systems on the data layer, [10:06] the workflow layer, the human in the loop, the governance. All these things are the [10:10] considerations that every CIO has to think about before they can take that {quote} {unquote} [10:14] lighthouse use case from pilot into production. And what we tell our clients is when you look at [10:20] a Boeing plane that many of us probably were on on our way here. Rolls-Royce, not not the car [10:25] Rolls-Royce, but there's an engine manufacturer called Rolls-Royce and they make the engines for a [10:30] lot of these planes. And I always tell clients at the end of the day the Rolls-Royce that engine of [10:35] the plane is like your LLM, but the Boeing plane around is what you sit, it's what you experience, [10:40] it's how you board, it shows you what part of the of the plane you're in. That's what you actually [10:45] experience. And so, when looking at the LLM, understand it is a great component, but it is only [10:50] 20% of what you need to successfully scale. And so, you saw a moment ago for that client is them [10:57] actually joining the 95% of failures. That's what they did. But to get to that 5% or that that group [11:03] of people that are able to actually scale their pilot use cases in the enterprise successfully, [11:08] there are two main architectural shifts. Number one, we really need to look at those two [11:13] challenges we had seen. We talked about the no single source of truth and then those rigid [11:17] all-in-one builds. Well, number one, you need to decouple this from a horizontal perspective [11:22] by allowing you to connect all those different systems and having governance and actionability [11:27] that sits above it. And then number two, this concept of vertical decoupling by having more of [11:32] assembly-first approach to build so if you build an agent that was looking at invoices for that use [11:37] case, being able to reuse whether it's the assets, the connectors, the contacts for your next agent. [11:43] So following more of an N+1 theory to quickly scale and that's what we allow our clients to do [11:49] is if you built one use case that has everything that you need, how can you quickly scale that [11:53] out to those other use cases? And then have an enterprise context graph that brings all that [11:57] information together that allows you to be able to give the agents a real single source of truth [12:03] to prevent the hallucinations and all those bad experiences we've actually seen in production. [12:08] And when we talk about the the horizontal decoupling, that one version of truth, [12:12] if you take that invoice use case, you maybe have um a CRM that tells what the rep sold [12:18] for that invoice. You maybe have SAP from a bill of material on what was sold to that individual. [12:24] You have the unstructured DocuSign that was done that says, "Hey, we gave them 10% discounting cuz [12:29] they're really good friend of mine." And then you have this conflict of what's the right information [12:33] to feed to the agent and then you may have a duplication problem. What you need to end up [12:38] end up doing is having a enterprise context graph with three layers. Number one, a knowledge graph [12:43] in its own. Being able to take structured data, semantic unstructured data, bring it together, and [12:49] then being able to have a governance layer around it. Understanding who has access to what data, [12:54] if an agent decides to query a request that touches these systems or this data, what type [12:59] of access is provisioned to that agent? And then being able to have that actionability back as [13:03] well. Can we be able to write back? Will the agent be able to retrieve or or put out the information [13:10] and then get that reconciled context end-to-end? And the value of this type of architecture and on [13:16] the next slide is the compounding speed of what you're doing. Once you start having your systems [13:22] being able to create this enterprise context graph, the use case maybe inventory or or invoice [13:28] reconciliation, but maybe you're a manufacturing company or a retail company and you have inventory [13:32] rebalancing as your next item. You've already connected your system, you've already created a [13:36] semantic layer, you already have a context graph. It's very easy now for my use case to be able to [13:41] be built so quickly. And that flows into the next slide where when you look at what gets built, [13:48] move away from that rigid all-in-one and follow more of an assembly-first build where you can [13:53] separate who does what to the swap models. You can move it from fully autonomous back to fully human [13:59] and every bit of what you build is a building block for something else. I would never want [14:04] to see a client where they built a solution and it's all built around just cloud code. [14:08] They're like, "Look at it just knows how to work within how cloud looks at information." [14:12] That's not a scalable type of use case. And this is where really structure matters because [14:17] with the right structure, you can swap your models freely. You can choose atomic engines that give [14:22] you the cheapest model potentially or upgrade to the one that ships better for your use case [14:27] and you don't have to rebuild. Even the human in the loop today or human in the loop tomorrow, [14:31] meaning remove the human totally, not having to re-engineer that if it makes sense. [14:38] And so when you think of what type of architecture do you need to to scale really in an enterprise, [14:44] number one, you need to make sure that your your architecture is agnostic to the model you want to [14:49] use and it needs to be able to deploy anywhere. Some clients need it physically on servers, [14:53] some need a VPC of choice. You may want SaaS manage. And then number two, [14:57] you need to be able to connect all your systems, structured, unstructured, system of activities. [15:02] And then above that, you should need to be able to create that unified data and knowledge layer, [15:06] that context graph, survivorship, ETL processing, being able to write back with reverse ETL, data [15:12] catalog and lineage. And then you need to have the builders. You need to be able to build UI, well, [15:18] workflows. So functions, deterministic steps that you want to give to that agent. You need [15:22] to be able to build that human in loop experience quickly, whether it's embedding a human in loop [15:27] experience in the tool they use today. Maybe they're in Salesforce every day or standalone [15:31] or maybe it's a push mobile notification. And then being able to build single agents, multi agents, [15:36] invoke external third-party agents, expose what you build to external third-party tools, [15:41] be able to invoke through MCP, expose through MCP. Having a full actionability layer, you need to be [15:46] comfortable that whatever architecture, whatever solution you're looking at has not only solved [15:51] me today's problem, but we all know in a few years, let's say a few months at this point, [15:55] this subset of token cost is going to go away. And every our engineer and every CIO is going to [16:00] have to look at what they scaled out and ask themselves, did I architect it in a way that [16:04] I don't depend on that bottom left where those elements live? And then lastly, you need full [16:09] governance from the systems you're connecting to the observability of what the agent is saying to [16:13] your users to the guardrail policies that I I I talked to my banking clients and they'll tell me, [16:18] "Hey Wasim, um there is now a a new AI governance framework and controls for banking institutions. [16:26] I know my systems can go through those controls, my humans can go through those controls, but how [16:30] do my agents go through those same controls and if they don't meet it, I want to rip it out of [16:33] production." That's the level of governance that you need. And what you're seeing on this plat on [16:38] this slide is actually our architecture for our clients that use Unify Apps today. So for our [16:43] clients, they're able to deploy us immediately in wherever they want to get their work done and be [16:47] able to scale these use cases with all of these capabilities out of the box in a no-code manner. [16:53] And so when we look back at that example I had, this is what that client went through when they [16:58] were part of that 95%. They went on their own, they found a good pilot use case. Luckily, [17:03] we came in and they worked with us and this is how we got them to the 5%. It took us 2 months, [17:09] about 143 FDEs and we were able to build this whole thing. We went live, we did over 50,000 [17:16] invoices day one. We took a subset of a variance and went after it. And today they are scaling over [17:21] 20 use cases, multiple multiple use cases with us today. And um part of doing this, looking at time, [17:29] is it's not just the technology itself, but also how you are helping them deploy and scale [17:34] in their production environment. So from our end, we are given dedicated forward deployed engineers. [17:40] We help you set up that COE cuz there's a mistake where many companies they first [17:44] start with the COE and then they get disconnected use cases from other parts of the organization. [17:48] It first starts with finding that right lighthouse use case, find the right ROI hypothesis, [17:53] allowing us to make sure you guys are extremely successful, then build the COE, [17:57] and then you own the flywheel. Meaning, as those use cases come in with the right architecture, [18:01] you are rapidly bringing those into production and having the right process and operational framework [18:06] to make sure that it's defensible when you bring it to your executive board. [18:11] And today we have over 100 customers actually experiencing this type of uh experience [18:16] across all different parts. We have public sector in Dubai, um top financial services here [18:20] in the United States and overseas, um some of the largest health care and also in the public sector. [18:27] And last thing for for anyone that comes to our booth, we have our master agent application [18:32] catalog where we have documented over 125 use cases that are live in clients' environments [18:37] today. And for each of those, what you'll see is we have a process area, what's the live solution, [18:43] what's the ROI, and who's the live customer. We usually share as much as we're allowed with our [18:47] NDAs, but these are not hypothesis or pilots, these are production-grade results. And we're [18:53] happy to share that with anyone that wants to come to the booth. And when it comes to picking a [18:57] use case, I tell our clients it's one of two ways. One, you had seen that we have this master app and [19:03] application catalog. Think of it as a menu if you and I went to like Cheesecake Factory restaurant. [19:08] But then you can just bring us your biggest problem. Because of the way of our our [19:11] architecture and how we how we built, the biggest problems that have the highest ROI are the biggest [19:16] value and components to prove out for your client for you to be able to see what the value is. [19:22] And so with that, I know we're right on time. I appreciate you guys taking the time this morning. [19:27] We are booth 929 and anyone has an AI use case that they like to see the approach, [19:32] please stop on by. I'd be happy to have a one-on-one with you.