2024 年 3 月，一个叫 OpenClaw 的项目在 GitHub 上发布了第一个 commit。两年后，它拥有了 247K Star、1.3 万个社区 Skill、被 Microsoft 选为 Build 2026 大会发布的 Scout Agent 的底层引擎。这篇文章不是教你装 OpenClaw——那在第 4 篇。这篇文章是让你理解：它到底是什么，为什么增长这么快，以及它对你的日常工作意味着什么。

---

OpenClaw 是什么

一句话：OpenClaw 是一个多 Agent 编排框架。它不替代 Claude Code 或 ChatGPT——它在它们的"上一层"工作。如果说 Claude Code 是一个程序员，OpenClaw 就是管理一群程序员的项目经理。

             ┌─────────────────────────────────┐
             │         OpenClaw（编排层）        │
             │  ┌─────────┐  ┌─────────┐       │
             │  │ Agent A │  │ Agent B │  ...  │
             │  │ (Coder) │  │(Reviewer)│       │
             │  └────┬────┘  └────┬────┘       │
             │       │            │             │
             └───────┼────────────┼─────────────┘
                     │            │
                     ▼            ▼
              Claude API    GPT API    DeepSeek API  ...
              （底层模型——OpenClaw 不绑定任何一家）

几个关键事实：

维度	详情
开源协议	MIT（完全自由使用、修改、商用）
语言	TypeScript（Node.js 生态，npm 安装）
支持的模型	Claude / GPT / Gemini / DeepSeek / 本地模型（Ollama）
安装方式	npm 全局安装 / Docker Compose / 源码编译
核心能力	Agent 集群、Worktree 隔离、共享记忆、ClawHub 市场
社区规模	247K GitHub Star、1.3 万+ ClawHub Skills

---

核心架构：Registry + Orchestrator + Worker

OpenClaw 的架构用三个角色概括：

                    ┌──────────────┐
                    │  用户/外部系统  │
                    └──────┬───────┘
                           │ 发送任务
                           ▼
                    ┌──────────────┐
                    │ Orchestrator │  ← 调度器："谁能做这个？"
                    │  (调度 Agent) │
                    └──────┬───────┘
                           │ 查询可用 Worker
                           ▼
                    ┌──────────────┐
                    │   Registry   │  ← 注册中心："我有哪些 Worker？"
                    │  (服务发现)   │     每个 Worker 的能力/状态/负载
                    └──────┬───────┘
                           │ 返回匹配的 Worker 列表
                           ▼
                    ┌──────────────┐
                    │ Orchestrator │  ← 分发任务给最合适的 Worker
                    └──┬───┬───┬──┘
                       │   │   │
              ┌────────┘   │   └────────┐
              ▼            ▼            ▼
        ┌─────────┐  ┌─────────┐  ┌─────────┐
        │Worker A │  │Worker B │  │Worker C │  ← 执行节点
        │(Coder)  │  │(Tester) │  │(Writer) │
        └─────────┘  └─────────┘  └─────────┘
              │            │            │
              └────────────┴────────────┘
                           │ 结果汇总
                           ▼
                    ┌──────────────┐
                    │ Orchestrator │  ← 汇总结果，返回给用户
                    └──────────────┘

三个角色的职责：

Registry（注册中心）—— "公司 HR 系统"
  - 每个 Worker 启动后到这报到："我是 Coder，用 Claude Sonnet，当前空闲"
  - 维护所有 Worker 的实时状态（在线/忙碌/下线）
  - 心跳检测：Worker 每 10 秒报一次"我还活着"，连续 3 次不报→标记下线

Orchestrator（调度器）—— "项目经理"
  - 接收任务："重构用户模块的支付逻辑"
  - 拆解：这个任务需要什么能力？→ Coder + Reviewer + Tester
  - 查询 Registry：现在有哪些 Worker 有空？
  - 分发：把子任务派给最合适的 Worker
  - 追踪：哪个 Worker 做完了？哪个卡住了？
  - 汇总：拼起来，返回完整结果

Worker（执行节点）—— "干活的"
  - 接收子任务：在自己的独立上下文中完成
  - 有自己的角色（System Prompt 定义）、自己的工具集、自己的模型
  - 做好后把结果返回给 Orchestrator
  - 不关心其他 Worker 在做什么（解除耦合）

这种架构的核心优势是关注点分离：每个 Worker 只在自己的领域内工作，上下文不会被无关信息污染。一个 Coder Worker 的 200K 上下文里全是代码相关的信息——不需要塞 API 文档规范、不需要塞测试策略、不需要关心前端组件怎么写。

---

五大核心能力

能力一：Agent 集群部署

开发环境（单机）：
  ┌─────────────────────────────────┐
  │ Docker（或直接 npm 运行）        │
  │  Registry + Orchestrator        │
  │  + 2-3 个 Worker                │
  │  全部在一个机器上                 │
  └─────────────────────────────────┘

生产环境（集群）：
  ┌────────┐  ┌────────┐  ┌────────┐  ┌────────┐
  │Worker 1│  │Worker 2│  │Worker 3│  │Worker 4│  ...可弹性扩缩
  └────┬───┘  └────┬───┘  └────┬───┘  └────┬───┘
       │           │           │           │
       └───────────┴───────────┴───────────┘
                           │
              ┌────────────┴────────────┐
              │   Redis（共享状态）       │
              │   Registry + Orchestrator│
              └─────────────────────────┘

两台 4 核 8GB 的 VPS 就能跑一个生产级的小集群。
后面第 9 篇会手把手搭这个集群。

能力二：并行 Worktree——多个 Agent 同时改代码不打架

这是 OpenClaw 的杀手级功能。原理是 Git Worktree：

一个 Git 仓库，创建多个独立的工作目录：

~/projects/my-app/              ← 主仓库（不动）
~/projects/my-app-worker-1/     ← Worker 1 的独立工作区（feature/payment）
~/projects/my-app-worker-2/     ← Worker 2 的独立工作区（feature/frontend）
~/projects/my-app-worker-3/     ← Worker 3 的独立工作区（test/payment）

每个 Worker 在自己的 Worktree 里修改代码 → 互不影响 → 完成后各自创建分支 → 逐个合并

传统方式（一个 Agent）：           OpenClaw Worktree：
  改 A 文件                        Worker 1: 改 A 文件 ─┐
  改 B 文件                        Worker 2: 改 B 文件 ─┤ 同时进行
  改 C 文件                        Worker 3: 改 C 文件 ─┘
  ...串行，30 分钟                  ...并行，8 分钟

冲突怎么办？OpenClaw 内置了冲突解决 Agent——当两个 Worker 改了同一个文件的不同位置，自动合并；改了同一位置，标记出来等人工处理。第 11 篇会深入讲。

能力三：共享记忆——Agent 之间传递知识

没有共享记忆：
  Worker A 在排查 Bug 时发现："数据库连接池默认值 5，高并发会耗尽"
  Worker B 不知道 → 又花了 20 分钟发现同一个问题

有共享记忆：
  Worker A 发现 → 写入 Shared Memory
  Worker B 启动 → 自动读取 Shared Memory → "已知：连接池默认值 5，需调大"
  → 直接跳过踩坑

OpenClaw 的三级记忆体系：

短期记忆（Redis）        中期记忆（SQLite）       长期记忆（Walrus/向量库）
─────────────────      ─────────────────      ─────────────────────
当前任务的上下文        跨会话的持久记忆         全局知识库
Agent 间实时传递线索    用户偏好 + 项目规则      所有 Agent 可检索
任务结束可丢弃          保留到手动清理            永久保留

能力四：ClawHub 技能市场——1.3 万个开箱即用的 Skill

就像 VS Code 的插件市场，但安装的是 Agent 的能力：

$ openclaw skill search "code review"
  返回：
  @clawhub/code-review     ⭐4.8  下载 125K  分级审查 + 修复建议
  @clawhub/security-scan   ⭐4.6  下载 89K   12 类安全漏洞检测
  @clawhub/pr-review       ⭐4.5  下载 67K   PR 自动审查 + 摘要
  ...

$ openclaw skill install @clawhub/code-review
  → Agent 自动获得代码审查能力
  → 不需要自己写 System Prompt + Checklist
  → 社区已经调好了最佳实践

这个市场的意义：你不需要从头设计 Agent 的 System Prompt 和工具集。社区已经有 1.3 万个经过实战验证的 Skill 模板。你只需要找到适合你的，安装，就能用。

能力五：原生 MCP 支持

Agent 启动时自动连接 MCP Server → Agent 的工具列表自动包含 MCP Tool

配置文件里一行搞定：
agents:
  coder:
    mcp_servers:
      - github      # 操作 Issue/PR
      - filesystem  # 跨项目文件读写
      - context7    # 实时文档查询
      - playwright  # 浏览器自动化

这让 Agent 的能力边界远超"写代码"——它可以操作 GitHub、浏览网页、读写任意文件、查询实时文档。

---

谁在用 OpenClaw

Microsoft Scout（Build 2026 发布）

Microsoft 在 Build 2026 大会上发布了 Scout——
一个企业级的 Autopilot Agent，底层就是基于 OpenClaw 构建的。

Scout 的能力：
  - 自动理解整个代码仓库的结构
  - 接收自然语言需求 → 自动拆解 → 分配给多个 Worker → 并行执行
  - 自动写代码 + 自动审查 + 自动测试 + 自动修复
  - 在 GitHub Issue 中直接协作（像一个虚拟的团队成员）

Microsoft 选择 OpenClaw 而不是自己从零造轮子，
说明这个框架已经过了"demo 阶段"，进入"企业可用"阶段。

NVIDIA OpenShell

NVIDIA 的 OpenShell 项目也使用了 OpenClaw 的多 Agent 编排能力，让多个 Agent 协作完成复杂的 GPU 编程任务。

社区生态

除了大厂，OpenClaw 的社区也非常活跃——Discord 上有 50K+ 成员，每天有大量新的 Skill 和 Plugin 提交到 ClawHub。

---

和 Claude Code 的关系

这是最容易混淆的地方，需要明确说清楚：

Claude Code = 一个 Agent，帮你写代码
  - 你打开终端，输入 claude，开始对话
  - 一个 Claude Code 实例 = 一个 Agent = 一个上下文窗口
  - 擅长：理解需求 → 写代码 → 跑测试 → 修复 → 验收

OpenClaw = 一群 Agent 的"管理层"
  - 你定义多个 Agent 角色（Coder/Reviewer/Tester/Writer...）
  - OpenClaw 负责任务分配、并行调度、结果汇总
  - 擅长：把大任务拆成小任务，让多个 Agent 并行干

两者的关系：
  ┌────────────────────────────────────────────┐
  │ OpenClaw（编排层）                          │
  │  告诉 Coder Agent 做什么                    │
  │  告诉 Reviewer Agent 审什么                  │
  │  汇总所有 Agent 的输出                      │
  └──────┬─────────────────────────────────────┘
         │ "Agent A 你写这个接口"
         ▼
  ┌────────────────────────────────────────────┐
  │ Agent A（可能是 Claude Code，也可能是 API）  │
  │  在自己的上下文中完成任务                    │
  │  返回代码 + 说明                            │
  └────────────────────────────────────────────┘

一个具体的类比：

• Claude Code = 你雇了一个自由职业程序员。他很能干，但一次只能做一个项目。
• OpenClaw = 你雇了一个技术主管，手下管着 5 个自由职业程序员。你把需求给技术主管，他负责分配、协调、汇总。

日常用法： 你在 Claude Code 里开发，遇到复杂任务（需要并行改多个模块、需要独立审查、需要写测试和文档）时，调用 OpenClaw 把任务外包出去。两者不是替代关系，是协作关系。

---

什么时候该用 OpenClaw

✅ 适合用 OpenClaw 的场景：

  1. 任务可拆解 + 互不依赖
     例：给项目加一个新功能——后端接口 + 前端组件 + 测试 + 文档
     → 4 个 Worker 同时做，15 分钟搞定

  2. 需要独立审查
     例：关键支付逻辑，AI 写的代码需要另一个 AI 严格审查
     → Coder 写 + Reviewer 独立审，不"放水"

  3. 需要长时间执行后台上任务
     例：下班前启动一个重构任务，第二天早上看结果
     → /goal 挂后台执行，Agent 自动工作整晚

  4. 有固定的多步骤工作流
     例：每次发版前：代码审查 → 安全扫描 → 跑测试 → 生成 changelog → 打 tag
     → 配置成流水线，一键触发

❌ 不适合用 OpenClaw 的场景：

  1. 修一个简单 Bug（改 3 行代码）
     → 启动 OpenClaw 集群的开销比修 Bug 还大

  2. 探索性编程（你不知道要做什么，边试边看）
     → 单 Agent 更灵活，随时调整方向

  3. 只有你一个人用的个人小工具
     → 没有并行需求，单 Agent 足够

一个简单的判断标准：

这个任务如果分配给你和 4 个同事一起做，会不会更快？
  会 → 用 OpenClaw
  不会（沟通成本 > 收益）→ 用 Claude Code

---

这篇文章的要点

1. OpenClaw 是一个多 Agent 编排框架（不是替代 Claude Code，是在它上层工作）

2. 核心架构：Registry（注册中心）+ Orchestrator（调度器）+ Worker（执行节点）
   → 每个 Worker 在自己的上下文中专注一件事

3. 五大核心能力：
   → Agent 集群部署（2 台 VPS 就能跑生产级集群）
   → 并行 Worktree（多个 Agent 同时改代码零冲突）
   → 共享记忆（Agent 之间传递踩坑经验）
   → ClawHub 市场（1.3 万+ Skill 开箱即用）
   → 原生 MCP 支持（一行配置扩展 Tool）

4. Microsoft Scout 基于 OpenClaw 构建——说明它已进入"企业可用"阶段

5. 判断标准：一个任务分给 5 个同事做会不会更快？
   会 → OpenClaw，不会 → Claude Code

---

延伸阅读

• OpenClaw GitHub
• OpenClaw 官方文档
• Microsoft Scout @ Build 2026
• ClawHub 技能市场