Skip to main content

从哪里开始：用几天成为 Agentic AI Engineer，而不是用几个月

你没有几个月时间来学习 AI。好消息是：你也不需要几个月。每个人都从同一个地方开始：在浏览器里完成 8 门 Foundations 课程，不安装任何东西，无论你会不会写代码。然后你只做一个决定，是用 AI 来完成自己的工作，还是构建能替你工作的 AI，再沿着相应课程走下去。工程师是终点，不是前置条件。

这一节是从初学者走到能够交付的 Agentic AI Engineer 的最短路径。衡量单位是天，不是学期：几个小时内开始用 AI 产生价值，一个周末做出第一个 Digital FTE，用一个月专注的夜晚掌握完整 Agent Factory stack。

为什么是几天，不是几个月​

这个承诺听起来不可能，直到你看到背后的方法。它和任何人在背景不足的情况下进入一份新工作并活下来的方法一样。第一，先获得工作的整体图景。第二，找出真正做事时最关键的少数主题。第三，学习每个主题中日常最常用的 80%，然后开始工作，在实践中补齐剩下的部分，同时把参考资料放在手边。

学习一个新领域的两种方式对比。穷尽式：先想学完所有内容，结果几个月过去，精力耗尽，什么也没交付。80% 式：五个步骤，1 先获得总览，2 找出关键主题，3 学习有用的 80%，4 开始工作，5 在真实使用中补齐其余，最终交付成果。覆盖关键的 80%，先开始工作，让其余部分在真实使用中补齐。

如果一开始就试图学完每个主题的每个细节，你会花掉几个月。还没交付任何东西，就已经耗尽精力。我们的教学法建立在相反的理念上：先覆盖关键的 80%，让你开始工作，再让剩下的内容通过真实使用逐步补齐。本节中的每一门速成课都是按这个思路设计的。

这一节如何组织（从这里开始）​

你不是靠把所有内容都读完来学习这件事，而是靠走一条清晰路径来学习。所以这就是那条路径，也是你唯一需要记住的地图。它和侧边栏已经展示的地图相同：先是 Foundations，然后是 General Agents，再到 Personal Agent Harnesses，也就是每个人都给自己一个持久的个人 agent，然后在两条路线中选择一条，Mode 1 或 Mode 2，最后是 References & Companions。整件事都围绕中间的一个决定（选择哪种 mode）展开；在这个决定之前的所有内容，所有读者都共享。

把课程体系看作一张地图。一条共享主干自上而下贯穿：Foundations，然后是 General Agents，然后是 Personal Agent Harnesses（拥有一个持久 agent）。从 Personal Agent Harnesses 出发，路径到达一个「选择 mode」的分叉，分成两条路线：Mode 1，问题解决（把一个问题解决一次），以及 Mode 2，制造（构建一个能反复完成它的 worker）；两条路线最终在底部汇合到 References & Companions。分叉之前的一切都由所有读者共享；mode 才是那个最重要的决定。

先阅读 论纲。它有两个版本：一个面向技术和商业专业人士，一个面向完全初学者。这样，无论背景如何，每个人都能跟上。读完论纲后，接下来是 Foundations：语言模型究竟是什么、prompting、agentic 工作的两种文档语言、委托 AI 写你永远不用写的代码、把一项任务教给 AI 一次并连接到你的应用，以及学习如何在 AI 时代思考。每位读者都先完成这些课程，再选择自己的 mode。

从哪里开始？从浏览器开始。 你的前 8 门课程，也就是 Foundations，都在一个聊天标签页里完成：Claude.ai、ChatGPT 或 Gemini。不需要安装任何东西，也不要求你已经会写代码。大多数日常 AI 价值，本来就发生在这个浏览器标签页里。当工作需要你的真实文件时，你再升级到运行在自己机器上的 general agent，agentic work 的三层结构也从那里开始。

你需要的心智模型是：AI 时代的工作发生在三层中。你使用 general agents 解决问题。你构建 AI Workers 来完成专门工作。你把这些 Workers 组合成 AI-Native Companies。每一次专业协作都以同一种方式开始：由人来指挥一个 general agent。唯一的问题是选择哪一个 agent，而这取决于你想完成什么。

note

一个命名说明。 在本书中，AI Worker、Digital FTE 和 AI Employee 指的是同一个想法：一个在人工定义的政策之下完成真实工作的专门化 agentic system。强调商业价值时，我们使用 Digital FTE；强调实现时，我们使用 AI Worker；强调它在公司里的角色时，我们使用 AI Employee。如果遇到其他不熟悉的术语，请随时查阅 术语表。

这三层也是本节带你走过的弧线，从你现在的位置到它最终带你到达的位置：

从 Beginner 到 AI-Native Company Architect 的七阶段旅程，按三层结构用颜色区分。第 1 层，使用 general agent：阶段 1 Beginner，从 prompting 到 thinking 的八门 Foundations，全部在浏览器里完成（你在这里）；阶段 2 Agent User，在真实工作中指挥一个像 Claude Code 或 Cowork 这样的 general agent；阶段 3 Personal Agent Harnesses，拥有一个持久 agent（OpenClaw 或 Hermes），每个人都会在选择 mode 之前完成这一步。第 2 层，构建 AI Workers：阶段 4 Agent Builder，用 OpenAI Agents SDK 构建你的第一个 agent；阶段 5 Worker Builder，把那个 agent 变成持久的 Digital FTE。第 3 层，构建 AI-Native Company：阶段 6 Workforce Builder，用一个 control plane、招聘和一个 delegate 治理一支 workforce；阶段 7 AI-Native Company Architect，用 evals 证明每个 Worker 并部署到云端。大多数读者会停在阶段 4 或阶段 5。

你不必走完整条路。大多数读者会停在第 4 或第 5 阶段，而这已经足以支撑严肃的职业发展或第一个创业项目。如果你想继续，完整路径也在那里。

选择你的 mode​

把这个决定近距离看一遍：一边是使用 AI，一边是构建能为你工作的 AI。先在抽象层面做决定，再找到属于你的那一行。

论纲中的 general agent 使用的两种模式 一节，描述了人们实际使用通用 agent 的两种方式。Mode 1 适合想用 AI 做自己工作的人。Mode 2 适合想构建能替自己完成工作的 AI 的人。「Manufacturing」这个标签听起来很工业化，事实也确实如此：构建 Workers 和使用 Workers 是不同的学科。

有一件事不会因为这个决定而改变：每个人都会在 Foundations 之后立刻选择一个 general agent，也就是课程 12 或课程 10。Mode 决定会把你导向不同路线；它不决定你是否使用 general agent。你总会使用。

Mode 1 与 Mode 2 对比。在 Mode 1，问题解决中，你指挥一个 general agent，由 agent 完成工作；你用 AI 更快地完成自己的工作。在 Mode 2，制造中，你指挥一个 general agent，它构建一个 Worker，由 Worker 一次又一次地完成工作；你构建能替你工作的 AI。

Mode 1：问题解决Mode 2：制造
如果你想……就选它让 AI 帮助你更快完成工作构建替你完成工作的 AI Workers
适合谁任何人：工程师或知识工作者工程师，或与工程师配对的知识工作者
你的工具Claude Code/OpenCode 或 Claude Cowork/OpenWorkClaude Code/OpenCode 用于构建；课程页面先教你自己阅读的概念，然后你再让 agent 去构建
从哪里开始课程 12（工程师）或课程 10（知识工作者）课程 32：构建 AI Agents
你产出什么已完成的工作一个能够自行产出工作的 Worker
由什么治理问题解决七原则Agent Factory 的七个不变量

分叉之前的说明。 在选择 mode 之前，每个人都先完成一个共享步骤：给自己一个持久的个人 agent。这就是 Personal Agent Harnesses 这一节（OpenClaw 与 General Agents，课程 21，以及 Hermes 与 General Agents，课程 22）。它是共享路径上的一步，不是一种 mode：你先在这里构建自己的 agent，然后再选择 Mode 1 或 Mode 2。

关于 Mode 2 的说明。 general agent 的输出不是最终结果；它产出的 Worker 才会持续产生结果。开发者使用 Claude Code 来编写规格、构建并部署一个代码审查 Worker。财务分析师与工程师配对，使用 Claude Code 来编写规格，构建一个每月月末运行的结账流程 Worker。工具相同，纪律相同，领域不同。

你的起步路径​

如果 mode 选择器仍然显得抽象，下面是同一个决定的完全具体版本：选择与你匹配的那一行，从最左边的课程开始。每条路径都从通用 Foundations（课程 1–8）开始。

你是……你的起步路径第一个里程碑
完全初学者论纲 → 课程 1（AI 是什么）→ 课程 2（AI 素养）→ 课程 3（Prompting）→ 课程 4（Claude & ChatGPT 101）→ 课程 5（Markdown 与 HTML）→ 课程 6（你永远不用写的代码）→ 课程 7（Skills & Connectors）→ 课程 8（Thinking）基础打好；接下来选择下面的一种 mode
知识工作者Foundations（课程 1–8）→ 课程 10（Cowork）→ 课程 21 或 22（通过 coding agent 拥有自己的 harness）→ 课程 23（这是 agent 问题吗？）→ 课程 24（原则）用 AI 交付真实的知识工作
工程师Foundations（课程 1–8）→ 课程 12（Claude Code）→ 课程 21 或 22（拥有自己的 harness）→ 课程 32 → 课程 33（FTE）交付你的第一个 Digital FTE
劳动力构建者工程师路径，然后课程 37（Paperclip）→ 课程 40（Evals）→ 课程 41（Deploy）一个受治理并部署到云端的 AI workforce

课程​

你已经做出了选择，下面就是每一门课程。它们完全按照侧边栏的方式分组，并在完整列表之前标出最快路线和每个深度的大致时间。

tip

几门课程包含 Reader track：这是一条概念型、无需构建的路径，让你理解并指挥工作，而不是实现每一行代码。在提供该路径的地方使用它，交付 Digital FTE 的最快路线是 Foundations（课程 1–8）→ 课程 12 → 课程 32 → 课程 33 → 课程 40（Reader track），大约需要 15 小时的专注工作。剩余课程会把这个 Digital FTE 变成受治理的 workforce，但你不需要它们也能交付第一个。

**按深度估算总时间：**Mode 1（用 AI 产生生产力）约 8 小时 · Mode 2 最小路径（第一个 Digital FTE）约 15 小时 · Mode 2 完整路径（受治理 workforce）约 28 小时 · 完整掌握 Agent Factory 约 48 小时（包含云部署课程）。

所有人共享下面这 8 门 Foundations；之后，路径会按 mode 分开。

Foundations（所有人）​

  1. AI 究竟是什么 — 一个不需要数学和代码的心智模型，用来理解所有其他课程底下那台机器。9 个想法会解释：为什么语言模型是在预测而不是查找，为什么它错了也显得很确定，为什么它会数错 "strawberry" 里的字母，以及为什么它的能力是参差不齐的。先读这一课，后面每一次「它为什么会这样做？」都会有答案可对照。约 45 分钟。

  2. AI 素养（4D 框架） — 决定 AI 是否真正帮助你的四项人类能力，它们构成一个框架，而不是一袋技巧：委派，即 AI 应做什么、什么留给我；描述，即它需要知道什么；辨别，即返回的内容是否真的好；尽责，即这种使用是否负责任、由谁对结果负责。课程还介绍人与 AI 协作的三种模式：自动化、增强和自主代理，以及当你为他人构建时，四项能力如何分别变成规格、系统提示词、评估和治理。约 40 分钟，另有六个练习提示词。前置要求：课程 1。

  3. 2026 年 AI Prompting — 一门 45 分钟、13 个概念的入门课，讲解如何在 2026 年有效使用 ChatGPT、Claude 和 Gemini：上下文、推理模式、deep research、多模态，以及 AI desktop apps。它覆盖本书每一章默认你已经掌握的机制。

  4. Claude & ChatGPT 101 — 并排讲解你每天真正会使用的两个聊天工作区，用 9 个概念让你学会一套统一的使用纪律，而不是分别学习两个产品：模型层级与思考模式、附件实际上做了什么、把项目当作一条工作流的专属房间、instructions、memory 与 projects 的区别、artifacts 与 writing blocks、skills 与 plugins、connectors 与 apps 及两者底层共同采用的 MCP 标准、如何把问题路由到搜索、思考或深度研究，以及通过复现你已经知道答案的工作来赢得信任的验证循环。所有产品相关说法均已于 2026 年 8 月核实。约 35 分钟，另加 6 个练习 prompt。前置要求：课程 1–3。

  5. Markdown 进，HTML 出 — 一门 13 个概念的入门课，讲 agentic 工作的两种文档语言：写出对机器足够精确的 Markdown specs，包括 headings、lists、fences、links，以及带 grade-to-9 验证循环的 spec 骨架；同时要求得到对人足够丰富的 HTML 输出，外加把 artifact 变成可分享链接的发布阶梯。包含结尾的 prompts 在内，大约 90 分钟。前置要求：课程 3。

  6. 你永远不用写的代码 — 一门 13 个概念的入门课，讲如何让 AI 替你写、运行并验证你永远不会阅读的代码。哪些任务属于代码问题（Volume、Precision、Repetition、Files），如何写一份没有技术词汇的五段式 brief，如何强制计算而不是估算，如何验证一个你读不懂的结果，以及 AI 为你运行代码的 5 个界面：Claude.ai、Claude Code、OpenCode、Cowork 和 OpenWork。约 1 小时，加上 40 分钟结尾 prompts 和 4 个项目。前置要求：课程 3 和课程 5。

  7. Skills & Connectors — 一门无需写代码的入门课，讲两种把聊天框升级成同事的方式。Skill 让 AI 只学习一次任务，也就是一个 SKILL.md，只有当你的请求匹配时才加载，这样它每次都按你的方式工作；Connector 则通过 MCP 标准，让 AI 在安全、权限受限的范围内访问你的真实应用，例如 Drive、Gmail、Slack 或 tracker。什么时候用哪一种，如何使用内置版本，如何让 AI 构建你自己的版本（它会替你写文件），以及如何在同样 5 个界面中安全完成这些事，同时附带 ChatGPT 和 Gemini 的对应说明。适合会计、医生、营销人员、工程师和学生。包含结尾 prompts 和项目在内，约 75 分钟。前置要求：课程 3–6。

  8. AI 时代如何思考 — 这是一套认知纪律，用来区分真正从 AI 中获得价值的人和没有获得价值的人：什么时候该找 agent，什么时候不该找，以及如何框定问题，让 agent 真正帮得上忙。

General Agents（选择你的协作者）​

这些是你在后续每一种 mode 中都会指挥的通用 agent。工程师选择 coding agent；知识工作者选择 desktop co-working agent。两者在 Mode 2 中也会复用；它们不是 Mode 1 专属工具，而是每种 mode 之下的工具层。每个人都从 web 开始，然后路线立刻分岔：知识工作者直接学 Cowork；编程路线则先从 Open Source LLMs 开始，在笔记本、自己控制的服务器和云端三个规模运行开放模型，让你从一开始就看清底层。之后再学 Agentic Coding。无论选了哪一个 co-worker，都要再运行五种纪律：Spec-Driven Development、Loop Engineering、Harness Engineering、Graph Engineering 和 Trusting the Checker。先明确构建什么，再设计替你构建它的 loop；打造让 loop 值得信任的 harness；运行多个 loop 后给它们共享记忆；最后用 eval 证明中心的 checker。

  1. 网页上的 General Agents：你的第一个 general agent，无需安装，直接在浏览器标签页中驾驭。这门 12 个概念的课程带你了解 2026 年 7 月的网页工作界面（网页上的 Claude Cowork 和 ChatGPT Work）：远程 session 是什么、文件实际存在哪里（三层退出纪律）、connector 如何既提供触达能力又充当出口、审批如何到达手机、四步委派 loop，以及在没有任何设备在线时仍能运行的计划任务。它留下的长期能力是一种阅读视角：每种 agent 产品都由相同的六个部分组成，因此新工具只需半小时就能读懂。这是进入整节内容最平缓的入口；无论会不会编程，每个人都先在浏览器中从这里开始，再安装工具。

  2. Cowork 速成课：一门 90 分钟、15 个概念的 Claude Cowork 入门课，涵盖委派真实的桌面知识工作、自治阶梯、prompt-injection 防御，以及避免多数后悔的计划审查习惯。知识工作者进入 general-agent 工作方式的起点。

  3. 开源 LLM：你的笔记本、服务器或集群，以及云端：编程路线从这里开始，也从开放模型真正提供的完整选择开始。课程分为三个彼此独立的部分，每个规模一部分。**第 1 部分（本地，Ollama）：**在自己的设备上免费、离线启动模型，把 Claude Code 或 OpenCode 指向它，并面对每套本地配置都必须越过的两堵墙：足够强的模型和足够快的硬件。**第 2 部分（服务器，vLLM）：**在自己控制的 GPU 设备上提供同一个 Qwen3 8B，同时向两种 serving layer 发出 50 个并发请求，画出两条曲线，亲眼看到一个缓慢爬行，另一个持续上升。**第 3 部分（云端，OpenRouter）：**用相同的两个 agent 驾驭 Kimi K3、DeepSeek V4 Pro 等个人无法托管的前沿开放模型，再在三个规模前放置同一个 router。长期要记住的只有一句话：agent 是 harness 加可替换的大脑，而大脑只是一个地址。全文阅读需 2–4 小时；第 1 部分约 60–90 分钟，只需免费安装。提前驾驭过 coding agent 会有帮助；即使没有，一条命令也能替你安装，课程 12 会教你如何驾驭。开放模型进入编程路线的入口；与 Skills 速成课配套。

  4. Agentic Coding 速成课：Claude Code 和 OpenCode：一门 90 分钟、15 个概念的课程，带你了解 Claude Code 和 OpenCode。两者词汇相同，快捷键略有差异；skills 可以在两个工具之间顺畅迁移。工程师进入 general-agent 工作方式的起点。

  5. 网站设计速成课：一门 15 个概念的应用构建课，把你刚学会的一切用于一项真实工作：设计、验证并交付一个真正的客户网站，无论单页还是多页，都像精心制作而不是机器生成。它涵盖作为模型加载文件的审美规范、从免费照片到付费视频的四通道媒体流程、把截图当作测试，以及最终上线的 URL。你用 agentic machine 完成的第一个真实构建。

  6. Spec-Driven Development：一门 13 个概念的入门课，讲在生成「怎么构建」之前先就「构建什么」达成一致：项目 constitution、四个阶段（Research、Specify、Clarify、Build），以及同一套纪律在 claude.ai、Claude Code 和 OpenCode 中以三种方式运行。这是思考纪律，不是编码技能，所以非程序员也能运行。约 90 分钟，外加一个构建两次的 worked example 和 6 个动手项目。让你所选协作者变得可靠的纪律。

  7. 四层结构：这张包含 12 个概念的地图，解释这个领域反复争论的词，并且有意成为本节最短的课程。Prompt、context、harness 和 loop 不是四种任选其一的技能，也不是逐级攀爬的四级台阶；它们是四个层层嵌套的容器，每个容器都由自己的工作单元定义（一次 model call、一个 window、一个 beat、完整的一次 run）。你会学到每层的失败特征、maker beat 自身唯一的成功信号以及为什么任何 prompt 都修不好它、人类 gate 为什么是出口而不是暂停、Mode 1 和 Mode 2 中你实际拥有哪几层，以及 graph 应放在哪里（并不是第五层）。结尾是一组 8 案例诊断练习，并坦诚说明框架何时会妨碍你。最终收获是一种习惯：当 agent 浪费整个下午反复做同一件事时，你不再重写 prompt，而是追问究竟哪一层出了问题。约 50 分钟，无需安装。前置要求：课程 12 或 10；在课程 16（Loop Engineering）之前阅读。

  8. Loop Engineering：一门 15 个概念的入门课，讲从逐回合提示 agent，转向设计替你提示它的 loop。你会学习 loop 的六个部分：heartbeat、worktree 隔离、skill、maker–checker 子 agent 拆分、connector，以及在多次运行之间存活的 state spine；在 Claude Code 和 OpenCode 中各构建一次，再组合成一个从晨间分诊到 PR 的 loop。课程还涵盖作为一个 beat 固化主体的 dynamic workflows、让 loop 保持可负担的 cost-by-cadence 纪律，以及为什么持久的 skill 位于 loop 永远无法自动化的两端：意图与问责。约两小时阅读，构建则更久。前置要求：课程 12；直接建立在课程 14（Spec-Driven Development）和课程 15（四层结构）之上。

  9. Harness Engineering：一门 12 个概念的入门课，讲围绕模型、把原始智能变成可信 agent 的那一层：Agent = Model + Harness。内容包括组织每个 harness 界面的五个动词（约束、告知、验证、纠正、升级）、按影响范围排序的权限规则、让破坏从「禁止」变成「不可能」的 sandbox、自动检查工作的 hook、程序可验证的类型化输出、四种失败类别，以及把每次抓到的错误固化成永久修复的棘轮习惯。结尾会在 Claude Code 和 OpenCode 中端到端加固 Loop Engineering 的晨间分诊 loop，外加 8 个 harness 构建练习。约两小时阅读。前置要求：课程 12；直接建立在课程 16（Loop Engineering）之上。

  10. Graph Engineering：当一个 loop 不再够用时，这门 16 个概念的课程会教你为多个 agent 建立共享记忆。论点只有一句话：agent 会忘记，graph 不会。Agent 不再把所学留在随 session 消失的 transcript 中，而是写成有类型、有连接的记录。你始终保留两张图，绝不合并：记录工作的 commit DAG（Karpathy 的 autoresearch 和 AgentHub）与记录事实的 knowledge graph（Anthropic 的 Knowledge Graph Cookbook）。它涵盖按 schema 提取而不是训练 pipeline、保留凭据且可逆的 entity resolution，以及每条 edge 上的 provenance 规则。使用图时，只把受限 subgraph 交给 agent，绝不整体倾倒；让 checker 引用 edge，否则就要求提供，以「triple not found」替代「感觉不对」。第五部分加入 governance graph：单个 loop 失效的四种方式、发现指标博弈的 counter-metric，以及任何 loop 都不能争辩的 anchors。结尾把 Loop Engineering 的晨间分诊 loop 从 prose spine 升级为可查询的 graph，只用 3 个 JSON 文件、jq 和 pre-commit hook，不需要数据库；另有 8 个练习。课程也坦诚提出反方观点：大多数系统不该建 graph，并教你判断方法。核心内容约两小时，深入注释后约三小时。前置要求：课程 12；直接建立在课程 16 和 17（Loop 与 Harness Engineering）之上。运行第二个 loop 时再学；只有一个 loop 时跳过。

  11. 信任检查器：Evals 速成课：一门 12 个概念的课程，讲如何在实际运行规模下测试 tester，让「checker 说 PASS」变成一个可以辩护的数字。Agent 是一个分布，因此要评估通过率，而不是单次运行；一轮运行可以在三个深度评分（答案、动作、trace）；从真正抓到的失败构建 golden set（棘轮变成案例）；锚定 rubric，并用自己的盲评校准 judge；每次变更都把这套案例作为 regression gate，并定期运行以发现 drift；用密封 hold-out 抵御 Goodhart 定律，保持诚实。无需框架：只需一个案例文件夹、shell runner 和 jq，在 Claude Code 与 OpenCode 中均可运行，最后测试晨间分诊 reviewer 本身。约两小时阅读。前置要求：课程 12；直接建立在课程 17（Harness Engineering）之上。

  12. 离开笔记本：Runtime 速成课：一门 12 个概念的课程，讲 runtime 决策：已经赢得信任的 loop 应该运行在哪里，以及如何迁移而不丢失记录。一个问题整理所有选项：谁负责运营 loop，工作在哪里执行？答案有四种归宿：你的 session、云端计划（Routines 或计划 GitHub Actions）、托管 runtime（Claude Managed Agents），或你自己的 process。Headless mode 是每次迁移都要跨过的桥；最小无人值守套件让没有人盯着的 loop 保持诚实；行李箱测试区分可随迁的纪律与必须重建的机制；信任要在新环境重新赢得，而不是直接转移。四个问题决定归宿，影响范围决定迁移速度；Claude Code 与 OpenCode 都涵盖。阅读约 90 分钟，实际迁移更久。前置要求：课程 12；直接建立在课程 19（Trusting the Checker）之上，并收尾阶段 3 三部曲。

Personal Agent Harnesses​

这是「使用」一个 agent 和「选择一种 mode」之间的共享步骤。在这里，每个人都给自己一个持久的个人 agent：它在多次会话之间都记得你，并运行在你自己拥有的基础设施上，而不是每次聊天都从头开始。你通过指挥一个 coding agent（Claude Code 或 OpenCode）来构建它，由它替你完成安装；所以即使 Cowork 是你的日常工具，你也会把这个步骤交给一个 coding agent。先在这里拥有自己的 agent，然后再选择 Mode 1 或 Mode 2。

  1. OpenClaw 与 General Agents — 一门 90 分钟、6 个场景的动手课。你的 general agent 会安装并配置一个运行在 OpenClaw 上的 Personal AI Employee：从零开始，到手机上运行一个 AI Employee，包含一个自定义 skill、一个 MCP tool、一个 heartbeat task，以及最后的 ACP-spawn 演示，让这个 AI Employee 召唤自己的 coding agent。Karpathy 的「little skill」在这里被扩展。前置要求：课程 12。

  2. Hermes 与 General Agents — 一门 90 分钟、6 个场景的动手课。你的 general agent 会安装并运行 Hermes（Nous Research），这是一个以记忆为先、能自我改进的 harness：持久的跨会话记忆，让它把学到的东西在多次运行之间带着走；一个学习循环，会从它解决的难题里写出自己的 skill；model-agnostic，所以你不会被某个厂商锁定；而且全部运行在你自己拥有的基础设施上。它和课程 21 是同一个 Personal AI Employee 的想法，只是建立在一个为「把所学不断复利」而设计的 harness 之上。前置要求：课程 9；与课程 21（OpenClaw）配套。

Mode 1：问题解决路径​

Mode 1 是一段三门课程的弧线：诊断、解决、跨越。 你先判断一项任务是否真的属于 agent，以及它属于哪种 mode（课程 15）；再在一次会话里把它解决好（课程 16）；当一个解法被证明值得保留时，把它提升为一个永久 worker（课程 17，通往 Mode 2 的桥梁）。

  1. 这是一个 agent 问题吗？ — 在打开任何 agent 之前先做的十分钟分诊。三道关卡：这到底是不是一个 agent 该做的活（还是一个普通工具，或者一个只负责回答的 chatbot），你是只做一次还是每周都做（Mode 1 还是 Mode 2），以及「完成」到底长什么样？三道关卡、三个容易走错的弯、一条清晰的路；课程最后给出一张参考卡，把每个答案对应到 2026 年正确的工具。正是这门课，能让你不再把一整次会话浪费在一个本就不属于 agent 的任务上。面向初学者和国际读者。这是 Mode 1 的入口，也是它的第一页。

  2. 使用 General Agents 解决问题 — 一门 90 分钟、7 条原则的速成课，讲的是一种操作纪律：它能把任何 general agent，无论是 Claude Code、OpenCode、Cowork 还是 OpenWork，从聪明玩具变成能交付真实工作的工具。这 7 条原则适用于全部 4 种工具：Bash 是关键、代码是通用接口、验证是核心步骤、小而可逆的分解、把状态持久化到文件中、约束与安全，以及可观测性。课程还包含四阶段工作流：探索、计划、实现、提交，并配有综合练习。

  3. 从一次性任务到 Worker：交棒给制造 — 这座桥梁结束 Mode 1，开启 Mode 2。当一个你一直手动解决的任务已经经过充分验证、足以成为一个永久 worker 时，该如何把它提升上去：一个信号（方法已经不再变化）、四次提升（你的 brief → 一份 spec，你的肉眼检查 → 一个 eval，你在回路中 → 一条升级规则，你的会话 → 一个 runtime），以及一个分叉（拥有一个个人 harness，或者制造一个 Digital FTE）。它把 Mode 1 到 Mode 2 的跨越从悬崖变成可以一步迈过的台阶，并说明一个 worker 大多是提升出来的，而不是发明出来的。这是 Mode 1 的最后一页；它把工作交棒给 Mode 2 路径（从课程 26 起）。

Mode 2：制造路径​

首先有一个入口。下面每门课程都假设你能读懂 agent 写出的 Python，所以如果你从未写过代码，请在构建课程之前先从 AI 时代的 Python 开始。你的第一次构建发生在拥有 loop 之前：一个 connector-native app，也就是你部署的 server，由宿主的模型调用，而你还没有自己的 agent loop。从那里开始，制造路径通过 7 个动作端到端展开：构建 Agent，把它提升为 Employee，用 nervous system 连接 Employees，加入管理层，让招聘动态化，解放 founder，并用 evals 证明整个 workforce 可以被度量和信任。没有最后这一步，制造就无法被证明；你无法度量的 Workers，也无法真正交付。

阶段 1：构建模块​

  1. AI 时代的 Python — 一门「先读再写」的入门课，面向从未写过代码的人。你不是从空白页开始写 Python；你会学习如何阅读、预测、测试并验证 agent 生成的 Python，使用 PRIMM-AI+ 方法和 Test-Driven Generation（TDG）循环。17 个概念和 6 个小项目，配套 base 会把你的 agent 变成一个有纪律的 tutor。这是每门 Mode 2 构建课程默认需要的 literacy gateway。前置要求：课程 12。

  2. Connector-Native Apps — 预 loop 的构建课程：交付一个远程 MCP server，让 Claude 免费层用户只需粘贴一个 URL、点击一次 Authorize 就能添加，且发生在你写任何 agent loop 之前。14 个概念围绕 connector-native app 的四个不变量：一个 gateway、只用 tools、从已验证登录证明身份、fail closed，并通过一个 Reading Room 完整示例落地，包含 OAuth 2.1、双表 Postgres 记忆、session-init gate 和真实部署。host 带来模型和 loop；你的 server 带来 tools、state 和 identity。约 90–120 分钟阅读，一个专注日完成构建。前置要求：课程 12 和 25；Build AI Agents 在这条路径更靠后的位置，会把 loop 交给你。

  3. 为你的 AI 接入可检索的上下文：用 pgvector 在 Postgres 上构建 RAG — 一门 15 个概念的入门课，教你为 AI 接入可检索的上下文：你指挥你的 agent 把 Neon + pgvector 变成一个可用的 RAG 系统，包括 schema、一个 embedding worker、chunking、语义检索与混合检索、eval 驱动的检索，以及一个任何 agent 都能调用的只读 RAG MCP server。这是 Digital FTE 赖以构建的检索基础，出自同一个制造路径 base。约 90 分钟阅读，外加一次构建。前置要求：课程 12。

  4. 构建 Context Layer — 跳出你自己那一个 store 的范围跃迁。上一门课让一个 Worker 拥有了一个由你自己填充的可搜索 store；这一门课构建的是整支 workforce 都要读取的 corpus，而且它围绕一个真实的客户问题来构建，这个问题其实同时是四个专业问题。七个部分、15 个概念：一个已连接的数据源可能属于的四个类别，以及为什么把它们混在一起是代价最高的错误；部署 Onyx Standard 并从内部把它读懂；权限继承，以及那道你必须自己构建的 gate，因为 Community Edition 不会提供它，并用一个正确答案是「什么都不返回」的角色来测试它；把你的 Neon 记录通过 MCP 提供出去，让发现和确认始终是两次独立的调用；一份先于 prompt 写好的 authority-map.yaml；以及一个 Context Router，它每次都返回同样的七个 section 并附带引用，而且拒绝把一处冲突揉成一个让人舒服的「是」。课程最后会把整个构建端到端走一遍，用四种方式故意破坏它，给出一套八个维度的 eval 集合，以及一个 Context Gateway：它通过同一道 identity 边界，把同一份 corpus 提供给 Claude Code、OpenCode 和你的 Digital FTE。约两小时阅读，构建需要一个下午。

  5. 面向 AI Agents 的 Plugins — 构建并交付一个真实的 plugin，用它扩展一个你并不拥有的 AI agent（Claude Code 或 OpenCode），再看着同一个 bundle 一路带到 claude.ai。13 个概念，讲一个 agent plugin 的四个不变量，以及它的四个杠杆（一个 skill、一个 subagent、一个 MCP server、一个 hook），外加把建议变成保证的确定性 exit-2 guard。一个经过测试的 starter 带你从一个空文件夹走到一个队友只用一条命令就能安装的 plugin。它是 Connector-Native Apps 的镜像：在那里你扩展的是 chat app；在这里你扩展的是 coding agent。前置要求：课程 26。

  6. AI Identity：Human Sign-In 与 Agent Access — identity 与 access 层，分成两半：先掌控你自己的 sign-in（email 与 social login、sessions、two-factor，以及一个构建在 Better Auth 之上、签发真实 tokens 的 OAuth/OIDC server），再给一个 AI worker 它自己的 credential，以及一种受 scope 限定、有时限、可撤销、经人类批准的、代表某人行事的方式。贯穿始终的问题是：这是谁的 identity，authority 又如何从 human 传给 agent？human sign-in 今天已是 production-grade；agent identity 仍在稳定当中，所以这门课锚定在 durable primitives 上。前置要求：课程 26。

阶段 2：构建 Workers​

  1. 构建 AI Agents 速成课 — 一门 90 分钟、16 个概念的 OpenAI Agents SDK 入门课：agent loop、tools、sessions、streaming、handoffs、guardrails、tracing、day-1 evals、human approval、Cloudflare 上的 sandboxed deployment，以及用 DeepSeek V4 Flash 控制成本。前置要求：课程 12。

  2. 从 Agent 到 Digital FTE — 一场 4 小时工作坊，讲如何把基础 agent 变成持久 Worker：可移植 Skills、作为 system of record 的 Neon Postgres 与 pgvector、作为连接线的 Model Context Protocol、audit-trail 纪律、approval 作为授权模型，以及一个端到端构建的客户支持 Worker。15 个概念，8 个构建决策。15 分钟 Quick Win；90 分钟浏览 cheat sheet；完整构建大约再需要 3 小时。前置要求：课程 32。

  3. 从 Digital FTE 到带 Nervous System 的 Production Worker — 一门 90 分钟、15 个概念的课程，讲如何用 Inngest operational envelope 包裹你的 Digital FTE：durable execution、event-driven triggers、step memoization、concurrency and throttling、replay，以及 HITL gates。它会扩展客户支持 Worker，让它在网络抖动、重启和长期等待 approval 的情况下仍能存活。前置要求：课程 33。

阶段 3：扩展 Workforce​

  1. Human-Agent Teams：你的 Workforce 的运营模型 — 把人类和 Digital FTEs 当作一个团队来运行的运营模型：公开地工作、一份角色清晰的 roster、一个 north star，以及随可验证的可靠性一起增长的信任。无需写代码；你指挥你的 agent 起草八份运营文档（roster、role cards、north star、verification rubric、doer-verifier、weekly report、attention budget），最后带走一支真实团队的运营手册。在你的第一个 worker 出现之前，就能在 planning mode 下完成。前置要求：planning mode 需要课程 12；live mode 假设你已有一个 Digital FTE（课程 33）。

  2. 设计 Agent 体验：当软件开始自主行动后，设计工作随之发生变化，这门速成课讲的就是这种新设计技艺。Agentic 产品同时有两类用户：必须信任它的人，以及必须解析它的其他 agent。课程分为 4 部分、共 18 个概念（转变、人类信任界面、机器界面和新技艺），教你让 agent 的判断可理解、自治程度可调整、错误可承受。你会指挥 agent 为已经构建的一个 Digital FTE 起草 Agent Experience Brief，再在动手实验中使用官方 create-mcp-app skill，指挥 coding agent 交付一个 MCP App。约一小时的 Reader track 面向负责指挥工作、而不是亲自实现的领导者和设计师。与课程 35（Human-Agent Teams）配套：那门课编写团队的运营模型；这门课设计人类体验团队工作的界面。

  3. 使用 Paperclip 构建 Workforce — 一门 90 分钟、6 个场景的动手课。你的 coding agent 会启动 Paperclip（开源、MIT 许可的 AI-native company control plane），雇用一个无密钥本地 Worker，把一次 board approval 记录成永久审计决策，换入一个真正由 Gemini 支持的 Worker，让预算终于有可计费工作可以计量，并用一个 SQL 查询从 activity log 中重建整个公司历史。场景 1–4 和 6 不需要 API key；只有预算场景需要一个免费的 Gemini key。前置要求：课程 33 或课程 21。

  4. 从固定 Workforce 到动态 Workforce — 一场半天工作坊，包含 15 个概念和 7 个决策。课程从课程 37 的 workforce 出发，让它发现能力缺口、起草招聘提案，并让提案走过同一个 approval primitive；这个 primitive 也会管控一次 $500 退款。最后，它会在 Claude Managed Agents 上 provision 一个 Legal Specialist。招聘成为一个可调用函数。课程闭合不变量 6：workforce 可以在政策之下扩展。前置要求：课程 37。

  5. 从 Founder Bottleneck 到 Owner Delegate — 一场半天工作坊，包含 15 个概念和 7 个决策。workforce 的 owner 会在 OpenClaw 上配置一个 Owner Identic AI：它读取例行 Paperclip approval requests，清理落在已签署 delegated envelope 之内的请求，只把真正需要人的决策浮出水面。owner 是最后一个瓶颈；这门课把它移除。课程闭合不变量 2：每个人都需要一个 delegate。它还交付一个可下载的 lab starter zip，包含 mock endpoints、rules templates 和 sample judgment context。前置要求：课程 38。

  6. AI Employees 的 Eval-Driven Development — 这是闭合制造弧线的纪律，也包裹住课程 9 到 27 构建的一切。四条学习路径：Reader（约 3–4 小时，概念）、Beginner（约 1 天）、Intermediate（约 2 天）、Advanced（约 3 天，完整实现）。15 个概念加上一个 7 决策 lab。课程讲授九层 evaluation pyramid：unit、integration、output、tool-use、trace、RAG、safety、regression、production，以及填满它的四工具栈：OpenAI Agent Evals with trace grading、DeepEval、Ragas、Phoenix。终点是一个每位成员都可度量、可信任的 workforce，并配有每周一次的 trace-to-regression-test promotion ritual，让 eval suite 能持续活过数月。Reader track 面向领导者；Advanced track 面向交付团队。假设你使用 OpenAI Agents SDK 或 Claude Managed Agents runtime。

  7. 把你的 Agent Harness 部署到云端 — 这门课会把制造路径构建的一切真正交付出去。它讲授 harness/sandbox 分离：control plane（保存 secrets、运行 agent loop、保持 state 的 harness）与 execution plane（agent 生成代码实际运行的 sandbox）处在不同的安全边界中。你会部署一条完整生产路径：Azure Container Apps 上的 FastAPI 作为 harness，Neon Postgres 作为 durable state，Cloudflare R2 作为 files，一个 code-execution sandbox，四个 surface 的 observability，以及接入 CI gate 的课程 40 eval suite。四条学习路径：Reader 面向领导者和架构师；Beginner 到 Advanced 面向交付团队。课程包含 17 个概念和 9 个决策的 agent-driven lab；你的 coding agent 会阅读配套的 AGENTS.md，并在你的指挥下构建 harness。前置要求：课程 40（决策 8 会接入它的 eval suite）。Reader track 不需要云账号。

  8. 选择 Agentic Architectures — 一门关于模式选择的概念速成课：用关于任务的 5 个问题，把任务映射到 4 种核心模式之一（sequential workflow；single agent + ReAct + tools；planning + ReAct execution；multi-agent specialist），再把 reflection 作为可叠加层放在上面。纪律是按架构适配度选择，而不是按外观是否厉害选择：每种模式都是关于任务的一次押注；正确模式就是假设最符合现实的押注。课程讲授五问决策树、两种同样常见的失败模式（过度设计与设计不足）、暴露不匹配的 runtime signals，以及每种模式如何与你的 deployment topology 和 eval suite 组合。四条学习路径（Reader 约 2–3 小时，概念；Beginner 约 1 天；Intermediate 约 2–3 天；Advanced 约 4–5 天），一个五案例 decision lab，以及一份可打印的 classify-this-task worksheet，供设计评审使用。前置要求：你已经能够构建并评估 agents；本课会交叉引用 agent-building、operational-envelope 和 eval 课程。

  9. Payment-Enabled Agents：ACP、AP2、x402 和 MPP — 一门多路径速成课，讲让 agents 能够移动资金的四个协议：ACP 用于消费者购物，AP2 用于授权 mandates，x402 用于 HTTP-native machine payments，MPP 用于 session-based settlement。关键想法是：这四个协议是层，不是竞争者。你会读取 use case，按层选择协议（discovery、authorization、commerce、settlement），并把它们组合成 OpenAI Agents SDK code，同时使用 tool-input guardrail 在付款发生前拦住它。四条学习路径（Reader 约 2–3 小时，概念；Beginner 到 Advanced 面向交付团队），19 个概念，一个五决策 lab，以及三级 spend-limit 纪律，防止失控 agent 掏空钱包。前置要求：课程 32（OpenAI Agents SDK）；与课程 34（Inngest）和课程 41（云部署）配套。

References & Companions​

  1. 2026 年你应该使用哪些 AI Employees？ — 五种工具，按你的身份和需求匹配。不到一分钟找到你的起点。

  2. 速查表 — 本书关键工具的交互式快速参考卡片：Claude Code、Claude collaborative workspace 和 OpenClaw。

  3. Agentic Engineering 基础 — 一门 45 分钟入门课，讲支撑本节所有内容的工程纪律：如何以对待任何生产软件的严谨程度，设计、交付和运行基于 agent 的系统。对于任何准备走过课程 33 的读者，这都是可选配套阅读。

术语表 是你的另一位常驻伙伴。把它们都保持在浏览器标签页中。

完成后你会拥有什么​

到达本节末尾时，你不仅会理解 Agent Factory 论纲，还会真正围绕它构建过东西。你会使用 general agents 交付真实工作。你会部署至少一个不依赖你也能运行的 Digital FTE。你会把它连接到 nervous system，把它放进 Paperclip 治理的 workforce，看着这个 workforce 雇用自己的同事，并通过 Identic AI 把自己从瓶颈中解放出来。你会用自己写的 evals 包裹整个系统，所以你可以证明，而不是祈祷，每一个 Worker 都值得信任。

这就是本书与其他 AI 课程的不同：你结束时带走的不是笔记，而是一支能工作的 AI workforce。

而且这一节在你学完之后会继续有用：当你卡住时，上面的 References & Companions 就是你会回来查阅的资料。

本节之后的一切，都会细化你已经构建出来的东西。现在，选择你的 mode，然后开始。