Enterprise software must replace fixed graphical interfaces with private ontology layers and distilled micro-models as autonomous digital workers supersede trained human operators.
## Background
Published on YouTube by Ai4 on August 20, 2026, this presentation features Ravi Bulusu, CTO of IFS Loops, explaining why agentic AI marks a foundational transformation for enterprise software rather than just another UI refresh or copilot feature. Drawing on IFS Loops' production deployments in heavy industries, Bulusu details the shift from permanent user interfaces to ephemeral interaction surfaces and autonomous digital workers communicating through APIs and Model Context Protocol (MCP).
## TL;DR
Bulusu argues that enterprise software has reached an inflection point where traditional graphical UIs and manual operator training no longer serve as competitive moats against autonomous digital workers. To support agents advancing from supervised interns to autonomous operators, enterprises must deploy a four-layer stack comprising infrastructure, intelligence, an organizational ontology graph, and execution work harnesses. Companies must protect their core moats—organizational memory and proprietary process intelligence—by utilizing dual-model validation and in-house model distillation rather than leaking operational workflows to public LLMs. Finally, enterprise architectures must prepare for embodied physical execution as intelligence shifts from text-based LLMs to Vision-Language-Action (VLA) robotics.
## Atmosphere & style
The talk delivers an energetic, authoritative, and direct briefing grounded in the hard-edged realities of asset-heavy industrial environments. Bulusu speaks with fast-paced, pragmatic conviction, actively dismantling surface-level AI hype such as chatbot wrappers and viral robotics demos to focus on underlying architectural plumbing, governance, and speed. Watching the session feels like an urgent wake-up call for enterprise architects, balancing technological vision with strict engineering discipline.
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=4s) Enterprise software has reached an inflection point where traditional UI-based competitive moats are broken, as users demand plain-language conversational interactions over forced software training.
- [02:25](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=145s) Applications must now natively support a dual-user base: human workers collaborating in everyday channels and autonomous AI agents communicating via APIs, CLIs, and Model Context Protocol (MCP) servers.
- [02:25](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=145s) Fixed graphical user interfaces are collapsing into ephemeral, intent-driven visual surfaces that materialize inside tools like Slack or Teams to solve a specific task and explain analytical reasoning.
- [04:38](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=278s) Deploying digital workers mirrors onboarding human interns, progressing from SOP-guided supervised execution to autonomous decision-making within enterprise guardrails.
- [04:38](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=278s) The agentic foundation requires a four-layer stack: Commodity Infrastructure, Hybrid Intelligence, an Organizational Ontology connecting disparate systems and RBAC policies, and a real-time Work execution layer.
- [10:08](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=608s) As AI democratizes software development, enterprise competitive advantages shift from raw engineering speed to preserving unwritten Organizational Memory and proprietary Process Intelligence.
- [10:08](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=608s) Enterprises can protect intellectual property from public model providers by using dual-model validation frameworks, local process distillation, and private Mixture of Experts (MoE) architectures.
- [14:37](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=877s) Lightweight local models running on CPUs provide pre-prompt inspection to detect prompt injections, PII, and IP leaks before data crosses enterprise boundaries.
- [14:37](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=877s) Human-in-the-loop oversight serves a dual purpose: safeguarding against edge-case failures and serving as the primary capture mechanism for institutional knowledge into organizational memory.
- [16:53](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=1013s) Enterprise AI is evolving past desktop advisory LLMs into Vision-Language-Action (VLA) models that output physical action tokens to power embodied robotics in operational environments.
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=4s) The iPhone Moment for Enterprise Software
Ravi Bulusu, CTO of IFS Loops, sets the stage by outlining what IFS and its Loops platform do. IFS operates as an industrial AI company serving complex, heavily regulated, and asset-heavy sectors such as aerospace, defense, heavy materials, and manufacturing. Loops is an agentic platform designed to deploy "digital workers" directly into these high-stakes enterprise environments. Having spent over 18 months deploying agentic systems in production, Bulusu explains that the industry has crossed a fundamental inflection point—what he characterizes as the enterprise software market's "iPhone moment" following the rise of ChatGPT.
For decades, enterprise software vendors relied on a standard operating model: build complex software, craft custom user experiences, and force customers to train their employees on specific menus, buttons, and dashboards. Vendors believed that having a superior UX created a competitive moat. Bulusu argues that this dynamic is permanently broken. In modern enterprise environments, nobody wants to be trained on a new UI anymore. If users cannot interact with software naturally by speaking or typing in plain language using their "God-given talent of talking to a system in the language that they really understand," the software simply will not be used. The traditional moat built around user interface design and human muscle memory has evaporated.
[02:25](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=145s) The Non-Human Workforce and the Collapsing Interface
Beyond human interaction, enterprise applications must now cater to a completely new class of user: autonomous AI agents. These digital consumers do not interact with software through graphical interfaces, mouse clicks, or keyboard shortcuts. Instead, they interact via APIs, command-line interfaces (CLIs), and Model Context Protocol (MCP) servers. Whenever modern enterprises evaluate software, the first architectural questions they ask are no longer about screen layouts, but rather whether the software is API-compliant and equipped with an MCP or CLI server. Enterprises cannot afford to delay this transition, as competitors moving at AI speed will rapidly outpace them.
As a result, the conventional software interface has collapsed. Rather than forcing employees to navigate into monolithic enterprise applications, work now comes directly to wherever workers already collaborate—such as Microsoft Teams, Slack, or email. Fixed UIs are being replaced by conversational, dynamic surfaces. When a user expresses intent—for example, asking to see the organization's riskiest purchase orders (POs)—the system immediately generates a contextual visualization tailored strictly to that objective, presenting the answer alongside a transparent explanation of why those specific risks were flagged.
```mermaid
flowchart TD
accTitle: The Shift in Enterprise Interaction
subgraph Users["Dual Classes of Users"]
H["Human Workers<br/>(Collaborating in Slack / Teams / Email)"]
A["Digital Workers / Agents<br/>(Autonomous Non-Human Consumers)"]
end
subgraph Core["Enterprise Business Context"]
APP["Underlying Enterprise Work Layer<br/>(ERP, CRM, HR, Asset Data)"]
end
H --> UI
A --> APIs
UI --> APP
APIs --> APP
```
- **Two user classes:** Applications must now natively support both human conversationalists and machine agents communicating via MCP and APIs.
- **Contextual UI generation:** Interfaces are no longer static screens; they materialize dynamically to answer specific intent and explain analytical reasoning.
[04:38](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=278s) From Interns to Digital Workers: The Four-Layer Agentic Stack
Bulusu compares the deployment of AI agents to hiring human interns. In traditional organizations, an intern begins with onboarding documentation and standard operating procedures (SOPs), requires close supervision and human-in-the-loop training, and gradually evolves into an expert capable of autonomous decision-making. Digital workers follow the exact same progression: they start with guided oversight on incoming purchase orders or equipment alerts, operate in an assisted mode to handle exceptions, and eventually graduate to full autonomy within defined guardrails.
To enable this progression across complex enterprise landscapes, Bulusu presents a four-layer agentic architecture designed to replace traditional SaaS foundations:
```mermaid
flowchart TD
accTitle: The Four-Layer Agentic Stack
subgraph Layer4["Layer 4: Work Layer"]
W["Agent Execution Harnesses<br/>(Autonomous Action, Task Orchestration)"]
end
1. **Infrastructure Layer:** The foundational commodity layer containing compute, storage, and databases. Bulusu stresses that this layer offers zero competitive differentiation: "Nobody is going to give you any brownie points if you just have infrastructure layer."
2. **Intelligence Layer:** Comprises both foundational public Large Language Models (LLMs) and specialized, private enterprise models needed to preserve organizational IP.
3. **Organizational Ontology Layer:** The critical grounding layer that connects disconnected applications (ERP, CRM, HR, and engineering systems). It maps cross-system entities, one-to-many and many-to-many relationships, APIs, business policies, and role-based access control (RBAC). This layer establishes strict operational boundaries, eliminating hallucinations by ensuring agents understand enterprise context.
4. **Work Layer:** The top execution harness where digital workers actively monitor 24/7 event streams, process alerts, and perform real-world operational workflows.
[10:08](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=608s) Defending Your Moat: Organizational Memory and Process Distillation
Reflecting on his background founding five startups, Bulusu explains that agility and speed historically allowed small, 30-person teams to outcompete 1,000-person incumbents. However, generative AI has democratized software development, eliminating the traditional engineering barrier and putting small and large organizations on an even footing. In this landscape, an enterprise's true competitive advantage boils down to two irreplaceable assets: **Organizational Memory** and **Process Intelligence**.
Organizational memory represents the collective, unwritten experience of a workforce—such as knowing the nuances of negotiating with a specialized supplier in Greece versus one in Texas. To preserve this moat, systems must capture these subtle human decisions using vector graphs and knowledge graphs so subsequent agents inherit that institutional wisdom.
Process intelligence represents proprietary workflow execution, such as Coca-Cola's or Pepsi's unique supply chain strategies. Bulusu warns strongly against leaking these proprietary processes and evaluation guardrails to public LLM providers. Instead of exposing trade secrets, IFS Loops employs a dual-LLM framework coupled with continuous model distillation:
- **Dual-Model Validation:** One LLM executes the process while an independent secondary LLM runs evaluation and guardrails.
- **Process Distillation:** Execution data from successful micro-processes is captured locally to fine-tune compact, highly specialized models.
- **Mixture of Experts (MoE):** Individual micro-process models are combined into an in-house Mixture of Experts architecture that remains fully proprietary to the enterprise rather than hosted by third-party model providers.
[14:37](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=877s) Safeguarding Speed: Guardrails, Small LLMs, and Human-in-the-Loop
Citing a favorite maxim from IFS's CEO—"Speed is life"—Bulusu emphasizes that while moving fast is vital to outpace competitors, high velocity inevitably brings "blind corners." Navigating these risks requires robust security and operational safeguards:
- **Pre-Prompt Inspection via Small Local Models:** Before an agent sends prompts outside the enterprise boundary, lightweight models (such as an 8-million-parameter local LLM or NVIDIA Nemotron running on high-end CPUs) inspect outbound traffic in real time. This ensures rapid detection of prompt injections, personally identifiable information (PII), and intellectual property leaks without introducing latency.
- **End-to-End Observability:** Full observability across the entire agent lifecycle is mandatory. It provides essential security audit trails and captures execution telemetry required for continuous model fine-tuning.
- **Human-in-the-Loop Feedback:** Active human supervision serves a dual role: it safeguards against edge-case failures during exception handling and acts as the primary capture mechanism for extracting unwritten expert intuition into the enterprise's permanent organizational memory.
[16:33](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=993s) Organizational Memory, Governance, and the Agentic Architecture
Beyond execution, enterprise agentic systems must institutionalize what they learn by systematically capturing context and storing it within the organizational memory stack. Governance remains paramount throughout this lifecycle, ensuring that autonomous digital workers operate within verified compliance and security guardrails. Pointing attendees to the comprehensive enterprise stack architecture published on `ifs.ai`, Ravi Bulusu stresses that true enterprise readiness requires a unified foundation integrating memory, orchestration, and trust rather than disjointed chatbot wrappers.
```mermaid
flowchart LR
accTitle: Evolution of Enterprise AI Models
accDescription: Flow showing the progression from text-based LLMs to multimodal VLMs and embodied VLA models driving robotics.
subgraph Inputs["Intelligence Evolution"]
LLM["Text LLMs<br/>(Advisory & Text)"]
VLM["Vision Language Models<br/>(Physical Intelligence & Video Signals)"]
VLA["Vision-Language-Action (VLA)<br/>(Action Tokens: Actuation & Movement)"]
end
subgraph Embodiment["Execution Layer"]
Robot["Embodied Robotics<br/>('Robot is the new computer')"]
end
LLM --> VLM
VLM --> VLA
VLA --> Robot
```
---
[16:53](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=1013s) The Physical Frontier: From LLMs to VLMs and Vision-Language-Action (VLA) Robotics
Looking toward what lies ahead, Bulusu cuts through the viral social media novelty of dancing machines to highlight a profound paradigm shift: "Robot is the new computer." Current desktop computers act purely as advisory engines—analyzing telemetry, calculating next steps, and prompting humans on what decisions to make to resolve an issue. In contrast, robots represent embodied computers capable of physically resolving real-world problems autonomously.
This shift reflects the blistering pace of model evolution. Standard Large Language Models (LLMs) are already becoming "a thing of the past." They are rapidly being superseded by Vision Language Models (VLMs) that extract physical intelligence and operational signals from video feeds and physical devices, which are in turn evolving into Vision-Language-Action (VLA) models. Unlike models that output text strings, VLAs output physical actions as discrete tokens, instructing robotic hardware precisely how much to articulate a joint, rotate an arm, or traverse a space. Bulusu concludes by urging enterprise leaders to ensure their technology stack adapts not merely to desktop-bound LLMs, but to a near future where computing is embodied and untethered from the desktop screen.
- **Desktop Computers vs. Robots**: Traditional enterprise software advises human workers on what decisions to execute; robotic systems will directly carry out physical resolutions in the operational environment.
- **Model Progression**:
- **LLMs (Large Language Models)**: Text generation and cognitive reasoning.
- **VLMs (Vision Language Models)**: Multimodal processing of video feeds, sensor arrays, and physical device telemetry.
- **VLAs (Vision-Language-Action Models)**: Next-generation architectures that output action tokens directly controlling robotic physical movement and spatial manipulation.
- **Architectural Imperative**: Enterprise software architectures must be built from the ground up to support embodied digital and physical workers rather than legacy keyboard-and-mouse interfaces.
## Notable quotes
> learn our menus, our dashboards, our keyboard shortcuts, and we'll let you do your job. Agentic AI breaks that bargain. — Ravi Bulusu
> Fixed UI, the permanent interface users had to learn, gives way to ephemeral UI that materializes only for the decision at hand and disappears once the work is done. — Ravi Bulusu
> [00:04](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=4s) digital workers — Ravi Bulusu
> [00:04](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=4s) iPhone moment — Ravi Bulusu
> [00:04](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=4s) God-given talent of talking to a system in the language that they really understand — Ravi Bulusu
> [04:38](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=278s) Nobody is going to give you any brownie points if you just have infrastructure layer. — Ravi Bulusu
> [14:37](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=877s) Speed is life — IFS CEO
> [14:37](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=877s) blind corners — Ravi Bulusu
> [16:53](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=1013s) Robot is the new computer — Ravi Bulusu
> [16:53](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=1013s) a thing of the past. — Ravi Bulusu
## Mentioned
Ravi Bulusu, IFS Loops, IFS, Ai4, ChatGPT, Microsoft Teams, Slack, Model Context Protocol (MCP), Coca-Cola, Pepsi, NVIDIA Nemotron, ifs.ai
## Video description
Ravi Bulusu - CTO, IFS Loops
For 25 years, enterprise software ran on a simple bargain: learn our menus, our dashboards, our keyboard shortcuts, and we'll let you do your job. Agentic AI breaks that bargain. Ravi Bulusu, CTO of IFS Loops, argues this isn't a UI refresh or a copilot bolted onto old screens, it's a foundational shift in what enterprise software is. Fixed UI, the permanent interface users had to learn, gives way to ephemeral UI that materializes only for the decision at hand and disappears once the work is done. That shift demands a new stack, because applications now have a second class of user: AI agents that speak API, MCP, and A2A instead of mouse and keyboard, and that need reasoning, orchestration, memory, and trust the old architecture was never built for. Drawing on IFS Loops' work building digital workers for industrial enterprises, Ravi shows how to tell real agentic infrastructure from a chatbot wrapper.
Ravi Bulusu, CTO of IFS Loops, argues that enterprise software has reached an inflection point where conventional user interfaces and static workflows must be replaced by a four-layer agentic stack serving both human conversationalists and autonomous digital workers.
The Collapse of Traditional Software Interfaces (2:25)
For decades, enterprise vendors treated complex user interfaces and specialized employee training as competitive moats. Bulusu argues this dynamic has evaporated because modern workforces expect to interact through conversational plain language embedded in existing collaboration tools like Slack, Microsoft Teams, or email. Instead of static navigation screens, software must dynamically generate intent-driven interfaces that visualize answers and articulate analytical reasoning on demand.
Simultaneously, enterprise software must cater to non-human autonomous agents that do not use graphical interfaces. Bulusu observes that machine workers interact via APIs, command-line interfaces, and Model Context Protocol (MCP) servers. He asserts that enterprise architectural evaluations now prioritize whether platforms support machine-readable protocols over visual design, warning that organizations adhering to human-only UI paradigms risk being outpaced.
The Four-Layer Stack for Digital Workers (4:38)
Bulusu likens deploying AI agents to onboarding human interns, who advance from structured standard operating procedures and supervision to assisted task execution and eventual autonomy. Supporting this operational progression across complex enterprise environments requires abandoning monolithic architectures in favor of a specialized four-layer agentic stack.
The base infrastructure layer of compute, storage, and databases offers zero competitive differentiation, according to Bulusu. Above it sit an intelligence layer of hybrid public and private language models and an organizational ontology layer. Bulusu highlights the ontology layer as critical for eliminating hallucinations by mapping cross-system entities, relations, business rules, and access controls across disparate systems like ERP, CRM, and HR. The top layer provides the execution harness where digital workers actively monitor real-time event streams and complete tasks.
Preserving Moats via Memory and Process Distillation (10:08)
Because generative AI has lowered traditional software development barriers, Bulusu argues that an enterprise's remaining defensive moats consist of organizational memory and process intelligence. Organizational memory encompasses the unwritten institutional experience of employees, which platforms must index within vector and knowledge graphs so autonomous agents can inherit workforce expertise.
Process intelligence represents proprietary workflow execution, such as custom supply chain operations. Bulusu cautions against leaking these operational trade secrets to external model providers. To safeguard intellectual property, IFS Loops implements a dual-model framework where one model executes a task while another validates guardrails. Execution data from successful micro-processes is then distilled locally into compact, fine-tuned models and assembled into an internal Mixture of Experts architecture.
Real-Time Guardrails and Human Oversight (14:37)
Rapid agentic execution introduces security vulnerabilities that require local, low-latency intervention. Bulusu details how lightweight models, such as an 8-million-parameter local model or NVIDIA Nemotron running on CPUs, can inspect outbound prompts prior to leaving enterprise boundaries. This pre-prompt inspection detects prompt injections, personally identifiable information, and intellectual property leaks without adding latency.
Continuous human-in-the-loop oversight remains an operational prerequisite. Beyond serving as a backstop for edge-case errors, human intervention captures expert problem-solving during exception handling, directly converting tacit human intuition into permanent organizational memory.
The Evolution Toward Embodied Robotics (16:53)
Looking beyond screen-based intelligence, Bulusu forecasts that the "robot is the new computer." He distinguishes traditional computers, which function purely as advisory engines that prompt humans on how to solve problems, from embodied robotic systems capable of autonomously executing physical actions in operational environments.
This shift tracks an underlying progression in machine learning architectures. Bulusu claims text-only language models are already being superseded by Vision Language Models that process visual feeds and sensor telemetry. These are further evolving into Vision-Language-Action models that output physical action tokens to actuate robotic joints and manipulate physical spaces, requiring enterprise software architectures to support embodied physical agents alongside digital software workers.
Bulusu concludes that genuine enterprise AI adoption requires foundational architectures integrating memory, cross-system ontologies, and local governance rather than superficial chatbot wrappers. However, real-world deployment hinges on maintaining strict data boundaries and operational guardrails as autonomous systems scale from digital workflows into physical robotics.
精炼阅读摘要
IFS Loops 首席技术官 Ravi Bulusu 认为，企业软件已迎来类似 iPhone 的底层重构拐点，传统基于图形界面与操作培训的护城河已彻底瓦解，企业必须建立融合组织本体、流程蒸馏与安全防护的四层智能体技术栈，以支撑自主数字员工并最终演进至具身实体操作。
传统交互界面瓦解与双重用户群体 (0:04)
Bulusu 指出，ChatGPT 问世后企业软件迎来了结构性拐点，过去数十年软件厂商依赖复杂功能排布、定制界面与员工操作培训建立的竞争壁垒已彻底失效。在现代企业中，人类员工不再愿意接受繁琐的系统培训，而是倾向于直接使用自然语言与系统对话；无法支持日常语言自然交互的软件将面临被淘汰的风险。更关键的转变在于，企业软件必须同时服务第二类全新用户——自主 AI 智能体。这类非人类使用者完全不依赖图形界面、鼠标点击或快捷键，而是通过 API、命令行界面（CLI）以及模型上下文协议（MCP）服务器直接与系统通信，使 MCP 与 API 的支持能力成为现代企业技术选型的首要标准。
这一变革促使传统的单体软件界面发生解构。业务处理不再需要员工主动登录大型独立系统，而是直接融入 Slack、Microsoft Teams 或电子邮件等既有协作平台中。当使用者表达业务意图（例如要求调出组织内风险最高的采购订单）时，系统会即时动态生成针对该目标的上下文可视化界面，并在展示结果的同时直接呈现具体的风险分析理由，使界面从固定死板的功能菜单转变为按需生成、具备可解释性的交互载体。
四层智能体技术栈与数字员工演进 (4:38)
Bulusu 将 AI 智能体在企业中的部署周期类比为人类实习生的成长路径：从最初依赖标准作业程序（SOP）和人工紧密监督，逐步过渡到辅助模式下处理异常，最终在既定安全边界内实现自主决策。为了在航空航天、国防制造等资产密集与强监管领域支撑这一演进，IFS Loops 提出了替代传统 SaaS 架构的四层智能体技术栈。
该技术栈底层为基础设施层，包含计算、存储和数据库，Bulusu 强调此层属于通用商品，无法为企业提供差异化优势；第二层为智能层，整合了公共基础大语言模型与保护专有 IP 的私有微调模型；第三层为核心的“组织本体层”（Organizational Ontology Layer），其作用在于连通 ERP、CRM、HR 及工程系统等数据孤岛，精确映射跨系统业务实体、关联规则、API 接口和基于角色的访问控制（RBAC），为智能体提供明确的业务边界并消除模型幻觉；最顶层则是工作执行层，由数字化工作者执行 7×24 小时的事件流监控、预警响应与真实业务流程调度。
组织记忆沉淀与微流程模型蒸馏 (10:08)
生成式 AI 的普及消除了传统软件工程的开发壁垒，使得小团队与行业巨头在编码效率上站在了同一起跑线。Bulusu 强调，在技术门槛拉平后，企业真正的竞争护城河收缩为两项专属资产：组织记忆（Organizational Memory）与流程智能（Process Intelligence）。组织记忆代表员工未写成文档的隐性实践经验（例如针对特定区域供应商的微妙谈判策略），企业必须借助向量图和知识图谱将这些人类决策沉淀为可被智能体继承的机构知识体系。
流程智能则指代企业独有的端到端业务执行逻辑。针对专有流程的安全顾虑，Bulusu 明确警告不得将企业核心流程与评估标准泄露给第三方公共大模型厂商。IFS Loops 对此采取双模型验证与流程蒸馏策略：由一个模型执行具体微流程，另一独立模型负责评估与安全拦截；同时在本地环境捕获成功执行的遥测数据，将其蒸馏微调为高度专业化的轻量级小模型，并在企业内部组合成私有的混合专家架构（MoE），确保核心商业机密留在防火墙内。
速度与合规平衡：前置轻量防护与人机协作 (14:37)
针对企业在高速智能化推进中可能面临的合规与安全盲区，Bulusu 介绍了多层防御机制。首先是在提示词跨越企业边界前部署实时前置审查，利用运行在高规格 CPU 上的轻量级本地模型（如 800 万参数模型或 NVIDIA Nemotron）拦截提示词注入、敏感个人身份信息（PII）以及知识产权外泄，在不引入显著网络延迟的前提下保障安全。
其次，系统实施全生命周期的端到端可观测性监控，不仅建立不可篡改的安全审计跟踪，还负责持续采集驱动内部模型优化所需的执行遥测数据。此外，“人在回路”（Human-in-the-Loop）机制兼具双重使命：一方面在异常处理与极端边界场景中充当最终安全托底，另一方面作为关键的数据捕获管道，负责将资深专家在处理复杂特例时的直觉判断逆向提取并固化为企业的长期资产。
从文本推理迈向具身物理执行 (16:53)
在探讨计算架构演进时，Bulusu 提出“机器人即新型计算机”的判断。他分析指出，传统的桌面端企业软件在本质上仅属于顾问型引擎，其作用局限于分析数据并向人类提示决策建议；而具备实体形态的机器人则是能够直接在物理世界中自主消除故障与执行作业的计算载体。
这一转变伴随着底层基础模型的能力跨越。纯文本大语言模型正逐步演进为能够解析视频流和设备遥测信号的视觉语言模型（VLM），并进一步跃升为视觉-语言-动作（VLA）模型。与输出文本标记的传统模型不同，VLA 模型能够直接输出用于驱动机械硬件的离散“动作代币”（Action Tokens），精确控制机器人关节旋转、机械臂伸展及空间位移。Bulusu 总结指出，企业软件技术栈的设计不能仅停留在适配桌面屏幕的阶段，而必须提前为数字员工与实体机器人的协同作业打好底层框架。
Bulusu 认为，企业软件正在经历从被动界面向自主智能体与具身物理执行的范式跃迁，软件架构必须以组织上下文、私有流程蒸馏与严格安全护栏为核心基础。然而，随着技术栈从纯数字领域的文本推理拓展至驱动硬件操作的 VLA 模型，企业如何在充满不确定性的物理工业场景中持续维持高可靠性与严格安全边界，仍是该体系规模化落地时面临的长期考验。
Detailed notes — zh
## Background
该视频由频道 Ai4 于 YouTube 平台发布，主讲人为工业 AI 企业 IFS Loops 的首席技术官（CTO）Ravi Bulusu。视频简介指出，企业软件历时 25 年的固定界面交互契约已被智能体 AI 打破，传统界面正让位于随需生成的即时 UI（Ephemeral UI），企业亟需构建全新的四层 Agentic 技术栈以支持非人类智能体用户，并从架构层面区分真正的智能体基础设施与简单的聊天机器人包装。
## TL;DR
Ravi Bulusu 指出企业软件正迎来“iPhone 时刻”，传统依赖固定界面和用户肌肉记忆的护城河已经失效，软件正演变为以 API、MCP 协议为主、界面即时生成的“工作找人”范式。针对强监管工业场景下的数字员工落地，他提出了包含基础设施、智能、组织本体与上下文、工作层的四层 Agentic 技术栈，强调本体层是约束智能体边界与遏制幻觉的关键。同时，企业应将组织记忆与专有业务流程持续蒸馏为自主可控的私有 MoE 模型，而非将机密外泄给公共大模型；在构建本地小模型护栏、端到端可观测性与人类在环安全体系的同时，为迈向动作即 Token 的具身智能（VLA）做好前瞻准备。
## Atmosphere & style
整体氛围极具工业技术极客底色与前瞻战略视野，节奏紧凑、信息密度极高。讲者 Ravi Bulusu 语言精练笃定、直切痛点，既展现出 5 次创业者敏锐的商业嗅觉，又透露出深耕航空航天与重工业等高监管严苛场景的务实工程经验。整场演讲不仅打破了企业对传统 SaaS 界面的固有认知，更通过对技术栈层层递进的架构解剖与对具身智能演进的推演，为观众带来一种见证底层软件范式革命爆发的紧迫感与纵深感。
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=4s) 企业软件迎来“iPhone 时刻”，过去 25 年依赖固定菜单培训与用户肌肉记忆的传统契约失效，自然语言交互成为全新基准。
- [01:46](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=106s) AI 智能体成为企业应用的第一类非人类“一等公民”，交互重点从图形界面彻底转向 API、CLI 和 MCP（模型上下文协议）等机器对机器接口。
- [01:46](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=106s) 交互范式从“人找工作”转变为“工作找人”，固定的 ERP/CRM 界面被按需动态生成、任务完成后即隐退的即时 UI（Ephemeral UI）取代。
- [04:38](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=278s) 数字员工的落地遵循“实习生到业务专家”的进化路线，经历由“人类在环（HITL）”辅助监督到完全自主决策闭环执行的成熟过程。
- [06:30](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=390s) IFS Loops 提出了企业级 Agentic 技术栈的四层架构：基础设施层、智能层、本体与上下文层，以及基于智能体 Harness 的工作层。
- [06:30](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=390s) 组织本体与上下文层（Ontology Layer）是智能体技术栈的核心支柱，通过沉淀跨异构系统的实体、关联图谱与权限策略，为智能体划定精准的业务作业边界并遏制幻觉。
- [10:08](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=608s) 随着 AI 开发门槛被抹平，企业独有的竞争壁垒不再是代码实现，而是长期积累的“组织记忆”与“专有业务流程智能”。
- [10:08](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=608s) 为防止核心商业机密外泄给公共大模型，企业应采用双模型协同与微流程知识蒸馏方案，持续沉淀自主可控的专有混合专家模型（MoE）。
- [14:37](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=877s) 在“速度即生命”的高速演进下，企业需构建四道安全防线：本地轻量模型毫秒级安全拦截、端到端可观测性、人类在环校验与策略驱动边界约束。
- [16:33](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=993s) 企业级智能体架构的核心在于将即时执行中的经验与决策数据沉淀至组织记忆栈中，并依托严格治理保障运转合规。
- [16:53](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=1013s) 计算范式正迈向具身智能（“机器人即新计算机”），模型演进路径从纯文本推理的 LLM、提取物理感知的 VLM，加速跃迁至直接将物理动作作为 Token 输出的 VLA 模型。
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=4s) 工业 AI 背景与企业软件的“iPhone 时刻”
Ravi Bulusu 是 IFS Loops 的首席技术官（CTO）。IFS 专注于工业 AI 领域，业务覆盖航空航天、国防、重工业原材料以及高端制造等高度受监管的严苛行业。IFS Loops 本质上是一个智能体平台架构（Agentic Stack），旨在向这些复杂的监管场景部署所谓的“数字员工（Digital Workers）”。在过去 18 个月深入一线的落地实践中，团队不仅积累了大量智能体部署的实战教训，更洞察到了企业软件底层架构正在经历的代际跃迁。
从宏观视角来看，自 ChatGPT 问世以来，整个软件交互逻辑与企业运转方式被彻底重塑，企业软件迎来了属于自己的“iPhone 时刻”。过去 25 年间，企业级软件始终建立在一套既定契约之上：厂商提供复杂的菜单、仪表盘与交互界面，企业花时间去培训员工适应系统。但在当今时代，“教用户去学习新 UI”已经成为过去式。如果一款软件无法支持用户直接以自然语言对话交互，它就会被市场抛弃。以往企业软件试图通过打造独特 UX、培养用户“肌肉记忆（Muscle Memory）”来构建护城河，这种模式已经失效，因为用户更倾向于使用最自然的母语直接与系统沟通。
- **核心行业覆盖**：航空航天（Aerospace）、国防（Defense）、重型原材料工业（Heavy Materials）及离散/流程制造业等强监管领域。
- **实践周期**：IFS Loops 已经在高监管工业环境中持续部署与迭代数字员工达 18 个月。
- **UI 模式转变**：固定菜单与复杂界面的培训机制终结，基于自然语言的即时交互成为 2026 年以来的全新行业基准。
---
### [01:46](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=106s) 非人类用户崛起与接口协议的彻底重构
企业应用正在迎来一类全新的“一等公民”用户——它们不再是人类，而是协同作业的 AI 智能体（Agents）。这类非人类用户根本不需要图形用户界面（UX），它们直接通过 API、命令行界面（CLI）以及新兴的模型上下文协议（MCP, Model Context Protocol）服务器进行机器对机器的通信。如今在企业内部部署软件时，客户首先拷问的指标不再是界面多美观，而是“系统是否完全 API 化？是否具备 MCP 服务器？是否提供标准 CLI 接口？”这种技术转向在接下来的发展中将变得愈发严苛。
在这场浪潮中，企业没有退路，也不可能按下暂停键，因为竞争对手正借助 AI 以前所未有的速度拉开差距。伴随界面的坍塌，一种“工作主动找人（Work comes to you）”的新工作范式正式成型。员工无需主动登录 ERP 或各种后台系统翻找数据，而是停留在 Microsoft Teams、Slack 或电子邮件等日常协作中枢内，由对话式界面按需提供服务。界面的形态从“永久固定”变成了“即时生成（Ephemeral UI）”：当用户表达一个意图（例如“帮我找出当前风险最高的一批采购订单 PO”）时，系统不仅给出结论，还会动态生成契合当前上下文的临时可视化界面，解释决策背后的因果逻辑，并在任务完成后隐退。
```mermaid
flowchart LR
accTitle: Fixed UI vs Ephemeral Agentic Flow
subgraph Traditional["传统模式: 人找工作 (Fixed UI)"]
direction TB
U1["人类用户"] -->|"学习与肌肉记忆"| GUI["固定 ERP / CRM 界面"]
GUI -->|"手动填表 / 巡检"| DB1[("企业数据库")]
end
subgraph Agentic["全新模式: 工作找人 (Ephemeral UI)"]
direction TB
A1["智能体 / 数字员工"] -->|"API / CLI / MCP"| Core["企业核心数据与业务逻辑"]
A2["人类用户 (Slack / Teams / 邮件)"] <-->|"自然语言 / 动态生成的即时 UI"| A1
end
```
---
### [04:38](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=278s) 从实习生到专家：数字员工的养成路径
在传统企业内部，新员工通常经历从“实习生”到“业务专家”的漫长成长轨迹：阅读流程文档、参与岗前培训、在导师指导下逐步上手，最终独立处理复杂业务。IFS Loops 构建的数字员工也遵循着完全相同的进化路径。这些数字员工拥有 24/7 全天候待命、永不疲倦的特性，能够实时监听企业内发生的各种事件——无论是邮箱里刚收到的一份采购订单（PO），还是某个重型工业资产设备触发的异常报警，都会瞬间唤醒数字员工去执行既定作业。
智能体的落地绝非一蹴而就的“全自动驾驶”，而是分为明确的成长阶段：
- **辅助阶段（Assisted Workmanship）**：在初期，面对高频出现的设备异常报警或边缘场景，必须引入“人类在环（Human-in-the-Loop, HITL）”机制进行监督指导，就像老员工带实习生一样，手把手教会智能体在特定异常发生时的应对策略。
- **自主阶段（Autonomous Execution）**：伴随流程理解的加深与规则的固化，智能体逐步具备独立决策与闭环执行的能力，正式晋升为可信赖的企业数字专家。
---
### [06:30](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=390s) Agentic 技术栈的四层架构剖析
为了支撑数字员工在工业与受监管环境下的可靠运转，企业软件的底层基础必须重构。IFS Loops 提出了全新的四层智能体技术栈（The Agentic Stack）：
```mermaid
flowchart TD
accTitle: The Four-Layer Agentic Stack Architecture
subgraph WorkLayer["4. 工作层 (Work Layer)"]
W["智能体执行框架 / Harness (如 OpenAI, Claude, 开源 Harness)"]
end
subgraph OntologyLayer["3. 本体与上下文层 (Ontology & Context Layer)"]
O1["组织级本体模型 (跨 ERP / CRM / HR / 工单系统)"]
O2["实体、API 与关联图谱 (Entities & 1:N / M:N Relations)"]
O3["业务策略与基于角色的访问控制 (Business & RBAC Policies)"]
O1 --- O2
O2 --- O3
end
subgraph IntelLayer["2. 智能层 (Intelligence Layer)"]
I1["通用公共大模型 (Public LLMs)"]
I2["企业专有/私有模型 (Private Fine-tuned LLMs / MoE)"]
end
subgraph InfraLayer["1. 基础设施层 (Infrastructure Layer)"]
INF["IaaS / 计算资源 / 关系型数据库 / 向量图谱 (Vector Graphs)"]
end
WorkLayer --> OntologyLayer
OntologyLayer --> IntelLayer
IntelLayer --> InfraLayer
```
- **第一层：基础设施层（Infrastructure）**
由传统 SaaS 时代的 IaaS、计算节点、数据库与存储设施演进整合而成。这是所有软件运作的基础门槛，具备该层并不会为企业带来额外的差异化竞争优势。
- **第二层：智能层（Intelligence）**
包含通用公共 LLM 与企业私有大模型。公共模型是通用能力的底座，但无法成为企业独有的护城河；唯有通过私有模型与针对性微调，企业才能筑牢自身的核心壁垒。
- **第三层：本体与上下文层（Ontology & Context）**
这是整个智能体架构最关键的支柱。企业并非由单一软件构成，而是林立着 ERP、CRM、HR、工程工单等各类异构系统。所谓“组织本体（Organizational Ontology）”，就是将跨系统的实体对象（Entities）、API 接口定义、一对多/多对多的数据拓扑关联，以及过去硬编码在前端页面中的业务规则与基于角色的访问权限（RBAC Policies）进行统一沉淀。本体层为智能体划定了严格的作业边界，是遏制模型幻觉、保障业务决策合理性的根本锚点。
- **第四层：工作层（Work Layer）**
过去由人工在 ERP 界面填表、核对报警所完成的业务操作，全面迁移至由开发者选择的智能体运行框架（Harness）中。得益于本体层对业务逻辑与领域知识的精确约束，无论上层选用 OpenAI、Anthropic Claude 还是开源 Harness，智能体都能表现出稳定可靠的行为。
---
### [10:08](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=608s) 企业新护城河：组织记忆与业务流程蒸馏
生成式 AI 与智能体工具抹平了巨头与初创企业之间的开发门槛。Ravi Bulusu 结合自身创办 5 家初创公司的经历指出，过去 30 人的小团队需要凭借极致的迭代速度与专注度去对抗千人大企业；而现在，大模型工具使 30 人的团队在研发效率上完全能够比肩千人团队。当代码开发门槛被打破后，传统企业历经数十年沉淀的护城河必须重新定义，其核心就在于两点：**组织记忆**与**流程智能**。
| 核心维度 | 传统认知 / 潜在误区 | 智能体时代的真正护城河方案 |
|:--- |:--- |:--- |
| **组织记忆 (Organizational Memory)** | 依赖老员工个人经验，分散于员工大脑中；人员流动即流失。 | 通过向量图谱（Vector Graphs）等结构全面捕获员工历史决策与隐性知识（如跨国供应链沟通习惯），供新派生的数字员工全量复用。 |
| **流程智能 (Process Intelligence)** | 将核心流程文档与业务规则全盘输入给公共 LLM 充当 Prompt。 | 严禁外泄专有流程。采用**持续知识蒸馏（Distillation）**路线：以微流程数据微调私有小模型，组装成专有混合专家模型（MoE）。 |
许多企业（例如百事或可口可乐）之所以立足，正是凭借其高度机密的供应链调度与独特的业务流程。如果企业草率地将专有流程文档与校验护栏（Guardrails）全盘提交给公共大模型，无异于将企业最宝贵的核心机密拱手让人。
为了彻底解决这一安全与主权隐患，IFS Loops 采用了一种双模型协同与持续蒸馏架构：一方面使用独立模型分别负责执行流程与校验评估；另一方面在微流程成功运转时捕获高价值数据，持续微调针对该特定微任务的专用小模型。长此以往，通过将大量精通微流程的微调小模型聚合为专有的混合专家模型（Mixture of Experts, MoE），企业便能拥有完全自主可控、可任意复制且持续进化的专有模型底座。这项资产独属于企业自身，而非 Anthropic 或 OpenAI。
---
### [14:37](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=877s) “速度即生命”下的安全防护四大基石
Ravi Bulusu 引用了 IFS 首席执行官的一句座右铭："Speed is life."（速度即生命）。在智能体时代，反应迟缓的企业必将被对手碾压出局。然而，高速行驶必然会遭遇“盲区（Blind corners）”，高速过弯如果缺乏防护极易导致事故。针对 CIO 与 CISO 最为关切的智能体安全与合规挑战，IFS Loops 总结出了企业必须构筑的四道安全防线：
1. **本地小模型前置拦截（Local Guardrails）**：
在 Prompt 发送出企业内网之前，必须建立前置过滤机制，严防 Prompt 注入攻击（Prompt Injection）、个人身份信息（PII）泄露或商业机密外溢。为避免复杂的安全检查拖慢整体响应，推荐在本地高性能 CPU 上部署约 80 亿参数（8B）的轻量级本地模型（如英伟达的 NeMo Guardrails / Nemotron 系列）实现纳秒级的毫秒安全扫描。
2. **端到端可观测性（Observability）**：
缺乏可观测性的平台绝对不可采用。可观测性不仅关乎系统安全审计与链路追踪，更是持续采集真实交互数据以供后续模型微调与蒸馏的必要前提。
3. **人类在环（Human-in-the-Loop, HITL）**：
人类干预不仅是兜底异常流程的防线，更是将员工大脑中的“隐性决策记忆”提取并转化为企业数字资产的核心通道。
4. **策略驱动的边界约束（Policy-driven Boundaries）**：
依托本体层中预设的业务与权限策略，对智能体的每一次工具调用与写操作实施严密授权与边界校验。
### [16:33](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=993s) 组织记忆沉淀与架构治理基座
在构建企业级 Agent 架构时，核心不仅在于任务的即时执行，更在于对执行过程中产生的数据与经验进行捕获，并将其沉淀到“组织记忆栈”（Organizational Memory Stack）中。与此同时，治理（Governance）是整个体系不可或缺的关键环节。由于演讲时间有限，Ravi 指出观众可以直接访问 ifs.ai 网站，查阅完整发布的企业级 Agent 技术架构图解与详细规范。
```mermaid
flowchart LR
accTitle: 模型演进与物理智能执行路径
subgraph S1["认知与多模态演进"]
A["LLM<br/>语言理解与推理"] --> B["VLM<br/>视觉与物理信号提取"]
B --> C["VLA<br/>将动作作为 Token 输出"]
end
subgraph S2["执行终端"]
C --> D["机器人 / 具身实体<br/>物理世界自主执行"]
end
```
### [16:53](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=1013s) 走向具身智能：从 LLM、VLM 到 VLA 的技术跃迁
展望未来技术演进，Ravi 强调“机器人就是新的计算机”（"Robot is the new computer"）。互联网上充斥着机器人跳舞等娱乐视频，但回到严肃的企业工业现实中，传统计算机与机器人的核心区别在于：当前的计算机系统只能给出决策建议，告知用户“采取某种操作来解决问题”；而机器人则会亲自在物理世界中执行操作并彻底解决问题。
人工智能模型架构的迭代速度极其迅猛，演进脉络清晰可见：
- **LLM（大语言模型）**：单纯处理文本与逻辑推理，在技术前沿视角下已成为阶段性的过去式。
- **VLM（视觉语言模型）**：面向视觉、视频流分析，从物理设备与物理现实中提取感知信号与物理智能（Physical Intelligence）。
- **VLA（视觉-语言-动作模型）**：新一代的核心突破，直接将物理世界的“动作（Actions）作为 Token 进行输出”。模型可以直接控制机器人本体的具体动作，精准下达机械臂旋转多少角度、机身向何处移动等底层控制指令。
Ravi 在结尾总结道，企业所构建的软件技术栈必须具备前瞻适应力，不仅要对接现有的 LLM 技术，更要面向未来做好准备——因为未来的计算机将不再只是静置于桌面上的显示屏与主机，而是具备行动能力的物理实体。
## Notable quotes
> [00:04](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=4s) 教用户去学习新 UI 已经成为过去式。如果一款软件无法支持用户直接以自然语言对话交互，它就会被市场抛弃。 — Ravi Bulusu
> [01:46](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=106s) 工作主动找人（Work comes to you） — Ravi Bulusu
> [01:46](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=106s) 系统是否完全 API 化？是否具备 MCP 服务器？是否提供标准 CLI 接口？ — Ravi Bulusu
> [04:38](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=278s) 数字员工拥有 24/7 全天候待命、永不疲倦的特性，能够实时监听企业内发生的各种事件。 — Ravi Bulusu
> [06:30](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=390s) 本体层为智能体划定了严格的作业边界，是遏制模型幻觉、保障业务决策合理性的根本锚点。 — Ravi Bulusu
> [10:08](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=608s) 如果企业草率地将专有流程文档与校验护栏全盘提交给公共大模型，无异于将企业最宝贵的核心机密拱手让人。 — Ravi Bulusu
> [14:37](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=877s) Speed is life. — Ravi Bulusu
> [14:37](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=877s) 缺乏可观测性的平台绝对不可采用。 — Ravi Bulusu
> [16:53](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=1013s) Robot is the new computer — Ravi Bulusu
> [16:53](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=1013s) 当前的计算机系统只能给出决策建议，告知用户‘采取某种操作来解决问题’；而机器人则会亲自在物理世界中执行操作并彻底解决问题。 — Ravi Bulusu
> [16:53](https://www.youtube.com/watch?v=sGtlR5UGqzA&t=1013s) 将动作（Actions）作为 Token 进行输出。 — Ravi Bulusu
## Mentioned
Ravi Bulusu, IFS Loops, IFS, ChatGPT, MCP (Model Context Protocol), Microsoft Teams, Slack, OpenAI, Anthropic Claude, NVIDIA NeMo Guardrails, Nemotron, 百事 (Pepsi), 可口可乐 (Coca-Cola)
## Video description
Ravi Bulusu - CTO, IFS Loops
For 25 years, enterprise software ran on a simple bargain: learn our menus, our dashboards, our keyboard shortcuts, and we'll let you do your job. Agentic AI breaks that bargain. Ravi Bulusu, CTO of IFS Loops, argues this isn't a UI refresh or a copilot bolted onto old screens, it's a foundational shift in what enterprise software is. Fixed UI, the permanent interface users had to learn, gives way to ephemeral UI that materializes only for the decision at hand and disappears once the work is done. That shift demands a new stack, because applications now have a second class of user: AI agents that speak API, MCP, and A2A instead of mouse and keyboard, and that need reasoning, orchestration, memory, and trust the old architecture was never built for. Drawing on IFS Loops' work building digital workers for industrial enterprises, Ravi shows how to tell real agentic infrastructure from a chatbot wrapper.
[Source](https://www.youtube.com/watch?v=sGtlR5UGqzA)
Source quotes
[0:04] Ravi Bulusu: 教用户去学习新 UI 已经成为过去式。如果一款软件无法支持用户直接以自然语言对话交互，它就会被市场抛弃。
[1:46] Ravi Bulusu: 工作主动找人（Work comes to you）
[1:46] Ravi Bulusu: 系统是否完全 API 化？是否具备 MCP 服务器？是否提供标准 CLI 接口？
[4:38] Ravi Bulusu: 数字员工拥有 24/7 全天候待命、永不疲倦的特性，能够实时监听企业内发生的各种事件。
[6:30] Ravi Bulusu: 本体层为智能体划定了严格的作业边界，是遏制模型幻觉、保障业务决策合理性的根本锚点。
[10:08] Ravi Bulusu: 如果企业草率地将专有流程文档与校验护栏全盘提交给公共大模型，无异于将企业最宝贵的核心机密拱手让人。
[14:37] Ravi Bulusu: Speed is life.
[14:37] Ravi Bulusu: 缺乏可观测性的平台绝对不可采用。
[16:53] Ravi Bulusu: Robot is the new computer
[16:53] Ravi Bulusu: 当前的计算机系统只能给出决策建议，告知用户‘采取某种操作来解决问题’；而机器人则会亲自在物理世界中执行操作并彻底解决问题。
[16:53] Ravi Bulusu: 将动作（Actions）作为 Token 进行输出。
Source quotes
Ravi Bulusu: learn our menus, our dashboards, our keyboard shortcuts, and we'll let you do your job. Agentic AI breaks that bargain.
Ravi Bulusu: Fixed UI, the permanent interface users had to learn, gives way to ephemeral UI that materializes only for the decision at hand and disappears once the work is done.
[0:04] Ravi Bulusu: digital workers
[0:04] Ravi Bulusu: iPhone moment
[0:04] Ravi Bulusu: God-given talent of talking to a system in the language that they really understand
[4:38] Ravi Bulusu: Nobody is going to give you any brownie points if you just have infrastructure layer.
[14:37] IFS CEO: Speed is life
[14:37] Ravi Bulusu: blind corners
[16:53] Ravi Bulusu: Robot is the new computer
[16:53] Ravi Bulusu: a thing of the past.
Original transcript
[0:04] My name is Ravi Belusu. I am the CTO of IFS Loops.
Um, what does IFS do? For people don't know,
[0:10] IFS is an industrial AI company. Um, we
operate in many different segments. Uh,
[0:15] uh, things like aerospace, defense, heavy material
industries, manufacturing, right? So, we are in
[0:22] most of the heavily regulated industries, right?
Um, and um, what do we do? What does uh, Loops do?
[0:28] Loops is an agentic stack agentic platform that
deploys what we call as digital workers, right?
[0:34] Um, and we deploy these digital workers in
these highly regulated industries. We've been
[0:38] doing this for about 18 months now. Um, and as
long I mean, there's a lot of lessons learned,
[0:44] right? Like yesterday we did a session on
uh, the lessons learned when we deploy these
[0:48] these agents, but also there's a there's a
higher lessons that has been learned, like
[0:52] what does the next software stack look
like, right? What what does um, you know,
[0:56] the future of any enterprise stack uh, stack looks
like, right? Like for example, what is changing,
[1:02] right? Like if you look at at a very high
level, you know, things have changed a lot um,
[1:07] ever since ChatGPT came in, um, not just from how
we use software, but also uh, enterprises have
[1:14] been changing as well. So, what we also call this
as an iPhone moment, right? Within the enterprise
[1:18] software itself, right? Um, now fundamentally
if you look at exactly what changed. One,
[1:25] in in this age, if you ask somebody to learn
a UI or if you ask somebody to build to say,
[1:30] okay, here's a UI, let me train you on this UI.
That's a no-no, right? Nobody is going to now
[1:35] uh, start learning new UIs anymore because
fundamentally you you if you if you can't
[1:40] talk to an application, nobody's going to use it,
right? That's been that's been the norm in 2026.
[1:46] Second is a lot of these UIs in the past or
applications that you've deployed in enterprise
[1:51] earlier used to rely on a lot of muscle memory,
which means that okay, let me train the user.
[1:57] Let me create a UX that is fundamentally different
than some other application and my UX is better
[2:02] than yours and that's why my application is
more usable than yours, right? Now, that's gone,
[2:07] right? There is no more mode in a better UI
because fundamentally people wants to use
[2:13] their God-given talent of talking to a system in
the language that they really understand, right?
[2:19] So, muscle memory is gone, right? Now, the the
other thing that you need to realize is that
[2:25] there is a new set of users for your enterprise
application and they are not human, right? Now,
[2:30] who are these users? These are other agents that
are interacting with your system, right? And these
[2:36] These agents don't use a UX. They use APIs. They
use CLIs. They use MCP servers, right? These are
[2:42] the new age of communication between these these
new kind of a users that you are deploying within
[2:47] the enterprise. It's so you have to adapt to
these things, right? More so in 2027 than in 2026.
[2:54] Uh but this is fundamentally what we are seeing as
well, right? Like whenever we we try to deploy a
[2:58] software within an enterprise, the first thing
everybody asks is, are you API compliant? Do
[3:03] you have an MCP server, right? Do you have a
CLI server, right? These are the fundamental
[3:07] questions you'll be getting um within the system.
Now, can you delay all this, right? Can you take
[3:13] a pause and saying that, okay, I'm not going to
uh you know, get into this right now? You can't.
[3:18] Because everybody is moving that fast. Your
competitors are going to get more advantage
[3:23] advantages because they're using AI, so you
can't wait. So, with all this, what does
[3:28] what does the next set of challenges look like,
right? Now, [snorts] as we discussed, interface
[3:32] has collapsed. So, what does the new interface
look like? It's fundamentally conversational,
[3:36] right? And the work is now coming to you rather
than you going to the work. What does that mean,
[3:41] right? You're not going to an interface.
You're mostly in Teams, in Slack, in email,
[3:45] wherever you are collaborating with your
other employees, that's where you are
[3:50] and you want work to come to you, Right? And
you have a chat interface. Now, there's no
[3:56] um fixed UIs. What does that mean, right? Uh
fixed UIs need training. Right? And UIs that
[4:03] are now usable right now are conversational, which
means that if I have an intent for me for you to
[4:07] show me some riskiest POs that I have, it should
come up with a UI that is defining my objective,
[4:13] right? And And the example shows here, you start
a conversation with something, right? And then
[4:18] you're presented with not just the answer for that
particular problem, but also a visualization that
[4:23] explains you why I provided that particular
problem, right? This is the new norm of um
[4:29] um of what communication with applications
are going to be. Now, for this, what does
[4:34] enterprises have to do? What is the stack that
we need to build in order to make this happen,
[4:38] right? Let me allude to one more problem.
Earlier, there were a lot of interns within
[4:43] your organization. You had, you know, you used
to train them on the software, whether you had
[4:47] an ERP, whether you had a CRM system. Used to
be what we call as a training that you used to
[4:52] take from an intern to uh kind of an expert within
your organization, right? Now, you have a new
[4:57] workforce. And what is this new workforce?
These new new workforces are called agents,
[5:01] right? This fundamentally what our platform does.
It basically creates a digital worker within your
[5:06] enterprise, right? And what are these digital
workers? They don't sleep. Right? They're 24/7
[5:11] listening to events that are happening within
your organization, whether there's a new PO
[5:15] coming in an email, whether there's a new
alert that's been um you know, raised by an
[5:19] asset within your system, right? All of that are
immediately triggering these so-called digital
[5:24] workers, all right? And then they perform the
operations that you have given them to perform.
[5:29] They're assisted as well. Why do you need
assistance? Assistance is because whenever
[5:32] there are exceptions, right? Like obviously,
if you in if you have a new intern within your
[5:36] organization and ask them to monitor an asset
that is releasing uh couple of alerts every hour,
[5:42] you would want to train them as to what they need
to do in a when a particular alert happens. So,
[5:46] that's why you have human in the loop, which
is what assisted workmanship is, right?
[5:50] And then finally, you have autonomous, where you
know, your agents are taking decisions, but this
[5:55] doesn't happen on day one, right? Very similar
to how you're taking your interns from a journey
[6:00] of interns to experts. What do you have? You
have process documents that interns goes through
[6:05] when you come into the organization. Then you
have, you know, people attending trainings,
[6:10] right? At some point of time when they start
solving problems for you, they become experts.
[6:14] And how do they How does it happen? Right? And
this is what we believe, right? And and over a
[6:20] period of time, as we started deploying more
and more agents in more and more complex and
[6:25] asset-heavy, you know, organizations are heavily
regulated, we found out that this is a stack that
[6:30] makes sense, right? Now, let me go through the
stack. Now, what you're seeing at the bottom,
[6:35] right, is infrastructure. If you remember
your SaaS world, where you had applications,
[6:41] infrastructure as a service, you had your
databases, you know, your your storage devices,
[6:48] all that is now collapsed in what we call as
infrastructure. This is given. If you don't have
[6:52] this, you don't have a product and you don't have
a company anymore, right? So, that's a given. So,
[6:57] nobody is going to give you any brownie points
if you just have infrastructure layer, right?
[7:02] So, what does the next stack looks like? The next
stack is what we call as intelligence, right? Now,
[7:06] intelligence can be both public LLMs, right? But
public LLMs cannot be just your differentiating
[7:12] factor, right? You need to have your intelligence.
What is your organizational intelligence,
[7:15] right? That's what we say that private LLMs
or a way to deploy private LLMs is very key
[7:21] if you want to if you want to keep your moat
as an organization, right? And I'll come
[7:26] to how we how we deploy it and how we kind of
fine-tune models to do that. But fundamentally,
[7:32] the third layer that we're talking about
here is what we call as an ontology, right?
[7:36] Now, an ontology can be for one application,
right? But your organization is not made of
[7:40] one application, right? You have CRM systems,
you have ERP systems, you have HR systems,
[7:45] you have work engineering systems. All these
have their own ontologies, right? And there is
[7:50] somebody within your organization who understands
how these applications link up with each other,
[7:54] right? That's what is called an organizational
ontology. If you have an organizational ontology,
[8:00] that is how you kind of ground your agents
to basically say what is hallucination,
[8:05] what is not hallucination, what is your boundary
of operation, right? In order for them to make
[8:10] meaningful decisions based on the domain that
they're actually solving the problem with, right?
[8:15] And that's why the ontology is very important.
And what what includes in an ontology? You have
[8:20] entities, you have APIs and relationships that
these entities go go together. There's one-to-many
[8:25] relations, many-to-many relationships.
All these what we had in the database,
[8:28] you have to give it to your agents in order for
them to do reasonably well with decision making,
[8:33] right? What what other thing is there
here, right? If you think of old UIs,
[8:38] you had a lot of business logic and and business
logic and rules, right? Like for example,
[8:43] uh if you are an admin, right? You can do
certain things. If you are um you know,
[8:48] a supervisor, you can do certain things. And
all this was coded as part of the application,
[8:53] right? Now, applications are gone. There's no
longer an application. So, where does these
[8:57] these rules reside right now? That's the context
layer, right? So, you have the third layer. You
[9:02] have You have the entities, you have the APIs, and
then you have what you call as rules or policies.
[9:07] And policies can be business policies or they
can be what we call as role-based policies,
[9:12] right? And that's what your ontology is. Once you
have defined your ontology, it's very easy for you
[9:17] to define an agent in any harness you want,
right? You can use uh Cloud, you can use
[9:22] uh OpenAI, you can use any of the open-source
ontology, but because you've grounded most of
[9:26] your business logic or the domain knowledge within
the ontology, they will behave properly, right?
[9:32] Now, the obviously the top layer is where
work happens. Now, uh work used to happen in
[9:37] ERP systems where you're supposed to read an email
and then go and fill up a form within an within an
[9:43] an ERP system or you want to look an alert and
basically figure out what you what you need to
[9:47] do with an alert. All this is now moved into what
we call this a work layer which could be a harness
[9:52] of your choice, right? And obviously when you
pick the harness you need to figure out on what
[9:57] are the capabilities of the harness and things
like that, but that's your that's your stack,
[10:01] right? And at a very high level obviously there's
a lot of details in each one of those areas.
[10:08] Right? All right. So, now one one thing that um
the ChatGPT movement or uh the agents have done is
[10:21] they've reduced the gaps between haves and
have-nots, right? When I say haves and have-nots
[10:25] for me my my background has a little been on
um a lot of startups. I've done five startups,
[10:30] right? And in each of these startups when
we compete with the big company one of the
[10:34] biggest things that we had was we have 30 people
an enterprise has a thousand people. How do you
[10:39] compete with them, right? Speed was one thing
that we always used to use as a differentiator
[10:43] to compete with big companies, right? Speed
and very focused area of of building, right?
[10:50] With generative AI with agents, right? The barrier
of development is gone which means that you have a
[10:55] thousand people I have a 30 people my 30 people
might be much better than your thousand people
[10:59] because, you know, we have far better tools right
now and both of them have an even keel, right? So,
[11:06] then what's your moat, right? What is your moat
as a 10-year or 20-year organization that you've
[11:11] been solving customer problems? Where where
does your moat go, right? That's fundamentally
[11:16] why we believe the two important aspects of um of
your organization. One is organizational memory.
[11:24] What's organizational memory? Let's say for
example there is this there is a supplier
[11:28] um that calls me from Greece, right? And talks to
me about a particular part. They talk a different
[11:34] language. There are a few people in your
organization who understand how to deal with,
[11:38] you know, suppliers from Greece. There are a few
people in your organization that understand how to
[11:42] deal uh with uh suppliers from Texas, right? Now,
one person doesn't have all this. And if the agent
[11:49] doesn't know this, right? They won't understand
this concept. Like they won't understand what
[11:53] is the difference between these two um these two
people. And that is what is your moat within your
[11:58] organization. The organizational memory is the
memory a collective memory of all your employees.
[12:06] Right? And as when you deploy agents, you have
to be very careful about how you're collecting
[12:11] this memory. Because the next agent or the next
digital worker that you're spawning needs to
[12:15] be aware of every decision that your employees
had made in the past in order to do a good job.
[12:20] Right? That's why the organizational
memory is really important, right? Now,
[12:23] how do we store it? Obviously, you can create
knowledge graphs, you can create, you know,
[12:28] um vector graphs. There's a lot of different
ways of storing this organizational memory.
[12:32] Uh we use a lot of vector graphs to to do that
uh the storing, right? The second aspect is
[12:38] process intelligence, right? Now, a lot of
companies, like take Pepsi for example, like Coke,
[12:43] right? They really value their supply chain. They
really value how efficiently they do the process.
[12:49] There are companies that differentiate themselves,
right? Just because their process is much better
[12:54] than somebody else's process. Now, imagine if
you're giving all this to an AI agent to do,
[12:59] and then fundamentally, you probably give
them saying, "Okay, I'm going to give you
[13:01] the process documents, and I'm going to have
a human in the loop to basically understand,
[13:05] you know, the incremental exceptions, and then
eventually, they become experts at it, right?"
[13:09] But you're giving away all that knowledge, right?
To a public LLM. You won't even discuss that with
[13:14] a with a with a person outside of your company,
but now you're okay giving that to a public LLM.
[13:20] Not just giving that to a public LLM, you're
also telling the LLM saying, "Here's my process,
[13:24] but wait, I'm also going to give you a set
of guard rails which will prove whether
[13:29] this process was right or wrong. Right? Be
wary about it that you are doing it. Now,
[13:34] I'm a cautious person, right? I would not want
to do this. So, I used two LLMs. One to do my
[13:41] process, the other one to do my you know, eval or
you know, guard rails and everything else, right?
[13:46] Even is that good enough? Not really. So, what we
do is we have a constant process of distillation.
[13:53] Right? Every time there's a process that goes
through fine, we collect the data. We make sure
[13:58] that we fine-tune a smaller LLM which is getting
much better and better at solving that particular
[14:03] micro-process. And over a period of time, you
start collecting these micro-processes and LLMs
[14:08] that are good at solving these micro-processes,
create a bigger LLM with a mixture of experts.
[14:12] Now, you have an LLM that is very specific
to your organization, which you can replicate
[14:17] at any amount of time, right? And you can you can
run agents and start getting better and better,
[14:21] right? That's yours to keep. It's not Anthropic's.
It's not OpenAI's. That's yours to keep, right?
[14:27] That is moat for you. Right? So, it's very
important that you understand that you're not
[14:32] you know, giving away everything, right?
Or keeping keeping something to yourself.
[14:37] Now, [clears throat] this is a quote from our
CEO, "Speed is life." and I really agree with it
[14:42] because if you are not fast at things, you're
going to lose at this game. Your competitors are
[14:47] going to be faster than you and you are going
to lose at this game, right? Now, speed always
[14:51] comes with blind corners, right? If you go fast
around a curve, you are going to hit something,
[14:56] right? Now, how do you protect yourself? There are
multiple ways of protecting yourself by the way,
[14:59] right? And again, this is a challenge that
every CIO or CISO organization faces, but
[15:06] in short, what we have learned is there
are four ways to protect yourself. One is
[15:11] before you send a prompt out of your network,
you need to have you need to make sure that there
[15:17] are certain things that are not in the prompt,
right? Things It's are the prompts having any
[15:22] prompt injection or is any PI information being
being released in there? Is my data leaking and
[15:28] all those things? For that, a very good approach
is to have a smaller local LLM and go read about
[15:34] Nvidia's NeMo Tron and all these other things
which which they use a smaller LLM to detect
[15:40] these these threats even before sending it outside
because you want these things to be fast as well,
[15:44] right? You don't want them to be you know, because
every prompt that you send, if you start doing a
[15:49] lot of handling on that, it's going to become
slower, right? So, use a smaller LLM and eight
[15:55] 8 million parameter smaller LLM that you can
pretty much run on a very high-end CPU, right?
[16:01] And then you use these to to detect your
prompts. Right? Observability, obviously,
[16:08] any platform that does not have observability,
don't use it because it's not just for security,
[16:11] they're also not capturing what you really need to
find your LLMs, right? So, you need observability
[16:16] as a as a picture. Human in the loop is very
important, right? Not just for exception handling,
[16:21] but also for capturing that memory that we talked
about earlier, right? Every exception is a memory
[16:25] that is in somebody's head that you're not
capturing, right? So, human in the loop is
[16:29] really important not just for making sure that
the process are not happening with exceptions,
[16:33] but also capturing the memory, right? And
storing it in your organizational memory stack.
[16:40] Right? Obviously, governance is is key.
Running out of time here, so I'm going to
[16:44] just move forward. Now, this is what a stack
looks like, you know, this is published in our
[16:47] website ifs.ai. You can basically look at it.
I'm not going to spend too much time on this.
[16:53] Right? Now, what's next, right? What's the
future? Now, robots, as as everybody knows,
[16:59] there's also many videos that are coming out
about robots dancing and things like that,
[17:02] but let's get serious. Robot is the new
computer, right? Now, what's the difference?
[17:06] The difference is your computers right now can
tell you what decisions to make. They can tell
[17:10] you that do this in order to solve the problem.
Robots are going to solve the problem actually,
[17:14] right? Now, where is the trend going? You have
LLMs right now. That's That's a thing of the past.
[17:19] You have VLMs if you are into vision,
if you are into videos, if you are into
[17:23] trying to extract signals from your, you
know, physical devices, physical intelligence,
[17:28] right? The next thing is VLAs. VLAs are vision
language models that output actions as tokens.
[17:36] Right? They tell the robot what to do, how much
to rotate the arm, right? How much to move about,
[17:43] right? These are VLAs that are going to become
your next generation VLMs, right? So, things are
[17:48] moving really fast. Right? So, it's important that
your stack is adapting to not just the current
[17:55] technology of LLMs, but also the future where the
computers are no longer sitting on your desktop.
[18:04] Right? That I'll leave I'll leave
that with the thought on your head.
[18:08] Any questions, I'm happy to take that.
[18:13] Woo! [applause] Okay.
