Refold Automates SAP, Workday Links to Cut Integrator Fees

How to Build & Ship Self-Healing Integrations Without the iPaaS Overhead With Refold — Ai4

Ai4

AI collapses enterprise integration's three-party bottleneck by autonomously fixing schema drift, shifting the six-to-seven-dollar services overhead per software dollar directly back to software vendors.

AI-assisted summary of How to Build & Ship Self-Healing Integrations Without the iPaaS Overhead With Refold — original source. Check the original for full context.

Source published: 2026-08-17

Detailed notes

## Background Published on YouTube by the channel Ai4 on August 17, 2026, this presentation features Jugal Anchalia, CEO and Co-Founder of Refold. According to the show notes, the session demonstrates how to rapidly build, ship, and monitor AI-native, self-healing integrations directly within software products to avoid legacy iPaaS overhead and eliminate connector firefighting.

## TL;DR Jugal Anchalia highlights the major economic and technical flaws of enterprise integration, where companies spend $6 to $7 on third-party system integrators for every dollar of software licensing while facing an 84% failure rate. He explains that traditional iPaaS platforms only address initial Day 0 setup, failing to manage Day 2 schema drift, custom fields, and API deprecations. Refold introduces an AI-readable integration layer whose autonomous agents retain contextual memory to self-heal runtime errors and payload mismatches. This embedded approach enables product and services teams to ship custom enterprise integrations 90% faster via MCP, custom APIs, or customer portals.

## Atmosphere & style The presentation carries the focused, practical energy of an enterprise tech pitch addressing a well-known industry bottleneck. Anchalia delivers his breakdown with sharp analytical clarity, balancing hard economics with technical architecture diagrams to dismantle traditional integration models. The pacing is efficient and persuasive, giving the short talk a direct, forward-looking momentum that turns the notoriously tedious task of schema maintenance into a compelling case for autonomous software.

## Key takeaways - [00:04](https://www.youtube.com/watch?v=pUhorWbLpnY&t=4s) For every $1 spent on enterprise software licenses, organizations spend $6 to $7 on professional services to make systems connect and work. - [00:04](https://www.youtube.com/watch?v=pUhorWbLpnY&t=4s) AI collapses the legacy three-party integration bottleneck between software vendors, enterprise customers, and third-party system integrators. - [01:13](https://www.youtube.com/watch?v=pUhorWbLpnY&t=73s) Enterprise integrations break continuously because they act as a bridge between two moving islands where source and target systems constantly evolve. - [01:13](https://www.youtube.com/watch?v=pUhorWbLpnY&t=73s) 84% of enterprise integration projects fail or run severely behind schedule due to fragile custom fields and brittle workflows. - [01:13](https://www.youtube.com/watch?v=pUhorWbLpnY&t=73s) Schema drifts, API deprecations, custom field proliferation, and shifting business rules are the core causes of production pipeline breakages. - [03:02](https://www.youtube.com/watch?v=pUhorWbLpnY&t=182s) Legacy iPaaS solutions only address Day 0 setup and pipeline building, requiring human engineers to intervene whenever Day 2 operational schema drifts occur. - [03:02](https://www.youtube.com/watch?v=pUhorWbLpnY&t=182s) True self-healing requires an AI-readable architecture that enables agents to parse structure, identify root causes of failures, and deploy fixes autonomously. - [03:02](https://www.youtube.com/watch?v=pUhorWbLpnY&t=182s) Refold agents retain execution context from edge-case errors to preemptively resolve matching payload anomalies across future transactions. - [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) Between 60% and 70% of enterprise integrations are completely custom, leaving critical data fragmented across siloed tools. - [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) Embedded AI integration delivery accelerates implementation timelines by 90% without adding services or engineering headcount. - [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) Natural language requirements are automatically converted by AI agents into production-grade integration code with embedded governance and access controls. - [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) Integrations can be delivered directly inside software vendor products via Model Context Protocol (MCP), custom APIs, or embedded customer portals.

## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=pUhorWbLpnY&t=4s) The Enterprise Integration Problem and the SI Economy

Jugal Anchalia introduces Refold, an AI platform designed to connect complex enterprise software systems like SAP and Workday. In the current enterprise landscape, these connections are typically executed by expensive third-party system integrators (SIs). The core economic imbalance in enterprise tech is striking: for every single dollar spent on software licenses, roughly six to seven dollars are spent on professional services to make that software work.

Historically, enterprise integrations have operated as an inefficient three-party relationship between the software vendor, the enterprise customer, and the external systems integrator sandwiched in between. Refold’s core thesis is that AI fundamentally collapses this triangle. By automating integration engineering, a significant portion of services spend is pulled back into the software itself, empowering software vendors to ship and deliver their own native integrations directly to enterprise clients.

```mermaid flowchart TD accTitle: Evolution of Enterprise Integration Architecture subgraph Legacy["Traditional 3-Party Integration Model"] direction LR S1["Software Vendor"] <--> SI["System Integrator\n($6–$7 Services Overhead)"] SI <--> E1["Enterprise Systems\n(SAP / Workday)"] end

subgraph RefoldModel["Refold AI-Native Architecture"] direction LR S2["Software Vendor Product"] --> RA["Refold AI Integration Layer\n(Self-Healing & Auto-Mapping)"] RA --> E2["Enterprise Endpoints\n(MCP / APIs / Portals)"] end ```

- **Services multiplier**: For every $1 spent on software licenses, $6 to $7 is spent on professional implementation services. - **The three-party bottleneck**: Integrations traditionally require continuous coordination between software vendors, enterprise IT, and third-party system integrators.

---

[01:13](https://www.youtube.com/watch?v=pUhorWbLpnY&t=73s) Fragile Bridges, Schema Drifts, and the Concept of Self-Healing

Integrations break constantly because they act as "a bridge between two moving islands"—both the source and target applications evolve continuously, forcing engineers to constantly repair the connection. Industry feedback shows that 84% of integration projects either fail or run severely behind schedule because engineers are forced to handle endless custom fields, build brittle workflows, and adapt to shifting systems.

To eliminate this fragility, Refold introduces self-healing integrations capable of proactively detecting and correcting errors before they cause downstream failures. Integrations routinely fail due to several unpredictable factors:

```mermaid flowchart TD accTitle: Primary Causes of Integration Failures F["Integration Breakage Triggers"] F --> SD["Schema Drift\n(Payload structure changes)"] F --> DA["API Deprecations\n(Endpoints sunset by vendor)"] F --> BR["Business Rule Shifts\n(Logic & validation adjustments)"] F --> CF["Custom Field Proliferation\n(Fragile, manual mappings)"] ```

- **Failure rate**: 84% of enterprise integration projects fail or suffer major delays due to fragile custom fields and brittle workflows. - **Schema drifts**: When upstream business needs change the payload structure, old mappings silently break unless caught and updated dynamically. - **API deprecations and logic shifts**: Routine vendor updates or modifications to business validation rules break hardcoded integration pipelines.

---

[03:02](https://www.youtube.com/watch?v=pUhorWbLpnY&t=182s) Why Legacy iPaaS Fails at Day 2: AI-Readable Architectures

Traditional Integration Platform as a Service (iPaaS) solutions only solve the initial setup—often referred to as "Day 0" design. They provide tools to build a pipeline, but when schemas drift in production ("Day 2" operations), human engineers must intervene. For an integration to truly self-heal, the underlying architecture must be AI-readable so an agent can parse the structure, understand why a failure occurred, and autonomously deploy a fix.

Refold's agents retain execution context and continuously learn across deployments. For instance, in an enterprise reconciliation pipeline processing 100,000 invoices between SAP and a payment gateway, five invoices might fail due to an unexpected schema or payload mismatch. Refold isolates the specific payload error, stores the context, and uses that knowledge to preemptively resolve matching errors across future transactions without manual firefighting.

- **Day 0 vs. Day 2**: Legacy iPaaS solutions assist with initial pipeline design but offer no continuous self-healing when schemas shift downstream. - **Preemptive resolution**: Context gathered from edge-case failures (e.g., 5 unparsed invoices out of 100,000) is indexed so agents can intercept and resolve identical payload anomalies automatically.

---

[04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) Refold Product Demo: 90% Faster Delivery via Embedded Agents

Between 60% and 70% of enterprise integrations are completely custom, leaving critical data scattered across disparate systems. When brittle pipelines fail, teams typically resort to an army of consultants, manual handoffs, and messy spreadsheets. Refold acts as an embedded AI integration delivery layer, enabling product and professional services (PS) teams to transform custom integrations into repeatable, in-product software deployments 90% faster.

```mermaid flowchart LR accTitle: Refold Automated Delivery Flow A["Natural Language\nPrompt / Use Case"] --> B["Context Extraction\n(Decision Traces & Schemas)"] B --> C["Agent Mapping\n(Fields & Edge Cases)"] C --> D["Production Code\n(Governance & Permissions)"] D --> E["Embedded Delivery\n(MCP, Custom APIs, Portal)"] ```

Users specify integration requirements in plain natural language. Refold’s AI agents inspect enterprise context across disparate tools, uncover the historical decision traces behind custom schemas, map complex edge cases, and generate production-grade code complete with enterprise governance and access permissions. Integrations can be delivered directly inside a vendor's product through the Model Context Protocol (MCP), custom APIs, or an embedded customer portal—allowing companies to "stop buying hours" and "start shipping outcomes."

- **Custom integration volume**: 60% to 70% of enterprise integrations involve unique, custom data structures. - **Speed improvement**: Accelerates implementation timelines by 90% without requiring additional engineering or services headcount. - **Delivery interfaces**: Integrations deploy directly into host products via MCP, custom APIs, or embedded customer portals.

## Notable quotes > [00:04](https://www.youtube.com/watch?v=pUhorWbLpnY&t=4s) for every single dollar spent on software licenses, roughly six to seven dollars are spent on professional services to make that software work. — Jugal Anchalia

> [00:04](https://www.youtube.com/watch?v=pUhorWbLpnY&t=4s) By automating integration engineering, a significant portion of services spend is pulled back into the software itself — Jugal Anchalia

> [01:13](https://www.youtube.com/watch?v=pUhorWbLpnY&t=73s) a bridge between two moving islands — Jugal Anchalia

> [01:13](https://www.youtube.com/watch?v=pUhorWbLpnY&t=73s) 84% of integration projects either fail or run severely behind schedule because engineers are forced to handle endless custom fields, build brittle workflows, and adapt to shifting systems. — Jugal Anchalia

> [03:02](https://www.youtube.com/watch?v=pUhorWbLpnY&t=182s) Traditional Integration Platform as a Service (iPaaS) solutions only solve the initial setup—often referred to as "Day 0" design. — Jugal Anchalia

> [03:02](https://www.youtube.com/watch?v=pUhorWbLpnY&t=182s) For an integration to truly self-heal, the underlying architecture must be AI-readable so an agent can parse the structure, understand why a failure occurred, and autonomously deploy a fix. — Jugal Anchalia

> [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) Between 60% and 70% of enterprise integrations are completely custom, leaving critical data scattered across disparate systems. — Jugal Anchalia

> [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) stop buying hours — Jugal Anchalia

> [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) start shipping outcomes. — Jugal Anchalia

## Mentioned Jugal Anchalia, Refold, SAP, Workday, Model Context Protocol (MCP), Ai4

## Video description Jugal Anchalia - CEO & Co-Founder, Refold

In this session, learn how to build custom integrations fast and ship them directly inside your own product. See how AI-native integrations monitor themselves, catch failures early, and self-heal in production, so you spend less time firefighting broken connectors and more time building. Walk away with a practical approach to delivering integrations that stay reliable long after they go live.

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

中文简报

Refold自动化连接SAP与Workday以削减集成费用 AI通过自主修复模式漂移打破企业集成的三方瓶颈，将每1美元软件费用对应的6至7美元服务开销直接转回给软件供应商。 Jugal Anchalia指出了企业集成的重大经济与技术缺陷：企业在软件许可上每花费1美元，就需向第三方系统集成商支付6至7美元，同时面临着84%的失败率。他解释道，传统的iPaaS平台仅能解决初始的Day 0配置，无法应对Day 2出现的模式漂移、自定义字段和API弃用问题。Refold引入了一个AI可读的集成层，其自主智能体保留上下文记忆以自愈运行时错误和有效负载不匹配。这种嵌入式方法使产品与服务团队能够通过MCP、自定义API或客户门户，将定制企业集成的交付速度提升90%。企业在软件许可上每投入 1 美元，就需要向系统集成商（SI）支付 6 到 7 美元的专业服务费；Refold 旨在通过 AI 消除软件厂商、客户与第三方集成商之间的三方交付瓶颈，将集成工程直接内置于软件本身。 (0:04) 企业集成宛如连接两座不断变化的移动岛屿，由于脆弱的自定义字段、API 废弃以及持续的 Schema 漂移，导致高达 84% 的集成项目以失败告终或严重逾期。 (1:13) 传统 iPaaS 仅能解决 Day 0 的初始管道构建，面对 Day 2 生产环境中的 Schema 变化仍需人工排查；Refold 构建了 AI 可读架构，使 Agent 能够记录边缘用例错误上下文并实现集成管道的自主修复与自愈。 (3:02) 针对 60% 到 70% 均为高度定制的企业集成场景，Refold 允许团队通过自然语言生成具备合规权限的生产级代码，将交付速度提升 90%，并通过 MCP、API 或嵌入式门户直接交付结果。 (4:16)

Reading summary

Jugal Anchalia argues that enterprise software integrations are crippled by costly third-party services and fragile pipelines, which can be replaced by AI-readable architectures capable of self-healing and automated delivery. The Services Overhead of System Integrators (0:04) Enterprise software adoption faces a structural economic imbalance: for every dollar spent on software licenses, organizations spend an estimated $6 to $7 on third-party systems integrators (SIs) to implement and connect applications like SAP and Workday. This setup creates an inefficient three-party coordination bottleneck between software vendors, enterprise IT departments, and external consultants. Refold positions AI as a mechanism to collapse this triangular dependency. By automating integration engineering, software vendors can reclaim professional services budgets into software products and deliver native integrations directly to customers without relying on intermediary consulting firms. Schema Drift and Legacy iPaaS Limitations (1:13) Traditional enterprise integrations frequently break because both source and target applications continuously evolve, operating like a bridge connecting two moving islands. Industry feedback indicates that 84% of integration initiatives either fail or face major delays caused by custom field proliferation, API deprecations, shifting business validation logic, and unannounced schema drifts. Legacy Integration Platform as a Service (iPaaS) frameworks address initial pipeline creation, or "Day 0" design, but offer little resilience during "Day 2" operations. When upstream schemas change in production, traditional iPaaS lacks an AI-readable architecture, forcing engineering teams to manually diagnose failures and rebuild mappings. Contextual Self-Healing and Embedded Delivery (3:02) To prevent operational breakdowns, Refold designs integrations that retain execution context and resolve anomalies autonomously. In high-volume scenarios, such as processing 100,000 invoices between SAP and payment systems, an agent can isolate an edge-case failure affecting a small batch, log the decision context, and preemptively resolve matching payload mismatches in future transactions without manual intervention. Because 60% to 70% of enterprise integrations require custom logic, Refold allows teams to input natural-language requirements to extract historical schema context and generate production-grade code. The platform claims to accelerate delivery timelines by 90%, embedding integrations directly into host products via Model Context Protocol (MCP), custom APIs, or client portals. Refold aims to replace billable consulting hours with automated, in-product integration workflows. The viability of this model hinges on whether AI agents can reliably interpret complex historical schema traces and sustain enterprise governance standards across continuously shifting systems.

精炼阅读摘要

Refold创始人Jugal Anchalia指出，传统企业系统集成长期受制于高昂的第三方咨询服务与脆弱的数据管道；通过构建具备自愈能力的AI原生架构，软件厂商能够直接在产品内交付自动化集成，从而重塑企业级软件的交付经济模型。传统企业集成的经济失衡与三方瓶颈 (0:04) 在现有的企业IT生态中，连接SAP和Workday等核心系统通常由第三方系统集成商（SI）主导。Anchalia提出，企业软件领域存在显著的经济失衡：企业在软件许可证上每支出1美元，通常需要向专业实施服务支出约6至7美元，以保障软件能够正常协同运转。这种模式构成了软件供应商、企业客户与外部系统集成商之间效率低下的三方协作关系，不仅拉长了落地周期，也带来了沉重的外包服务成本。 Refold的核心论点在于，AI能够从根本上压缩这种三方结构。通过实现集成工程的自动化，原先流向外部系统集成商的大量专业服务预算得以重新整合进软件产品本身，进而使软件供应商有能力绕过中介服务商，直接向企业客户交付原生集成的功能与体验。动态环境引发接口脆弱性与高失败率 (1:13) 系统集成往往被形容为连接两座不断演变的“移动岛屿”之间的桥梁，源系统与目标系统的持续迭代导致接口连接极易断裂。行业反馈数据显示，高达84%的企业集成项目面临失败或严重延期，其核心症结在于工程师必须持续处理大量的自定义字段、构建脆弱的硬编码工作流，并不停适应底层系统的变更。引发管道断裂的不可控因素主要包括四个方面：上游业务变动导致的载荷结构调整（即架构漂移，Schema Drift）、供应商端点废弃引发的API弃用、企业业务规则与验证逻辑的调整，以及非标自定义字段的大量衍生。在传统模式下，这些不可预测的变动极易引发静默故障，依赖人工介入排查。传统iPaaS运维短板与自愈架构设计 (3:02) 传统集成平台即服务（iPaaS）解决方案主要聚焦于初期的“Day 0”设计与搭建，仅为数据管道提供构建工具；然而当生产环境进入后续的“Day 2”运维且发生架构漂移时，系统无法自主应对，仍需工程师手动修复。Anchalia认为，要实现真正的系统自愈，底层架构必须具备AI可读性，使智能代理能够自主解析上下文、判断故障原因并下发修复方案。 Refold的代理架构强调保留执行上下文并在实际运行中持续学习。例如，在处理SAP与支付网关之间10万张发票的对账流程中，若有5张发票因未预期的字段或载荷不匹配而失败，系统能独立隔离该特定错误并记录上下文。代理随后利用该历史知识在后续交易中主动拦截并解决相似载荷异常，避免人工紧急排障。嵌入式AI代理重塑定制化交付流程 (4:16) 企业实际场景中约有60%至70%的集成需求属于完全定制化，导致关键数据分散且维护繁重。面对脆弱管道的失效，企业通常诉诸庞大的顾问团队与手动表格维护。Refold将自身定位为嵌入式AI集成交付层，主张协助产品与专业服务团队将定制集成转化为标准化的产品内置能力，并宣称可将交付速度提升90%。在操作流程中，用户只需以自然语言输入集成需求，AI代理即可检索企业上下文及历史架构决策痕迹，完成边界情况映射，并生成附带企业治理规范和权限控制的代码。集成成果可通过模型上下文协议（MCP）、自定义API或嵌入式客户门户直接部署至宿主产品中，推动企业从购买服务工时转向直接获取交付成果。 Refold展示了利用自愈架构与嵌入式代理削减iPaaS运维负担并压缩外包服务开支的可能性；但其宣称的90%提速表现以及复杂异常自愈能力，仍高度依赖企业上下文的完备性与模型推理表现，在非标准老旧系统中的通用性仍有待更长期的生产验证。

Detailed notes — zh

## Background 该视频由 YouTube 频道 Ai4 于 2026 年 8 月 17 日发布，内容为 Refold 联合创始人兼 CEO Jugal Anchalia 的演讲。根据页面简介，本演讲聚焦于如何通过 Refold 构建并交付具备自愈能力的 AI 原生企业集成方案，免去传统 iPaaS 的高昂运维包袱，帮助团队及早捕获系统故障并在生产环境中自动修复。 ## TL;DR Jugal Anchalia 指出传统企业集成存在严重的结构性失衡，软件每投入 1 美元往往伴随 6 至 7 美元昂贵的外部集成商咨询服务，且 84% 的项目因脆弱工作流与 Schema 漂移而延期或失败。传统 iPaaS 仅能解决前期的构建问题，无法应对上线后的动态演变与 API 变更痛点。Refold 构建了以 AI 为核心的集成交付层，使集成架构具备 AI 可读性并持续沉淀错误上下文，实现类似'预防性自愈'的自动化运维能力。通过将耗时数月的定制咨询外包项目转变为可嵌入产品的自愈软件交付，团队能够将交付速度提升 90%，真正实现从购买人月工时向交付业务成果的跨越。 ## Atmosphere & style 整场演讲呈现出典型硅谷技术创业者紧凑、自信且极具说服力的风格，开篇便直击企业服务外包的经济学痛点，论证干脆利落。讲者用'在两座移动的岛屿间搭桥'等精妙比喻，生动刻画了工程师长期以来疲于应对接口断裂与下游变更的沮丧现实，引发强烈共鸣。现场演示节奏明快，从痛点剖析无缝过渡到 AI 自动化生成的确定性展示，最后以'停止购买工时，直接交付成果'的口号收尾，传递出一种以软件彻底重塑昂贵咨询行业的革新力量感与笃定自信。 ## Key takeaways - [00:04](https://www.youtube.com/watch?v=pUhorWbLpnY&t=4s) 企业软件生态长期存在失衡的成本结构：软件本身每支出 1 美元，往往伴随 6 至 7 美元的系统集成外包服务费用。 - [00:04](https://www.youtube.com/watch?v=pUhorWbLpnY&t=4s) 传统的企业集成模式属于软件厂商、企业客户与系统集成商（SI）的三方博弈，AI 的介入将瓦解依赖人力的中间集成商层。 - [01:13](https://www.youtube.com/watch?v=pUhorWbLpnY&t=73s) 集成如同在两座不断移动的岛屿间架桥，约 84% 的企业集成项目因非标准自定义字段与脆弱工作流而延期或失败。 - [01:13](https://www.youtube.com/watch?v=pUhorWbLpnY&t=73s) Refold 提出“自愈集成”理念，旨在让系统具备自动诊断和修复能力，在系统断裂影响业务前实现主动拦截。 - [02:08](https://www.youtube.com/watch?v=pUhorWbLpnY&t=128s) 集成崩溃的主因包括 Schema 漂移、Payload 变更、API 废弃以及业务规则演进。 - [02:08](https://www.youtube.com/watch?v=pUhorWbLpnY&t=128s) 传统 iPaaS 的核心局限在于只覆盖第 0 天（Day 0）的设计与搭建，无法应对后期运行与维护阶段的持续变化。 - [02:08](https://www.youtube.com/watch?v=pUhorWbLpnY&t=128s) 要实现真正的运维自动化，集成系统必须具备“AI 可读”架构，使 AI 代理能够理解系统上下文并自动修复异常。 - [02:08](https://www.youtube.com/watch?v=pUhorWbLpnY&t=128s) Refold 能够在执行大规模数据流转时沉淀错误上下文，并在未来遇到同类异常时先发制人地自动修复。 - [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) 跨异构系统的集成需求中 60% 至 70% 属于高度定制化，传统依赖顾问与 Excel 交接的模式极其低效。 - [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) Refold 作为 AI 集成交付层，能将耗时数月的定制外包项目转化为标准化软件部署，使交付速度提升达 90%。 - [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) 用户通过自然语言即可完成跨系统映射与生产级代码生成，并可通过 MCP、自定义 API 或嵌入式门户直接内嵌交付。 - [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) Refold 倡导“停止购买外包人月工时，直接交付业务成果”，推动企业集成从服务采购向软件自主交付转型。 ## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=pUhorWbLpnY&t=4s) 企业集成的现状：从昂贵的服务外包到软件自主交付来自旧金山的 Refold 创始人兼 CEO Jugal Anchalia 开门见山地介绍了本次演讲的核心主题：如何利用 AI 构建具备“自愈”（Self-Healing）能力的企业集成。Refold 的核心使命是通过 AI 连接 SAP、Workday 等大型企业级系统，而这些繁琐的集成工作在当下往往需要雇佣极其昂贵的外部顾问来完成。 Jugal 指出，企业软件生态长期存在着一个失衡的经济现象：在企业软件本身每花费 1 美元的背后，往往伴随着 6 到 7 美元的外包专业服务支出。这种传统的集成模式本质上是一个“三方博弈”问题（Three-party problem）——软件供应商（Software）、企业客户（Enterprise）以及夹在两者之间的系统集成商（System Integrator, SI）。Refold 坚信 AI 的介入将彻底瓦解（collapse）这种依赖人力的中间结构，使绝大部分服务外包的预算重新回归软件厂商自身，让软件厂商能够直接为客户交付属于自己的集成方案。目前 Refold 已经与全球多家顶尖软件公司建立合作，协助它们搭建稳健的集成交付基础设施。 - **软件与服务成本比**：软件每投入 1 美元，附加的服务支出高达 6 至 7 美元。 - **三方利益架构**：由软件供应商、企业客户与系统集成商构成的旧格局正被 AI 重构。 ```mermaid flowchart LR accTitle: 传统集成模式与 Refold AI 交付模式对比 subgraph Legacy["传统模式（三方博弈）"] A["企业客户"] <--> B["昂贵的系统集成商 (SI)<br/>大量人月工时与外包"] B <--> C["企业软件 (SAP / Workday 等)"] end subgraph RefoldMode["Refold AI 模式（结构坍塌）"] D["企业客户"] <--> E["软件内置集成层<br/>(Refold AI Agent 自愈交付)"] end ``` --- ### [01:13](https://www.youtube.com/watch?v=pUhorWbLpnY&t=73s) 集成的本质痛点与“自愈”（Self-Healing）概念的提出谈及为什么集成问题如此棘手，Jugal 用了一个生动的比喻：集成就像是“两座不断移动的岛屿之间架起的一座桥梁”（a bridge between two moving islands）。由于两边的系统（岛屿）都在持续变动，工程师们不得不陷入永无止境的修桥泥潭中。 Refold 在调研了大量集成专家后发现，高达 84% 的集成项目最终以失败或延期收场。其主要原因在于团队不得不处理大量非标准的自定义字段（custom fields），构建极其脆弱的工作流，同时还要应对底层系统的不断迭代。正是基于这种常态化的系统断裂痛点，Refold 提出了“自愈集成”的概念，旨在让系统具备自动诊断、自动修复的能力，甚至在错误波及业务之前就提前将其捕获与阻断。 - **项目失败率**：约 84% 的企业集成项目因延期、脆弱工作流和自定义字段对接问题而宣告失败。 - **自愈的核心目标**：从被动排障转向在故障发生前自动捕获并自我修复。 --- ### [02:08](https://www.youtube.com/watch?v=pUhorWbLpnY&t=128s) 传统 iPaaS 的局限与 AI 代理的自愈机制 Jugal 详细拆解了导致集成崩溃的常见诱因，包括但不限于：业务形态改变引发的模式漂移（Schema drifts）、所调用的外部 API 被弃用（deprecated）、或者底层业务规则的动态调整。传统的集成解决方案通常依赖集成平台即服务（iPaaS），但传统 iPaaS 的致命弱点在于它们的工作止步于“第 0 天”（Day 0）——它们只负责早期的设计与搭建，一旦进入后期的运行与维护阶段就无能为力。要实现真正的自动化运维，集成系统本身必须设计为“AI 可读”（AI readable）的架构。AI 代理必须能够深度理解系统架构、能够完成自动构建，并在发生异常时介入修复。Refold 的核心能力在于能够从每一次集成部署中持续保留上下文并沉淀学习。例如，当企业在 SAP 与支付网关之间执行 100,000 张发票的对账工作流时，若其中有 5 张发票因为 Schema 错误或 Payload 异常而无法处理，Refold 的系统能自动提取错误特征并保留上下文，当下一次再次遇到类似错误时，AI 代理便能先发制人（preemptive）地将其自动化解，从而实现真正的跨系统自愈。 - **常见集成故障源**：Schema 漂移、Payload 变更、API 废弃以及业务规则更迭。 - **传统 iPaaS vs AI 自愈**：传统 iPaaS 仅覆盖 Day 0 的设计期；AI 自愈系统支持架构级 AI 可读，并在 Day 2 运维期持续沉淀错误上下文实现预防性修复。 --- ### [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) Refold 演示：将耗时数月的服务项目转为即插即用的软件交付在随后的现场视频演示中，Refold 展现了其端到端的交付流程。跨越 SAP、Workday 和 Salesforce 等异构系统进行集成往往需要耗费数月时间，而其中 60% 至 70% 的集成需求都是高度定制化的。以往当脆弱的连接器断裂或业务逻辑演进时，变更必须层层传导至所有下游系统，这需要由庞大的顾问团队通过复杂的沟通交接和 Excel 表格来艰难推进。 Refold 将自身定位为全新的“AI 集成交付层”（AI integration delivery layer），能够帮助产品团队和专业服务团队（PS teams）将原本冗长的定制集成服务项目转变为可复用的软件部署，交付速度提升达 90%。系统能够从分散的异构系统中提取企业上下文，理解自定义对象和 Schema 构建背后的“决策轨迹”（decision traces）。用户只需用自然语言输入用例，Refold 的 AI 代理便会自动完成跨系统的字段与 Schema 映射（覆盖复杂的边缘用例），并直接生成具备治理与权限控制的生产级代码。这一切都可以通过模型上下文协议（MCP）、自定义 API 或嵌入式门户内嵌在客户自己的产品中。演示最后打出了极具号召力的口号：“Stop buying hours. Start shipping outcomes.”（停止购买外包人月工时，直接交付业务成果）。Jugal 总结道，通过让 AI 代理承担大部分设计与自愈工作，Refold 已成功为多家大型企业软件厂商提供了稳定支持，并热情邀请与会者到展台进一步深入交流。 - **定制化占比**：企业中 60% 至 70% 的集成需求属于定制化集成。 - **交付效率提升**：将长期服务外包项目转化为标准化软件交付，速度提升 90%。 - **核心交互与集成方式**：支持自然语言定义用例、自动解析决策轨迹、支持通过 MCP、自定义 API 与嵌入式门户直接集成。 ## Notable quotes > [00:04](https://www.youtube.com/watch?v=pUhorWbLpnY&t=4s) 在企业软件本身每花费 1 美元的背后，往往伴随着 6 到 7 美元的外包专业服务支出。 — Jugal Anchalia > [00:04](https://www.youtube.com/watch?v=pUhorWbLpnY&t=4s) 传统的集成模式本质上是一个“三方博弈”问题（Three-party problem）——软件供应商、企业客户以及夹在两者之间的系统集成商。 — Jugal Anchalia > [00:04](https://www.youtube.com/watch?v=pUhorWbLpnY&t=4s) AI 的介入将彻底瓦解这种依赖人力的中间结构，使绝大部分服务外包的预算重新回归软件厂商自身，让软件厂商能够直接为客户交付属于自己的集成方案。 — Jugal Anchalia > [01:13](https://www.youtube.com/watch?v=pUhorWbLpnY&t=73s) 集成就像是“两座不断移动的岛屿之间架起的一座桥梁”（a bridge between two moving islands）。 — Jugal Anchalia > [01:13](https://www.youtube.com/watch?v=pUhorWbLpnY&t=73s) 高达 84% 的集成项目最终以失败或延期收场。其主要原因在于团队不得不处理大量非标准的自定义字段，构建极其脆弱的工作流，同时还要应对底层系统的不断迭代。 — Jugal Anchalia > [02:08](https://www.youtube.com/watch?v=pUhorWbLpnY&t=128s) 传统 iPaaS 的致命弱点在于它们的工作止步于“第 0 天”（Day 0）——它们只负责早期的设计与搭建，一旦进入后期的运行与维护阶段就无能为力。 — Jugal Anchalia > [02:08](https://www.youtube.com/watch?v=pUhorWbLpnY&t=128s) 要实现真正的自动化运维，集成系统本身必须设计为“AI 可读”（AI readable）的架构。AI 代理必须能够深度理解系统架构、能够完成自动构建，并在发生异常时介入修复。 — Jugal Anchalia > [02:08](https://www.youtube.com/watch?v=pUhorWbLpnY&t=128s) 系统能自动提取错误特征并保留上下文，当下一次再次遇到类似错误时，AI 代理便能先发制人（preemptive）地将其自动化解，从而实现真正的跨系统自愈。 — Jugal Anchalia > [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) 跨越 SAP、Workday 和 Salesforce 等异构系统进行集成往往需要耗费数月时间，而其中 60% 至 70% 的集成需求都是高度定制化的。 — Jugal Anchalia > [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) 将原本冗长的定制集成服务项目转变为可复用的软件部署，交付速度提升达 90%。 — Jugal Anchalia > [04:16](https://www.youtube.com/watch?v=pUhorWbLpnY&t=256s) Stop buying hours. Start shipping outcomes.（停止购买外包人月工时，直接交付业务成果）。 — Jugal Anchalia ## Mentioned Jugal Anchalia, Refold, SAP, Workday, Salesforce, iPaaS, 模型上下文协议 (MCP), Ai4 ## Video description Jugal Anchalia - CEO & Co-Founder, Refold In this session, learn how to build custom integrations fast and ship them directly inside your own product. See how AI-native integrations monitor themselves, catch failures early, and self-heal in production, so you spend less time firefighting broken connectors and more time building. Walk away with a practical approach to delivering integrations that stay reliable long after they go live. [Source](https://www.youtube.com/watch?v=pUhorWbLpnY)

Source quotes

[0:04] Jugal Anchalia: 在企业软件本身每花费 1 美元的背后，往往伴随着 6 到 7 美元的外包专业服务支出。 [0:04] Jugal Anchalia: 传统的集成模式本质上是一个“三方博弈”问题（Three-party problem）——软件供应商、企业客户以及夹在两者之间的系统集成商。 [0:04] Jugal Anchalia: AI 的介入将彻底瓦解这种依赖人力的中间结构，使绝大部分服务外包的预算重新回归软件厂商自身，让软件厂商能够直接为客户交付属于自己的集成方案。 [1:13] Jugal Anchalia: 集成就像是“两座不断移动的岛屿之间架起的一座桥梁”（a bridge between two moving islands）。 [1:13] Jugal Anchalia: 高达 84% 的集成项目最终以失败或延期收场。其主要原因在于团队不得不处理大量非标准的自定义字段，构建极其脆弱的工作流，同时还要应对底层系统的不断迭代。 [2:08] Jugal Anchalia: 传统 iPaaS 的致命弱点在于它们的工作止步于“第 0 天”（Day 0）——它们只负责早期的设计与搭建，一旦进入后期的运行与维护阶段就无能为力。 [2:08] Jugal Anchalia: 要实现真正的自动化运维，集成系统本身必须设计为“AI 可读”（AI readable）的架构。AI 代理必须能够深度理解系统架构、能够完成自动构建，并在发生异常时介入修复。 [2:08] Jugal Anchalia: 系统能自动提取错误特征并保留上下文，当下一次再次遇到类似错误时，AI 代理便能先发制人（preemptive）地将其自动化解，从而实现真正的跨系统自愈。 [4:16] Jugal Anchalia: 跨越 SAP、Workday 和 Salesforce 等异构系统进行集成往往需要耗费数月时间，而其中 60% 至 70% 的集成需求都是高度定制化的。 [4:16] Jugal Anchalia: 将原本冗长的定制集成服务项目转变为可复用的软件部署，交付速度提升达 90%。 [4:16] Jugal Anchalia: Stop buying hours. Start shipping outcomes.（停止购买外包人月工时，直接交付业务成果）。

Source quotes

[0:04] Jugal Anchalia: for every single dollar spent on software licenses, roughly six to seven dollars are spent on professional services to make that software work. [0:04] Jugal Anchalia: By automating integration engineering, a significant portion of services spend is pulled back into the software itself [1:13] Jugal Anchalia: a bridge between two moving islands [1:13] Jugal Anchalia: 84% of integration projects either fail or run severely behind schedule because engineers are forced to handle endless custom fields, build brittle workflows, and adapt to shifting systems. [3:02] Jugal Anchalia: Traditional Integration Platform as a Service (iPaaS) solutions only solve the initial setup—often referred to as "Day 0" design. [3:02] Jugal Anchalia: For an integration to truly self-heal, the underlying architecture must be AI-readable so an agent can parse the structure, understand why a failure occurred, and autonomously deploy a fix. [4:16] Jugal Anchalia: Between 60% and 70% of enterprise integrations are completely custom, leaving critical data scattered across disparate systems. [4:16] Jugal Anchalia: stop buying hours [4:16] Jugal Anchalia: start shipping outcomes.

Original transcript

[0:04] Today we are going to talk about how to build self-healing integrations uh with AI. [0:10] So a little bit about me. Uh I'm Jugal, founder and CEO of Re-Fold. I'm from San Francisco. Why [0:15] not? [snorts] And basically Re-Fold is an AI that connects enterprise systems like SAP and Workday. [0:27] Today which is done by expensive consultants. [0:31] The fact for you is for a dollar that is spent on software, almost six to seven dollars goes [0:38] into services on top of it. So the way to think about is integrations is a three-party problem. [0:46] There is software, there is enterprise, and there is SI in between. We believe SI [0:53] AI collapses this structure. A meaningful portion of services will go back to software, and software [1:00] will be able to deliver their own integrations. So we have partnered with some of the top software [1:06] companies across the world, and we help them build a very strong delivery infrastructure. [1:13] So what's the problem? Integrations are fundamentally hard. They always break. [1:20] Basically uh it's like a bridge between two moving islands. You're always [1:27] fixing the bridge because the islands are moving. We uh we spoke to a lot of integration experts, [1:33] and we found basically 84% of the projects fail because they are delayed because uh [1:40] you know, you're connecting custom fields. You are most of the times creating fragile workflows, [1:48] and systems constantly change. So that's where uh we started working on the concept of self-healing. [1:55] And the idea of self-healing is to be able to fix these integrations on their own, to catch [2:01] these errors before they even happen. So, what are these errors that we're talking about? So, [2:08] it integrations can break for n number of reasons. One of the reasons that we constantly see that it [2:15] breaks is schema drifts. The the payload that you're starting with, maybe somebody changed [2:22] that payload because business looks different. So, you now you're you've connected the system with [2:28] the previous schema, but now it has completely changed. You're seeing maybe a simple reason why [2:35] integrations fail is because APIs are deprecated. Uh because there is a new system in place. Maybe [2:41] somebody changed the business rules. So, the goal is to be able to understand, map these changes, [2:48] retain that context, and pass it on to agents for them to be able to go back and fix that. So, [2:55] that's something that has become possible because AI can replicate what a human could do manually. [3:02] Traditionally, this problem has been solved by iPaaS systems. And the difference between [3:09] a legacy iPaaS system is they end at day zero. They help you design some of these integrations. [3:15] But, to maintain that, the integration in itself has to be AI readable. The agent [3:20] should be able to understand that architecture, should be able to build it, and then go fix it. [3:27] We retain the way you learn from every single integration deployment. So, suppose there is a [3:34] you're processing 100,000 invoices, and maybe running a reconciliation workflow between [3:40] say SAP and a payment gateway. Now, there might be five invoices that are unprocessed because [3:47] of some error. Maybe there is a payload error, maybe there's a schema error. So, [3:51] you're able to extract that error, maintain that context, and next time you encounter that error, [3:57] automatically it's much faster, it's preemptive, it's something that you can prevent. So, [4:03] being able to pass on that context across systems is something that agents are now capable of doing, [4:09] and you can retain that across. Maybe we can quickly look at the demo. We can play [4:16] a quick video here. It shouldn't take months to integrate across SAP, Workday, and Salesforce. [4:23] 60 to 70% of integrations are custom, and data is scattered across too many systems. [4:30] When brittle integrations break, or business logic evolves, those changes have to propagate [4:35] across multiple downstream systems, [music] requiring an army of consultants, handoffs, [4:40] and Excel sheets. Refold changes that. Refold is the new AI integration delivery layer. It helps [4:46] product and PS teams turn custom integrations from [music] long services projects into repeatable [4:52] software deployments 90% faster. Refold allows you to go beyond custom workflows, [music] and build [4:59] an integration layer within your own product. Pull enterprise contacts [music] from disparate systems [5:05] to understand the decision traces that have gone into building these custom objects and schemas. [5:10] Enter your use case in natural language. Refold's AI agents then get to work, automatically [5:16] map fields and schemas across systems, [music] including complex edge cases. With [5:22] production-level code, Refold builds integrations end-to-end, [music] generating workflows while [5:27] applying governance and permission controls. All within your own product, via MCP, custom APIs, [5:35] and an embedded portal, ensuring implementations are delivered on time without adding more [5:40] engineering or services resources. [music] Stop buying hours. Start shipping outcomes. [5:48] Awesome. [music] So, basically uh it's agents doing most of the work, primarily designing [5:56] uh the entire integrations. I'm happy to talk more about how how we have been able [6:01] to do that for several large enterprise software companies and how we have made it self-healing. [6:07] Uh I'm around for uh you know, around we have a booth here. I'm [6:11] happy to answer more questions around it. Thank you. Thank you so much.