Tavant Deploys AI Agent Harness to Modernize Legacy Enterprise Code

The Software Decision Beyond Build vs. Buy With Tavant — Ai4

Ai4

Direct prompting of AI coding agents fails in enterprise software unless organizations decouple foundation models into structured verification pipelines that postpone code synthesis until specifications and tests are locked.

AI-assisted summary of The Software Decision Beyond Build vs. Buy With Tavant — original source. Check the original for full context.

Source published:

Detailed notes

## Background Published on YouTube by Ai4 on August 15, 2026, this session features Olav Laudy, Head of AI Consulting at Tavant. The talk explores how technology leaders can navigate enterprise software decisions beyond traditional build-versus-buy trade-offs by utilizing hybrid architectures, open foundations, and AI coding agents to preserve sovereignty and avoid vendor lock-in.

## TL;DR Olav Laudy outlines a strategic framework for enterprise software delivery in the era of AI coding agents, moving beyond the binary choice of building versus buying. He analyzes the spectrum of software options—including SaaS, AI-native platforms like Palantir, low-code tools, and custom builds—highlighting trade-offs around governance, cost, and architectural lock-in. Tavant introduces a hybrid software model that pairs modular domain components with an enterprise AI governance harness layered over commercial coding assistants. This approach utilizes a structured seven-stage modernization pipeline with dual-loop executor-verifier governance, enabling organizations to refactor legacy codebases, unplatform monolithic architectures, and retain full source ownership in their own cloud environments.

## Atmosphere & style The presentation carries a pragmatic, authoritative, and architecturally grounded tone that cuts through commercial AI hype with practical engineering realism. Laudy delivers a structured, candid briefing for enterprise leaders, using clear modular diagrams to illustrate complex governance pipelines. The session feels like a high-level strategic workshop, systematically deconstructing enterprise pitfalls and replacing them with disciplined, guardrailed execution models.

## Key takeaways - [00:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=4s) AI coding assistants alter enterprise software economics by turning legacy modernization and modular 'unplatforming' into viable, cost-effective engineering tasks. - [02:31](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=151s) Software delivery spans a continuum—from pure SaaS and platform extension to AI-native ontologies, low-code, and custom builds—rather than a binary build-vs-buy decision. - [03:00](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=180s) Choosing where to sit on the software spectrum involves fundamental trade-offs among subscription overhead, vendor lock-in, engineering talent requirements, and innovation velocity. - [04:29](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=269s) Over-extending SaaS platforms for non-standard workflows creates architectural bloat, while AI-native platforms like Palantir risk locking enterprises into proprietary ontological schemas. - [06:51](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=411s) A hybrid software architecture pairs open cloud foundations and modular domain services with AI agent factories to achieve platform speed alongside custom software sovereignty. - [09:20](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=560s) Enterprises achieve better results wrapping commercial frontier models in a structured governance harness rather than attempting to build or train bespoke foundation models from scratch. - [12:14](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=734s) Directly prompting LLMs with functional specifications to synthesize enterprise code without rigorous multi-stage abstraction is a recipe for architectural disaster. - [13:00](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=780s) Effective legacy modernization pipelines deliberately postpone raw code synthesis until intent extraction, domain mapping, and test validation scaffolding are fully established. - [14:10](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=850s) Implementing a dual-loop control architecture—pairing an Executor Agent with an independent Verifier Agent and human-in-the-loop sign-off—prevents compounding errors across pipeline stages. - [17:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=1024s) Decoupling governance harnesses, tooling hooks, and domain specifications from the underlying LLM ensures agentic workflows remain model-agnostic and seamlessly upgradeable. - [18:30](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=1110s) Retaining full ownership of functional specifications, generated source code, and cloud deployment runtimes is essential for eliminating permanent vendor dependency.

## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=4s) Rethinking Enterprise Software in the Era of AI Coding Agents

Olav Laudy, Head of AI Consulting at Tavant, opens by reflecting on the ubiquitous industry debate over building versus buying software. Tavant, an AI engineering firm with its own suite of SaaS products across fintech, lending, and manufacturing after-sales, has been investigating how to construct a robust engineering "harness" around commercial AI coding assistants to produce enterprise-grade custom software.

The industry is currently driven by the promise that AI coding assistants will make development workflows "10 times as efficient." Beyond merely speeding up existing tasks, enterprises face mounting pressure to transform manual workflows into agentic systems. Furthermore, organizations saddled with legacy systems built twenty years ago now have a realistic path forward; where legacy modernization was previously a "horrible exercise" of scrapping code and starting over from scratch, AI agents make large-scale code refactoring economically and operationally feasible. This technological shift is also unlocking "unplatforming," empowering enterprises to disaggregate monolithic legacy platforms and replace individual components modularly without sacrificing architectural governance.

- AI coding assistants aim to compress developer labor and deliver order-of-magnitude productivity improvements. - Key enterprise demand drivers include transitioning manual workflows to agentic architectures and modernizing decades-old legacy applications. - Unplatforming allows organizations to replace expensive, rigid monolithic platform modules with purpose-built custom components.

---

[02:31](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=151s) The Spectrum of Software Decisions and Enterprise Trade-Offs

When technology leaders evaluate software delivery, the choice is rarely a binary build-versus-buy decision. Instead, it spans a broad spectrum of options: pure SaaS procurement, extending existing platforms, adopting AI-native platforms, leveraging low-code tools for citizen development, or committing to full in-house custom builds.

``` +--------------------------------------------------------------------+ | THE SOFTWARE SPECTRUM | | | | BUY --> EXTEND --> AI-NATIVE --> LOW-CODE --> BUILD| | (Pure SaaS) (Customized) (Ontology) (Citizen) (Custom) | +--------------------------------------------------------------------+ ```

Choosing a point along this spectrum involves navigating fundamental trade-offs: - **Cost Structure:** Buying SaaS replaces upfront engineering overhead with recurring subscription fees, whereas building requires retaining specialized in-house talent for ongoing maintenance and operations. - **Vendor Lock-In:** Pure SaaS and proprietary platforms create architectural dependencies that can severely limit an organization's agility if it later decides to migrate. - **Innovation Velocity:** Relying on commercial vendors tethers an enterprise's pace of innovation directly to that vendor's product roadmap. Organizations with distinctive domain needs may find themselves constrained unless they maintain control over their own technology stack.

---

[04:29](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=269s) Analyzing Software Archetypes: From Palantir to Low-Code

Each archetype on the software spectrum serves specific operational needs but carries inherent limitations. Pure SaaS solutions like Salesforce excel when organizations require rapid deployment of standardized business processes. However, extending these platforms beyond their intended domain introduces risks; companies often overextend the platform for edge-case user groups, leading to fragile architectures and spiraling costs.

AI-native platforms, exemplified by Palantir, offer powerful semantic abstraction layers and predefined ontologies that enhance how business users interact with complex data. Yet their core limitation is rigidity: the enterprise becomes deeply tied to that vendor's specific ontological model. Low-code platforms accelerate internal citizen development but sacrifice flexibility, making them ill-suited for critical, customer-facing applications. Custom builds offer complete autonomy and bespoke alignment, provided the organization has the engineering talent and budget to support long-term maintenance. Tavant's objective is to construct an alternative hybrid paradigm that captures the speed and structural benefits of buying alongside the flexibility and ownership of building.

- **Buy (e.g., Salesforce):** Best for standard processes and immediate time-to-market; high risk of architectural bloat when over-customized. - **AI-Native Platforms (e.g., Palantir):** High-value data abstraction through ontology layers, balanced against vendor dependency on their proprietary schema models. - **Low-Code Platforms:** Rapid internal workflow automation at the expense of engineering flexibility and external user scalability. - **Pure Custom Build:** Complete sovereignty and tailored features, requiring substantial continuous engineering commitment.

---

[06:51](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=411s) The Hybrid Software Architecture and AI Agent Factory

The emergence of advanced AI coding assistants makes a hybrid development model practical. By automating the generation of pipelines, infrastructure deployments, unit tests, and refactored codebases, AI assistants compress tedious engineering tasks while keeping human engineers in the loop.

``` +--------------------------------------------------------------------+ | HYBRID SOFTWARE OPERATING MODEL | | | | [ Client Specs ] --------+ | | v | | [ Spec Library ] --> [ AI HARNESS ] --> [ Open Modular Platform ] | | ^ - Pluggable Domain Modules| | [ Coding Agents] --------+ - Customer Cloud Runtime | | - Full Source Ownership | +--------------------------------------------------------------------+ ```

This hybrid model relies on several core architectural principles: - **Open Technology Foundation:** Utilizing open-source and standard cloud-native frameworks to eliminate proprietary platform fees and prevent vendor lock-in. - **Modular Domain Components:** Treating business domain products (such as lending or after-sales engines) as compartmentalized, pluggable modules operating on top of a reusable runtime. - **AI Agent Factory:** Leveraging an automated builder ecosystem to translate functional specifications into governed software modules. - **Sovereignty & Cloud Portability:** Deploying directly into the client's own cloud environment with complete ownership of and access to the underlying source code.

---

[09:20](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=560s) Structuring the AI Coding Harness Over Vanilla LLMs

Building bespoke software reliably requires a structured abstraction layer over commercial coding assistants. Rather than attempting to train proprietary foundation models or build coding agents from scratch, Tavant utilizes best-in-class base models (such as Claude Code or Codex) and wraps them in an enterprise governance harness.

``` +--------------------------------------------------------------------+ | TAVANT HARNESS & RUNTIME ENGINE | | | | AI Lab Coding Agents (Claude Code, Codex, LLM Loops) | | | | | v | | [ Tavant Governance Harness & Guardrails ] | | | | | +----------------------------+ | | | | | | v v | | [ Runtime Specific Builders ] [ Ignite Factory ] | | (Applies Spec Library) (Translates Client Specs into | | Governed Workflows & Agents) | | | | | | +----------------------------+ | | | | | v | | Target Runtime Platform (Client Cloud / Modular Domain Services) | +--------------------------------------------------------------------+ ```

The system operates across two key builder tracks: - **Runtime-Specific Builders:** Ingest Tavant's library of architectural recipes—including workflow schemas, rule engines, and data pipeline blueprints—to instantiate the underlying platform runtime. - **Ignite Factory:** Ingests bespoke client specifications and produces production-ready business logic, AI agents, and governed application workflows.

---

[12:14](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=734s) The Seven-Stage Modernization Pipeline and Dual-Loop Governance

Directly prompting an AI model with functional specifications and expecting production-grade code is, as Laudy cautions, a "recipe for disaster." AI agents must be managed by forward-deployed engineers who bridge business requirements and automated code generation. In Tavant's legacy modernization workflow, the process is decomposed into seven distinct stages, where raw code generation is deliberately postponed until stage six.

``` +--------------------------------------------------------------------+ | STAGE-LEVEL AGENTIC CONTROL LOOP | | | | Inputs / Prior Stage Spec | | | | | v | | +---------------------------------------------------------------+ | | | [ Executor Agent ] <---> [ Verifier Agent ] (Stage Verification)| | +---------------------------------------------------------------+ | | | | | v | | [ Human-in-the-Loop Validation Hook ] | | | | | v | | Validated Artifact Output (Passes to Next Stage) | +--------------------------------------------------------------------+ ```

1. **Discovery:** Ingests legacy documentation, architecture diagrams, and slide decks to map system topography. 2. **Intent Extraction & Parsing:** Analyzes underlying legacy code using specialized language parsers combined with LLM tooling to determine the true business intent. 3. **Requirement Mapping:** Converts legacy logic into modern domain specifications. 4. **Architectural Blue-printing:** Designs target services and integration contracts. 5. **Test & Validation Scaffolding:** Establishes acceptance criteria, integration tests, and guardrail definitions. 6. **Code Synthesis:** Generates modernized application code adhering to the generated specifications. 7. **Deployment & Runtime Verification:** Executes containerized deployments and live integration tests.

Within each stage, execution follows an "outer loop" governance model: an Executor Agent generates artifacts based on input specifications, a dedicated Verifier Agent independently audits the output against acceptance criteria, and a human-in-the-loop validation hook approves the stage before downstream progression.

---

[17:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=1024s) Leveraging Native Capabilities and Future-Proofing Agent Architectures

To avoid building brittle, proprietary agent frameworks that quickly become obsolete, the harness leverages the native extensibility of state-of-the-art developer tools like Claude Code. Capabilities are defined through standardized configuration layers:

- **Skills & Scripts:** Structured modules that execute deterministic development tasks and invoke language parsers. - **Tooling & Hooks:** Standardized interfaces that bind the model to CI/CD pipelines, static analysis suites, and validation runtimes. - **Sub-Agents:** Specialized personas deployed to verify outputs and enforce organizational guardrails.

By decoupling the governance harness and domain specifications from the underlying model, the system remains model-agnostic. When frontier AI labs release more capable models, organizations can upgrade their underlying foundation model without re-architecting their pipelines. This strategy enables enterprises to maintain full sovereignty over their functional specifications, eliminate vendor lock-in, and deploy modern software directly within their own cloud infrastructure.

## Notable quotes > [00:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=4s) 10 times as efficient — Olav Laudy

> [00:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=4s) horrible exercise — Olav Laudy

> [12:14](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=734s) recipe for disaster — Olav Laudy

> [00:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=4s) unplatforming — Olav Laudy

> [12:14](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=734s) Discovery — Olav Laudy

> [12:14](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=734s) Intent Extraction & Parsing — Olav Laudy

> [12:14](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=734s) Requirement Mapping — Olav Laudy

> [12:14](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=734s) Architectural Blue-printing — Olav Laudy

> [12:14](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=734s) Test & Validation Scaffolding — Olav Laudy

> [12:14](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=734s) Code Synthesis — Olav Laudy

> [12:14](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=734s) Deployment & Runtime Verification — Olav Laudy

## Mentioned Olav Laudy, Tavant, Ai4, Salesforce, Palantir, Claude Code, Codex, Ignite Factory

## Video description Olav Laudy - Head of AI Consulting, Tavant

What if the most consequential AI decision is not which model, tool, or vendor you select, but which software path you commit your organization to for years to come? In my work with enterprise technology leaders, I see organizations navigating a growing range of options—from buying SaaS and extending established platforms to adopting AI-native or low-code platforms and developing custom solutions on the cloud. Each path can be the right choice, but each carries tradeoffs that are often underestimated, including customization pressure, escalating ecosystem costs, governance challenges, architectural constraints, engineering continuity, and vendor lock-in. In this session, I will examine where each approach works best, the common failure modes leaders should anticipate, and how AI coding agents are changing the economics and speed of custom development without replacing the need for strong architecture, domain expertise, governance, and long-term ownership. Attendees will also learn how a hybrid approach—combining an open technology foundation, modular domain products, and AI-powered development tools—can deliver the acceleration of a platform while preserving flexibility, architectural control, and a path away from permanent vendor dependency. Join me for a practical, candid discussion designed to help CIOs, CAIOs, and technology leaders make the software decision that will shape how their organizations build, operate, and evolve.

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

中文简报

Tavant 部署 AI Agent 框架推进遗留企业代码现代化改造 在企业软件中直接对 AI 编程 Agent 进行提示往往会失败，除非企业将基础模型解耦至结构化验证流水线中，在规范和测试锁定之前推迟代码生成。 Olav Laudy 概述了 AI 编程 Agent 时代企业软件交付的战略框架，超越了自研与采购的二元抉择。他分析了包括 SaaS、Palantir 等 AI 原生平台、低代码工具和定制开发在内的各类软件选项，重点指出了围绕治理、成本和架构锁定方面的权衡。Tavant 推出了一种混合软件模型，将模块化领域组件与叠加在商业编程助手之上的企业级 AI 治理框架相结合。该方法采用具有双循环执行器-验证器治理的结构化七阶段现代化流水线，使企业能够重构遗留代码库、解耦单体架构，并在自身云环境中完全保留源代码所有权。 AI 编程助手通过将遗留系统现代化和模块化“去平台化”转化为可行且具成本效益的工程任务，改变了企业软件的经济模型。 (0:04) 软件交付是一个连续的谱系——从纯 SaaS 和平台扩展到 AI 原生本体、低代码和定制开发——而不是非此即彼的自研与采购决定。 (2:31) 在软件谱系中确定位置涉及在订阅开销、供应商锁定、工程人才需求和创新速度之间进行根本性的权衡。 (3:00) 针对非标准工作流过度扩展 SaaS 平台会导致架构臃肿，而 Palantir 等 AI 原生平台则存在将企业锁定在专有本体模式中的风险。 (4:29) 混合软件架构将开放云基础架构、模块化领域服务与 AI Agent 工厂相结合，在实现平台级开发速度的同时保障定制软件的自主权。 (6:51)

Reading summary

Olav Laudy of Tavant argues that advances in AI coding agents enable a hybrid software delivery model, allowing enterprises to move past the traditional build-versus-buy dichotomy by pairing open modular platforms with governed, automated custom engineering. Trade-Offs Across the Software Delivery Spectrum (2:31) Enterprise technology delivery spans a continuous spectrum rather than a binary choice: pure SaaS procurement, extended enterprise platforms, AI-native ontology platforms, low-code citizen tools, and full custom builds. Each archetype introduces distinct operational trade-offs between speed, flexibility, and architectural sovereignty. Standard SaaS applications like Salesforce provide immediate time-to-market for common business workflows, but overextending them to accommodate edge-case requirements frequently leads to fragile architectures and escalating recurring license costs. Conversely, AI-native platforms such as Palantir offer structured semantic ontologies that simplify complex data interactions, yet bind organizations to proprietary vendor schemas. Low-code options accelerate internal workflow creation but lack the adaptability required for core customer-facing systems, while fully bespoke in-house builds require dedicated engineering headcount to maintain. According to Laudy, enterprises need an approach that captures the velocity of commercial platforms while avoiding vendor lock-in and product roadmap dependency. Constructing an AI Harness for Hybrid Development (6:51) To combine the architectural control of custom software with the speed of packaged solutions, Tavant advocates deploying a hybrid operating model supported by an automated AI agent factory. Instead of training custom foundation models or building agentic frameworks from scratch, this pattern places an enterprise governance harness directly over commercial foundation models such as Claude Code and Codex. The resulting software components are deployed directly into the client's cloud environment, ensuring full source code ownership. The harness separates platform assembly into two operational tracks. Runtime-specific builders leverage libraries of architectural recipes—including rule engines, data pipelines, and workflow schemas—to stand up an open, cloud-native foundation. Simultaneously, a domain-specific factory translates custom client specifications into production-ready business logic, AI agents, and modular domain services. Governing Synthesis Through Multi-Stage Agentic Pipelines (12:14) Laudy warns that directly prompting raw large language models with functional specifications to write production code is a recipe for failure. To mitigate hallucination and architectural drift, Tavant structures legacy application modernization into a rigorous seven-stage sequence: discovery, intent extraction and parsing, requirement mapping, architectural blue-printing, test scaffolding, code synthesis, and runtime verification. Synthesizing code is intentionally deferred to stage six, ensuring rigorous specifications and automated tests precede any code generation. Within each stage, execution is constrained by a dual-loop governance mechanism. An executor agent first produces the target artifact, which is then independently audited against strict acceptance criteria by a verifier agent. The artifact cannot progress downstream until a human-in-the-loop validation hook confirms that the output satisfies domain requirements. Decoupling Foundation Models for Long-Term Extensibility (17:04) To prevent engineering pipelines from becoming obsolete as underlying model capabilities evolve, the governance harness utilizes native extensibility points within state-of-the-art developer tools. The architecture organizes capabilities into modular skills and deterministic scripts, standardized CI/CD and static analysis tool hooks, and specialized verification sub-agents. Decoupling business specifications and governance guardrails from the foundational AI models allows organizations to swap or upgrade underlying LLMs as frontier labs release new versions. This approach ensures enterprise software remains model-agnostic, portable across cloud environments, and insulated from vendor obsolescence. Tavant outlines how enterprises can disaggregate legacy monolithic systems into modular cloud-native architectures using AI coding agents. However, the system's operational viability remains contingent on forward-deployed engineers who must configure verification loops and supervise transitions between automated extraction and actual code synthesis.

精炼阅读摘要

Tavant 人工智能咨询主管 Olav Laudy 提出，企业软件决策已超越单纯的“自研与外购”两难选择；借助在商用 AI 编程助手外部构建受控工程外壳（Harness），企业能够以模块化解构旧系统，打造兼具外购交付速度与自研掌控力的新型混合开发范式。 超越自研与外购的光谱抉择 (2:31) 传统软件交付往往被简化为购买 SaaS 或全面自研的二元对立，但实际形态涵盖纯 SaaS 采购、平台扩展、AI 原生平台、低代码开发及纯自研等多维光谱。企业在不同路径间权衡成本结构、供应商锁定风险与创新迭代速度。纯 SaaS 模式替换了前期研发投入，却带来持续订阅成本，并在面对边缘场景过度定制时容易导致架构臃肿；AI 原生平台（如 Palantir）通过预设本体层提供强大的数据抽象，但企业会受制于其私有 schema 规范；低代码工具虽能加速内部平民化开发，却牺牲了面向外部核心系统所需的灵活性；纯定制开发虽能完全贴合业务并拥有代码主权，但必须长期承担高昂的专业工程维护团队开销。 AI 赋能的混合架构与解构重塑 (6:51) 生成式 AI 编程助手的兴起改变了工程经济学，行业预期其将推动开发工作流效率提升十倍，并使二十年前遗留系统的重构从过去难以承受的代码报废推倒重来，转变为经济可行的工程实践。这催生了“去平台化”（Unplatforming）与混合交付模式，允许企业在不破坏全局治理的前提下，逐步拆解昂贵且僵化的单体遗留平台，替换为自建模块。混合模式依托开源及标准云原生框架以杜绝专用平台费用，将借贷或制造售后等业务领域逻辑作为可插拔模块封装在可复用运行时之上，最终直接部署至客户自身云环境，确保企业享有底层源代码的完整掌控权与云端可移植性。 商用大模型之上的工程治理外壳 (9:20) 为了稳定交付企业级软件，Tavant 避免从零训练专有基础模型或自建底层编程代理，而是直接采用 Claude Code 或 Codex 等前沿基础模型，并在其外层封装工程治理与安全防护层（Harness）。该架构划分为两条构建轨道：一方面，特定运行时构建器（Runtime-Specific Builders）导入包含工作流模式、规则引擎与数据流水线蓝图的规范库，快速实例化底层平台运行环境；另一方面，Ignite Factory 负责吸收客户的定制化功能需求，并将其转化为生产就绪的业务逻辑、受控 AI 代理以及应用工作流，从而在基础模型能力与企业级交付标准之间建立结构化抽象层。 七阶段现代化流水线与双循环治理 (12:14) Laudy 警告，直接向 AI 模型输入功能需求并期望生成生产级代码往往会导致灾难。为此，遗留系统现代化工作流被严格拆解为七个离散阶段，且实际的代码生成被刻意推迟到第六阶段：从文档资产发现、代码意图解析与业务规范映射，到目标架构蓝图设计，再到测试与校验脚手架搭建，随后才进行代码合成，最后完成容器化部署与运行时验证。每个阶段内部均引入双循环（Outer Loop）治理体系：由执行代理（Executor Agent）负责根据前序规范生成中间产物，专门的验证代理（Verifier Agent）依据验收标准进行独立审计，且各阶段向下推进前均需通过人机协同（Human-in-the-Loop）的验证钩子确认，确保全流程处于前线工程师的严密监管下。 标准化扩展与模型解耦策略 (17:04) 为防止代理架构在技术快速迭代中过时，系统充分利用 Claude Code 等先进开发者工具的原生扩展机制，通过标准化配置层定义能力边界。具体包括执行确定性开发任务和调用语言解析器的“技能与脚本”（Skills & Scripts）、对接 CI/CD 流水线与静态分析工具的“工具与钩子”（Tooling & Hooks），以及专门负责合规与规则审计的“子代理”（Sub-Agents）。这种将治理框架、业务规范与底层基础模型解耦的设计，使整体架构保持模型中立；当外部前沿实验室发布更先进的基座模型时，企业可无缝完成底层模型升级，而无需推倒重构工程管线，进而牢固维持业务规范主权。 该方案的核心逻辑在于通过多阶段管道与人机协同机制约束商用编程代理，使遗留系统重构与混合软件定制具备确定性。然而，整个体系仍高度依赖前线工程师对各阶段产物的准确把关，在完全剥离人工校验的自主演进以及极度复杂的专有老旧系统跨平台解析上，仍存在工程落地的边际挑战。

Detailed notes — zh

## Background 本内容由频道 Ai4 于 2026 年 8 月 15 日在 YouTube 平台发布。视频记录了 Tavant 人工智能咨询负责人 Olav Laudy 的主题演讲，主要探讨企业在“自研还是外购”（Build vs. Buy）之外的全新软件决策路径，分析各类方案的权衡暗坑，并阐述如何结合开放技术底座、规范驱动与 AI 编码智能体实现兼具速度与控制权的混合架构。 ## TL;DR 演讲深入剖析了企业软件交付在纯 SaaS、平台扩展、AI 原生平台、低代码以及完全自研这五种形态下的得失与常见陷阱，指出一味依赖供应商或盲目自研都会带来高昂代价。Tavant 由此提出“第三条道路”：以企业自有的规格说明书（Specs）为核心资产，在底层基础编码模型外围搭建严密的工程外壳（Harness），并结合前线部署工程师（FDE）把关。演讲还通过应用现代化重构的七阶段管线与双循环治理机制，展示了如何在不依赖黑盒自动生成的前提下，安全高效地实现遗留系统重构，彻底摆脱单一厂商绑定并夺回软件资产所有权。 ## Atmosphere & style 整场演讲风格务实、坦率且极具工程实战洞察，演讲者完全摒弃了当下行业内浮躁的“一键全自动生成”AI 狂热，展现出资深企业技术顾问的沉着与冷静。叙事节奏层层递进，从剖析采购暗坑的清醒批判，到拆解七阶段重构管线与双循环架构的严谨细致，听感上硬核且逻辑闭环。现场洋溢着一种兼具战略前瞻与敬畏工程底线的理性氛围，给身处技术转型迷茫期的技术管理者带来了极具说服力的定心丸。 ## Key takeaways - [00:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=4s) AI 编码助手的出现改变了企业软件交付的经济模型，使推倒重写 20 年遗留系统与解绑臃肿平台（Unplatforming）在工程上切实可行。 - [02:31](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=151s) 企业软件交付路径是一条覆盖纯 SaaS、平台扩展、AI 原生平台、低代码到完全自研的光谱，传统各路径均面临专有生态锁定或昂贵维护成本的两难。 - [07:39](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=459s) 破解自研与外购困境的“第三条道路”是融合开放技术底座、模块化领域构件与 AI 构建工厂，兼具平台交付速度与资产自主所有权。 - [09:20](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=560s) 架构核心由右侧的多云运行时与左侧的 AI 构建系统组成，企业无需支付平台月租费，享有全部规格与底层源代码的修改控制权。 - [09:20](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=560s) 工程策略上不盲目自研原生编码大模型，而是复用 Claude Code 等成熟模型并在外围构建工业级外壳（Harness）与防线护栏。 - [12:14](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=734s) “一键全自动生成企业级系统”是危险的行业幻象，前线部署工程师（FDE）必须深入一线进行需求对齐并把控最终架构质量。 - [13:45](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=825s) 应用现代化组件（App Modernizer）采用七阶段流水线，前五个阶段均用于意图提取与架构建模，真正的代码生成被严格后置至倒数第二步。 - [15:09](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=909s) 采用双循环治理架构，由执行智能体产出草案、验证智能体对照规格严苛核验，并由人类工程师终审签名，从根本上遏制 AI 幻觉。 - [17:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=1024s) 上层业务治理规则与底层基础模型实现原生解耦，未来能够像插拔插头一样无缝接入更先进的大模型，而无需重构工程体系。 - [18:01](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=1081s) 软件资产的核心正演进为可执行的规格定义（Specs），企业借此摆脱强势供应商的捆绑条款，重新夺回软件演进的战略主导权。 ## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=4s) 重新审视自研与外购：AI 时代下的企业软件新命题 会议开场，演讲者 Olav Laudy（Tavant 人工智能咨询负责人）指出，当天上午的会议讨论中充斥着关于“自研还是外购”（Build vs. Buy）的激烈辩论，而这正是本次演讲的核心议题。Tavant 自身作为一家拥有多款 SaaS 产品的人工智能工程公司，一直在深入思考如何借助新兴的 AI 编码助手（AI coding assistants），在其外围构建一套工业级、坚固的治理框架（Harness），从而规模化生产高质量的企业定制软件。 这一变革背后的驱动力在于技术承诺与现实需求的双重碰撞。业界普遍预期 AI 编码助手能够将研发效率提升十倍，与此相对的是，企业内部亟需完成海量的自动化重组——不仅要将既有流程自动化，更要将整个工作流重塑为由智能体驱动的“Agentic”形态。在 Tavant 长期深耕的金融科技贷款（FinTech lending）与制造业领域，企业普遍背负着沉重的遗留系统包袱。在以往，推倒重写一套运行了 20 年的旧系统堪称是一场“可怕的折磨（a horrible exercise）”；而如今，利用编码智能体进行遗留系统现代化改造（Legacy Modernization）终于具备了经济与工程层面的可行性。与此同时，市场上正掀起一场轰轰烈烈的“解绑平台（Unplatforming）”风潮，企业不再甘于被巨头捆绑在庞大昂贵的全家桶实例中，而是开始尝试分拆并替换局部模块。然而，如何在这一过程中建立起有效的治理体系，依旧是企业面临的核心挑战。 - **核心场景分布**：以金融科技信贷审批、贷后管理与复杂制造业的售后业务为主。 - **现代化痛点**：传统模式下推倒重写 20 年历史的遗留核心系统代价极高、风险巨大。 - **市场新趋势**：企业逐步摆脱单一庞大平台捆绑（Unplatforming），转向更灵活的模块化拆解。 --- ### [02:31](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=151s) 从 SaaS 到低代码：全光谱技术选型的权衡与暗坑 企业在决定软件交付路径时，面临的绝非非黑即白的二元对立，而是一个覆盖五种形态的连续光谱：纯粹外购（Buy）、在现有平台上扩展（Extend）、AI 原生平台（AI-native platforms）、低代码平台（Low-code platforms）以及完全自主研发（Build）。企业在做决策时，必须审慎权衡成本、生态锁定、创新依赖度等关键要素。外购虽然开箱即用，但会带来持久的每月订阅成本，并将企业死死锁定在供应商的演进节奏上；自主构建虽能摆脱锁定，却需要组建庞大且昂贵的内部工程团队负责漫长生命周期的持续维护。 ```mermaid flowchart LR accTitle: Enterprise Software Path Spectrum subgraph Spectrum["企业软件交付路径光谱"] A["纯外购 SaaS\n(如 Salesforce)"] --> B["平台扩展\n(Extend)"] B --> C["AI 原生平台\n(如 Palantir)"] C --> D["低代码平台\n(Citizen Dev)"] D --> E["完全自研\n(Custom Build)"] end ``` 详细审视这些选项会发现，各类方案都有其难以回避的陷阱： 1. **外购 SaaS（如 Salesforce）**：适合标准化业务流程的快速部署，但一旦业务出现特化，企业就会陷入盲目定制的泥潭。 2. **平台扩展（Extend）**：试图在既有系统上二次开发，但往往面临“过度伸展”（Overextending）的风险，强行将平台用于其根本不擅长的业务场景。 3. **AI 原生平台（如 Palantir）**：虽然具备出色的本体论（Ontology）和语义层，能够将底层数据抽象为极具商业价值的业务模型，但企业也将因此受困于该平台特有的本体形态与专有架构中。 4. **低代码平台**：虽有利于全民开发者（Citizen development）快速搭建内部支持工具，但在灵活性上代价高昂，一旦涉及复杂的对外客户交互便捉襟见肘。 5. **完全自研**：给予企业最大的自由度，但长期维护代价巨大。 面对这种两难困境，Tavant 提出了一种第三条道路——融合外购平台的加速能力与自研的高灵活性，借助 AI 编码助手的突破能力打破原有权衡。 --- ### [07:39](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=459s) 破局第三条道路：融合生态特性的混合式平台架构 真正兼具“外购的开发速度”与“自研的资产所有权”的混合模式，其底层依托于 AI 编码助手带来的技术红利。如今的 AI 不仅能补全代码片段，更能够生成端到端的完整流水线、部署脚本和自动化测试套件，使大规模的代码重构变得切实可行。这一模式的核心理念是将工程任务高度压缩，将枯燥单调的手工编码交由机器加速，但全流程依然保留人类专家的在环控制（Human-in-the-loop）。 构建这种混合平台需要确立几个根本原则：首先，底层必须基于**开放技术平台（Open technology platform）**，坚决避免任何专有供应商的架构锁定；其次，上层的所有行业领域产品（Domain products）都应当被设计为**模块化、可插拔的构件**，运行于可复用的运行时（Runtime）之上；最后，企业通过构建一套包含多样化构建工具的“AI 工厂”（Agent factory / AI factory），打通从规格说明书（Specs）直接到可用软件产品的流水线。更重要的是，这套体系允许完全部署在客户自身的私有云中，没有按席位收取的平台月租，客户最终拥有全部源代码，享有绝对的架构控制权与修改权。 - **核心资产归属**：企业完全掌握核心软件的规格定义（Specs）与底层源代码（Source Code）。 - **基础设施形态**：支持多云及客户本地私有云运行，免去高昂平台授权费（No platform fee）。 - **解耦设计**：通用运行时基础层与垂直行业领域模块彻底解耦，按需插拔替换。 --- ### [09:20](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=560s) 架构蓝图拆解：AI 工厂外壳与运行时引擎的有机结合 从宏观技术架构来看，该体系清晰地划分为右侧的平台运行时与左侧的 AI 构建工厂两大部分： ```mermaid flowchart TD accTitle: Tavant Hybrid Platform and AI Harness Architecture subgraph LeftSide["AI 构建系统 (AI Factory & Harness)"] direction TB L1["底层模型 / 编码智能体\n(Claude Code / Codex / Kimi 3)"] L2["智能体约束外壳 (Agent Harness)\n(守卫护栏 / 合规治理)"] L3["规格驱动源\n(Tavant 预置规范库 + 客户业务规格)"] L4["运行时构建器 & Ignite 生产工厂"] L1 --> L2 --> L3 --> L4 end subgraph RightSide["目标交付平台 (Target Platform Runtime)"] direction TB R1["可插拔业务模块\n(信贷产品 / 售后服务 / 定制模块)"] R2["执行运行时 (Runtime Engine)\n(Tavant 预选套件 或 客户自有组件)"] R3["底层多云环境 (Any Cloud / Private Cloud)"] R1 --> R2 --> R3 end LeftSide -- "规格驱动生成与更新" --> RightSide ``` 右侧的运行平台具备多云部署能力，底层是预定义或由客户自带的业务运行时；上层则搭载了各种高内聚的业务模块（包括信贷处理、售后保障及根据客户需求全新定制的组件）。而整个体系的精髓在于左侧——**如何用规范工程化地造出这些组件**。在底层，系统接入的是原生的基础编码大模型，例如 Claude Code、OpenAI Codex 乃至 Kimi 3。 演讲者坦言：“我们曾经做过深入实验，得出的结论是：我们不可能凭空造出一个比科技大厂更强悍的原生编码智能体。”因此，Tavant 的研发重心并不是从零自研基础编码模型，而是在大模型外围构建一套**坚固的外壳（Harness）**。该外壳将智能体严格约束在既定的防线护栏（Guardrails）和企业治理规范内。这套外壳由两类规格输入驱动：一是 Tavant 积累的标准运行时配方（涵盖工作流定义、规则引擎及数据架构规范）；二是客户具体的软件业务需求规格。上层的专用构建器（Runtime specific builders）与 Ignite 工业化工厂正是以此为蓝本，稳定将抽象规格转化为安全可控的企业级工作流、AI Agent 或传统软件制品。 --- ### [12:14](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=734s) 戳破“一键生成”的幻象：前线部署工程师（FDE）的关键作用 虽然 Tavant 开发了数据平台构建器（Data platform builder）、系统迁移助手（Migration assistant）、数据科学智能体（Data science agent）等一系列听起来极具未来感的工具，但演讲者严肃澄清了行业内的普遍误区。当前市场上充斥着一种不切实际的幻想，认为只需把业务规范往 AI 编码器里随手一扔，按下按钮就能自动运行生成一整套复杂的数据科学系统。演讲者直接将这种一键式幻想定性为**“通向灾难的配方（A recipe for disaster）”**。 在实际工程交付中，人类资深工程师不可或缺。当下业界正在流行将这部分工程师重新命名为“前线部署工程师”（Forward Deployed Engineers, FDE）。他们的职责是深入业务一线理解规格，并驾驭 AI 编码助手产出高质量的模型与工程构件。代码具体写成什么样、架构如何落地，决策权依旧牢牢掌握在 FDE 手中，AI 从未获得完全脱缰的自主权。 - **角色重塑**：传统软件工程师进化为深入业务一线的前线部署工程师（FDE）。 - **工程红线**：严防脱离人工审查的“黑盒全自动编程”，代码质量由专业工程师最终兜底。 - **价值主张**：AI 扮演的是超级动力杠杆，而非无人监管的独立决策者。 --- ### [13:45](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=825s) 重构的艺术：应用现代化（App Modernizer）的七阶段管线 为了将这种受控的工程思想具象化，演讲者深入拆解了专门用于遗留系统现代化重构的应用组件——App Modernizer 的运作细节。在面对错综复杂的遗留陈旧系统时，Tavant 将整个重构作业拆分为严格递进的七个阶段： ```mermaid flowchart LR accTitle: App Modernizer Seven-Stage Pipeline subgraph Pipeline["现代化重构 7 个核心阶段"] S1["阶段 1: 资产发现\n(文档/PPT挖掘)"] --> S2["阶段 2: 意图提取\n(结合语法解析器)"] S2 --> S3["阶段 3: 架构建模"] S3 --> S4["阶段 4: 规则抽取"] S4 --> S5["阶段 5: 目标映射"] S5 --> S6["阶段 6: 实际编码\n(生成新代码)"] S6 --> S7["阶段 7: 测试验证\n与交付部署"] end ``` 整个管线中最发人深省的设计在于：**实际编写代码仅仅发生在阶段 6（倒数第二步）**。在真正敲下一行新代码之前，前 5 个阶段完全专注于彻底厘清“到底需要编写什么”。这包括第一阶段的基础发现（Discovery，从既有杂乱的技术文档、架构 PPT 中挖掘原始信息），以及后续利用底层编程语言解析器（Language parsers）配合 AI 深入提取既有旧代码的业务真实意图（Intent extraction）。正是前 5 个阶段在业务语义与架构层面的反复推演，才确保了阶段 6 生成的代码能够在生产环境中可靠稳定地运行。 --- ### [15:09](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=909s) 双循环治理机制：执行智能体、验证智能体与人机回环 在 App Modernizer 的这七个阶段中，每一个阶段内部都运行着一套精密的微观执行架构。阶段输入包含整个项目的总览规范以及上一阶段交付的中间成果，由具体的执行智能体（Executor agent）负责研读规格并产出阶段性产物（在发现阶段可能是梳理后的系统清单，在阶段 6 则转化为特定映射用例的高质量新代码）。 ```mermaid flowchart TD accTitle: Dual Loop Governance Engine subgraph OuterLoop["智能体治理外循环 (Outer Loop)"] direction TB IN["上一阶段输入 / 业务规格"] --> EX["执行智能体 (Executor Agent)\n(生成设计草案或代码)"] EX --> OUT["中间交付产物"] OUT --> VER["验证智能体 (Verifier Agent)\n(基于输入规格进行严苛审查)"] VER -- "未达标: 驳回重算" --> EX end subgraph HumanLoop["顶层安全控制网 (Human-in-the-loop)"] VER -- "审查通过" --> HIL{"前线部署工程师审查\n(意图确认 & 终审签名)"} HIL -- "放行" --> NEXT["流入下一阶段"] HIL -- "纠偏调整" --> EX end ``` 但这绝非终点。系统在这里建立了清晰的“双循环”（Inner Loop vs. Outer Loop）概念： - **内循环（Inner Loop）**：即传统 Claude Code 或 Codex 本身自带的单次指令生成过程。 - **外循环（Outer Loop）**：由专门配置的**验证智能体（Verifier agent）**组成。执行智能体一旦产生输出，验证智能体立刻介入，对照原始设计规范进行逐项严苛核验，形成自动化纠错循环，确保“设计初衷与生成现实高度一致”。 - **人机回环（Human-in-the-loop）**：在这两层智能体闭环之外，还嵌套着由前线部署工程师主导的监督钩子（Hook），负责确认系统是否真正契合顶层战略意图，并审核验证智能体的工作成效。这种多层套叠的防御机制，从根本上杜绝了 AI 自由散漫导致的“幻觉式编程”。 --- ### [17:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=1024s) 原生解耦与模型平替：面向未来的敏捷资产底座 这种重度治理的设计看似复杂，让人误以为 Tavant 自研了一整套专有的封闭式智能体引擎，但实情恰恰相反。该体系完全构建在诸如 Claude 等基础模型的原生能力之上。所有的工作流规则、执行脚本、领域工具、交互钩子（Hooks）以及子智能体设定，本质上都是以外围规格配置（Specifications）的形式注入到 Claude Code 等原生运行环境中的。 这种架构赋予了企业极强的抗技术迭代风险能力。当 Anthropic 或其他前沿实验室推出更强大的下一代基础模型时，企业不需要对既有的软件工程体系伤筋动骨，只需在底层像换插头一样接入更先进的新模型，上层的既定规格与安全护栏直接无缝继承并立即生效运行。 - **原生技术适配**：深度复用基础模型的原生 Tool use、Skills 机制与 Sub-agents 机制。 - **解耦防过时**：上层治理规格与底层大模型完全解耦，确保第一时间享受前沿模型的降本增效收益。 --- ### [18:01](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=1081s) 总结与展望：用属于自己的规范重塑企业软件命运 在演讲的尾声，Olav Laudy 进行了精炼的战略总结：这套由智能体赋能的平台架构，从根本上颠覆了以往企业必须在外购受限与自研高耗之间艰难妥协的技术定势。 通过将规范定义（Specs）转化为最核心的企业级数字资产，企业不再被动依附于强势软件供应商“要么接受平庸、要么承担巨额定制成本”的单向条款；依托底层开放技术平台与 AI 编码团队，企业获得了在自己云端灵活组装、随时演进复杂业务系统的能力。最终，软件的资产控制权与进化主导权被重新交还给企业自身。演讲在现场观众的掌声中结束，并随即进入热烈的现场提问环节。 ## Notable quotes > [00:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=4s) 推倒重写一套运行了 20 年的旧系统堪称是一场“可怕的折磨（a horrible exercise）” — Olav Laudy > [09:20](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=560s) 我们曾经做过深入实验，得出的结论是：我们不可能凭空造出一个比科技大厂更强悍的原生编码智能体。 — Olav Laudy > [12:14](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=734s) 只需把业务规范往 AI 编码器里随手一扔，按下按钮就能自动运行生成一整套复杂的数据科学系统……这是通向灾难的配方（A recipe for disaster）。 — Olav Laudy > [13:45](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=825s) 实际编写代码仅仅发生在阶段 6（倒数第二步）。 — Olav Laudy > [17:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=1024s) 所有的工作流规则、执行脚本、领域工具、交互钩子（Hooks）以及子智能体设定，本质上都是以外围规格配置（Specifications）的形式注入到 Claude Code 等原生运行环境中的。 — Olav Laudy > [17:04](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=1024s) 企业不需要对既有的软件工程体系伤筋动骨，只需在底层像换插头一样接入更先进的新模型，上层的既定规格与安全护栏直接无缝继承并立即生效运行。 — Olav Laudy > [18:01](https://www.youtube.com/watch?v=iJ3xEwtU83M&t=1081s) 通过将规范定义（Specs）转化为最核心的企业级数字资产，企业不再被动依附于强势软件供应商“要么接受平庸、要么承担巨额定制成本”的单向条款。 — Olav Laudy ## Mentioned Olav Laudy, Tavant, Claude Code, OpenAI Codex, Kimi 3, Salesforce, Palantir, Anthropic, App Modernizer, Ignite ## Video description Olav Laudy - Head of AI Consulting, Tavant What if the most consequential AI decision is not which model, tool, or vendor you select, but which software path you commit your organization to for years to come? In my work with enterprise technology leaders, I see organizations navigating a growing range of options—from buying SaaS and extending established platforms to adopting AI-native or low-code platforms and developing custom solutions on the cloud. Each path can be the right choice, but each carries tradeoffs that are often underestimated, including customization pressure, escalating ecosystem costs, governance challenges, architectural constraints, engineering continuity, and vendor lock-in. In this session, I will examine where each approach works best, the common failure modes leaders should anticipate, and how AI coding agents are changing the economics and speed of custom development without replacing the need for strong architecture, domain expertise, governance, and long-term ownership. Attendees will also learn how a hybrid approach—combining an open technology foundation, modular domain products, and AI-powered development tools—can deliver the acceleration of a platform while preserving flexibility, architectural control, and a path away from permanent vendor dependency. Join me for a practical, candid discussion designed to help CIOs, CAIOs, and technology leaders make the software decision that will shape how their organizations build, operate, and evolve. [Source](https://www.youtube.com/watch?v=iJ3xEwtU83M)

Source quotes

[0:04] Olav Laudy: 推倒重写一套运行了 20 年的旧系统堪称是一场“可怕的折磨（a horrible exercise）” [9:20] Olav Laudy: 我们曾经做过深入实验，得出的结论是：我们不可能凭空造出一个比科技大厂更强悍的原生编码智能体。 [12:14] Olav Laudy: 只需把业务规范往 AI 编码器里随手一扔，按下按钮就能自动运行生成一整套复杂的数据科学系统……这是通向灾难的配方（A recipe for disaster）。 [13:45] Olav Laudy: 实际编写代码仅仅发生在阶段 6（倒数第二步）。 [17:04] Olav Laudy: 所有的工作流规则、执行脚本、领域工具、交互钩子（Hooks）以及子智能体设定，本质上都是以外围规格配置（Specifications）的形式注入到 Claude Code 等原生运行环境中的。 [17:04] Olav Laudy: 企业不需要对既有的软件工程体系伤筋动骨，只需在底层像换插头一样接入更先进的新模型，上层的既定规格与安全护栏直接无缝继承并立即生效运行。 [18:01] Olav Laudy: 通过将规范定义（Specs）转化为最核心的企业级数字资产，企业不再被动依附于强势软件供应商“要么接受平庸、要么承担巨额定制成本”的单向条款。

Source quotes

[0:04] Olav Laudy: 10 times as efficient [0:04] Olav Laudy: horrible exercise [12:14] Olav Laudy: recipe for disaster [0:04] Olav Laudy: unplatforming [12:14] Olav Laudy: Discovery [12:14] Olav Laudy: Intent Extraction & Parsing [12:14] Olav Laudy: Requirement Mapping [12:14] Olav Laudy: Architectural Blue-printing [12:14] Olav Laudy: Test & Validation Scaffolding [12:14] Olav Laudy: Code Synthesis [12:14] Olav Laudy: Deployment & Runtime Verification

Original transcript

[0:04] Good afternoon everyone. Um very interesting  discussions so far this morning. I I hear a lot of [0:11] uh buy versus built discussions and that's exactly  the topic of this talk. Uh I work at Tavant. We're [0:18] an AI engineering company. We have a number of SAS  products and uh we've been thinking really hard [0:25] how to basically take the AI coding assistance  kind of create a hardened like harness around that [0:35] and then produce uh custom software and I hope  to share that with you how how we're doing that. [0:44] So um look it it all starts with the idea  that that AI coding assistants make uh [0:52] dev work 10 times as efficient. That's at least  we hope for. That's what we're told. Right [0:59] now with that we're also seeing that uh a lot of [1:05] automation needs to happen within the enterprise.  So not only uh do we automate the existing tasks, [1:12] we need to take workflows and make them  agentic. So there's a lot of work there. [1:18] Then um the the companies that we work with  uh typically in in fintech lending space [1:26] but also manufacturing they have a lot of legacy  applications and actually for the first time now [1:33] we see there's a a good opportunity to use those  coding agents to do legacy modernization. So [1:41] it becomes feasible. Before that, it was  like basically a horrible exercise to take [1:47] something that was built 20 years ago and to  kind of throw that overboard and start over. [1:53] Then what we see in the market there's  a lot of like unplatforming if you will, [1:59] right? the the the the bigger platforms they  they keep selling their massive uh instances [2:06] and now for the first time we we basically have  the opportunity to take pieces and maybe replace [2:13] them if we see that's feasible. Yeah. All with  this comes of course that you still need to govern [2:22] this all and that's that's a that's a challenge.  So if we're thinking about build versus buy, [2:31] then uh there's there's like a spectrum, right?  It's not just build and buy. Uh you have you [2:39] completely bu buy that that's one option. Then  there's extend, right? So you you buy and then [2:47] it doesn't completely fulfill your your  desire. So you you're going to extend it [2:52] a little bit. Uh then of course you have the AI  native platforms. I'll I'll come back to that a [2:57] little bit. Uh you have the low code platforms.  This is where citizen development happens [3:04] and people kind of build their own work streams.  And then finally yeah you have to completely [3:10] buy of a built decision. Now with that uh there's  a number of criteria that you can consider [3:19] choosing the one over the other. Like obviously  cost is one. If if you buy that's great but you [3:26] you you're basically hanging yourself up to  monthly cost. Uh although if you build it [3:33] you need to have the engineering team in house  that that builds that and then maintains that. [3:40] um towards the buy, you're going to have  some lock in, right? One way or another. [3:46] And uh that that can be good if you choose for  that, but it can also hinder you at a later [3:52] point if you decide to leave. Then basically the  innovation and agents kind of go hand in hand. [4:00] If you decide to buy, you're effectively  depending on the vendor's innovation capability. [4:08] But if you don't have that capability in house,  then that makes sense. But if you do want to [4:12] innovate and and you're dependent on what the your  your vendor of your software platform is offering, [4:19] that that can hinder you. Now, so altogether,  right, uh we we see a number of uh choices here. [4:29] So buy obviously is Salesforce, right? you you can  buy that that that works very well in in certain [4:37] uh in specific cases. Namely, if you want uh is  fast deployment and you have standard processes. [4:45] If you want to extend that platform, Dub works  um you you can leverage existing platform, [4:53] but then the question is how far do you  want to push that that customization [4:57] and suddenly you run the risk that you start to to  extend the platform for users it's not really for [5:05] and and overextending yourself to get there.  Now there's AI native platforms uh such as as [5:14] Palanteer. They're wonderful platforms and what  they come with is typically this this ontology or [5:20] the semantic layer and that's a wonderful thing  because it abstracts the data in a fashion that [5:26] business use uh business users or the the business  use of that data is enhanced through that ontology [5:34] layer. Now, of course, the the downside  of such a process is that you're kind of [5:41] hung up on the specific form of the ontology  that such an AI native platform offers. [5:49] Then you have your your low code platforms which  is great for for citizen development. It is fast [5:55] but you pay for that in flexibility. There  are certain things that you cannot do, [6:01] certain things that you you cannot extend into.  I would think that's mostly very useful for for [6:08] internal processes and potentially not so  much for for customerf facing processes. [6:14] And then finally, of course, you can build  your own uh which is a is a great alternative [6:20] if you have the capability in house to to to build  this and uh the the willingness to maintain this. [6:28] Um below you see the Tavon platform. I'm not  here to try to sell you that. But what we're [6:33] trying to do here is can we take basically  the positive aspects of buy and the positive [6:42] aspects of build and merge them together. So  in other words, is there an alternative? Now [6:51] we feel that alternative really became feasible  with the AI coding assistance. Right? you you have [7:00] we we generate code but not only code complete  pipelines deployments test cases everything right [7:08] then uh as there for for the modernization  case the the code refactoring at scale is [7:14] suddenly feasible and I'll I'll go in  detail uh on that a little bit later [7:20] um and of course the the the whole idea  is to compress the engineering task in [7:27] uh in in something that faster.  There's a human in the loop, [7:31] but the the actual coding, that's the the used  to be the tedious part, that's now sped up. [7:39] So, if we're thinking of this hybrid option  and you want to have some type of a platform [7:46] that gives you the features of of  buy, right, or the advantages of buy, [7:51] but also the advantages of build, what would that  be? Well, you might choice uh you may choose an an [7:58] open technology platform, right? So, don't lock  yourself in to something proprietary. Then, [8:06] if you think of your your your domain product,  think of that as a module that runs within a [8:14] larger platform. And that means it's pluggable,  right? It means that it is it is compartmentalized [8:21] and it runs on a larger underlying runtime  that can be reused for for various purposes [8:28] but your your domain product is is really  a component that that lives on top. [8:34] Then uh the AI tooling effectively creates  this agent factory if you will or AI factory [8:43] and that that's a set of builders that helps you  uh go from specs to a software product. Then of [8:53] course you you want to potentially run this in  your own cloud, right? You don't have to, but [8:58] you you you could. Uh one of the big advantages is  there's no no platform fee obviously and uh this [9:05] is a very important thing of owning software you  have access and you own the source code eventually [9:12] and that means that that once you get this uh you  you you can do with it whatever whatever you want. [9:20] So how would that work and this is kind of a  lightweight architecture diagram that shows how we [9:27] think about this. On the right side you have the  actual platform right. So u this platform as shown [9:34] runs on any cloud. It has a runtime that either  in this case we provide because we made a number [9:41] of choices but it can also be a runtime that is  a customer provided because they have already [9:48] they they have this in house and on this runtime  you have those components in in orange you see the [9:55] components that that we have built traditionally  in the in the lending space and in the in the [10:00] after sales space but also the components that you  now want to develop. Now, so far that is in a way [10:08] a very high abstraction of of how a platform  looks like. But the key is how do you build this [10:15] and that's being shown on the on the left side.  So underneath you see AI lab coding agents. [10:21] These are if you will vanilla coding agents  like cloth codes or codecs or uh even other like [10:30] Kimmy 3 in in certain agentic loops  and and whatever you can use there [10:37] we have experimented with this believe there's  no opportunity for us to kind of create a better [10:47] say agentic coding agent right as as than than  what is provided. But what we're doing on top [10:56] is build a harness, right? So rather than trying  to think that we can build a better coding agent, [11:04] we're kind of guiding this coding agent in such a  way that it it constrained via to our guard rails [11:13] uh to our governance process and I'll show you  that in a minute. Now that basically um is fed by [11:21] two specs right either the specs for the runtime  that that we provide which is recipes of okay this [11:29] is how a workflow should look like or this is this  is the rule engines that we use or the data setup [11:35] or the client specs right any software that the  client wants to build or have built and then you [11:41] have the two components on top right one is the uh  the runtime specific builders that takes the the [11:49] spec library from the uh from the Tavon platform  and creates the runtime and then we have the [11:56] Ignite factory that is a number of components I'll  show you that that basically take the client spec [12:04] and develop that into a a governed workflow  or AI agent or traditional piece of software. [12:14] So those AI agents we we developed a number  of them, right? So you have a uh for example [12:21] a data platform builder, you have an migration  assistant, uh you have an data science agent. Now [12:31] that those sound fantastic, right? And it sounds  like oh wow you have an you have your cloud code [12:37] or your AI coder and you just give it specs and it  will now build your data science product and that [12:46] is exactly what I want to show how we're doing  that because I feel at the moment there's a lot of [12:54] knowusion or orlarity around that. I still  believe that uh engineers are much needed, [13:02] right? and and these days the you rename your  engineers as forward deployed engineers uh as [13:09] to kind of signal that they take business specs  and with the help of AI coders they produce [13:16] say an AI model or they they produce uh the  artifacts that you're after but it is still [13:23] very much in the hands of the the the forward  deployed engineer on what's being coded so it's [13:30] not an AI I agent or a cloud code that you press  a button here's the specs and bof there it runs [13:37] that that is in our uh perception in our  experience basically an recipe for disaster. So [13:45] let let me show app modernizer right which is  one of those components how how does that work? [13:51] Now, first of all, we split this up in seven  different stages. And if you look at stage six, [13:59] this is the actual coding that happens. So  if you're if you're refactoring legacy code, [14:09] it's the one but last step that you start actually  writing code, right? And before that, there's a [14:15] wide number over there. There are six steps that  basically help you define what needs to be coded [14:23] and we feel that this process and we have done  this now a number of times with very good results. [14:29] This is the proper way of going from a spec  to code that actually runs well in deployment. [14:38] It starts with obviously discovery, right? And  then it creates the the extraction of the the [14:44] code in terms of intent. what needs to happen.  Not everything here is completely agentic, [14:52] right? There's components that that try to uh that  that have language parsers underneath. So, it's an [15:00] AI tooling that uses language part uh parsers as  as help or as input to those processes. Okay. So, [15:09] you see those seven stages, right? Now within  each stage you effectively have a process that [15:17] looks like this. You have your inputs the overall  project input the input of the previous stage [15:25] and that goes to your coding agent your executor  agent. So it it reads the specs and it decides [15:33] what to do. This happens in each of those seven  stages. Right? So in maybe in the first stage [15:38] discovery is like okay read all the powerpoints  or the existing documentation. In step six this is [15:45] we need to now produce code based on this map and  and this use case but once the output is produced [15:54] there's a spec there's an other agent that  verifies everything that's happened right and then [16:00] that happens in a loop. So this is if you will the  outer loop of the agentic coding. The inner loop [16:07] of the agentic coding is just what you're used  to in in codec or cloud code. It it goes and it [16:13] builds something. But here we explicitly define  this outer loop to to uh ensure that what is what [16:21] is intended to be built is being built. And all  that is kind of put together in in a hook or in in [16:28] a human in a loop that is yet a loop around that  to show okay is this indeed the intent and has the [16:39] verifier agent done its correct work. So again the  the agentic coder or the AI coder is not just left [16:48] alone and you press a button and it just produces  the modern code from a legacy application. Right? [16:54] There's a it's a very much kind of guided process  or governed process in order to get that result. [17:04] So then you can wonder okay that sounds very  involved and it sounds like you have now built [17:13] your own coding agent but in fact that's not the  case. We make use of the native capabilities of [17:22] those coding agents. And so if you take Claude for  example, you define your skills, you define your [17:29] your scripts in there, you define your tooling in  there, uh you define your your hooks, your your [17:36] sub aents. And so all these are in fact  specifications that live inside cloud code. Now, [17:45] whenever Enthropic comes with a better agent, that  is not a problem because you just kind of put the [17:52] better agent in there and it it uses the the specs  as defined here and you're you're good to run. [18:01] All right. So um concluding here I hope to have  kind of shown you how we think of like taking a [18:08] platform uh an aentically enabled platform that  now can be coded or can be created using specs. [18:19] Uh but those specs are not just like a one button  press and and there you go. Um the the the the [18:28] basically the the advantages here are you own  your own spec right? So you're no longer uh just [18:34] dependent on on a vendor who says like this is our  product either take or completely customize it. [18:41] Uh it runs on open technology. [snorts] um you  put build you build using your agents, right? [18:49] The the your AI coders are the the source of  the the coding. Um so you you compose without [19:00] having to hand over your complete uh build to a a  vendor and you it runs in your own cloud. Um, and [19:09] so with that, uh, uh, I think we have 38 seconds  left and, uh, I think there's room for a question.