OpenClaw Skill深度解析：与MCP的对比与选择

发表于 | 分类于 | 评论数： 0 | 阅读次数：

前言

在前几篇文章中，我们分别介绍了OpenClaw的整体架构、多Agent功能，以及Anthropic的MCP协议。今天我们来深入探讨OpenClaw的Skill系统，并将其与MCP进行详细对比。

这两个系统都试图解决同一个问题：如何扩展AI Agent的能力。但它们的设计理念和实现方式有着根本性的差异。

什么是Skill？

在OpenClaw中，Skill（技能） 是一种轻量级的扩展机制，用于教会Agent如何使用工具完成任务。每个Skill本质上是一个包含SKILL.md文件的目录：

1
2
3
4
5
6
7
skills/
├── summarize/
│   └── SKILL.md
├── browser/
│   └── SKILL.md
└── gemini/
    └── SKILL.md

Skill的核心结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
---
name: summarize
description: Summarize long texts using the summarize CLI
metadata:
  {
    "openclaw":
      {
        "emoji": "📝",
        "requires": { "bins": ["summarize"] },
        "install": [{ "kind": "brew", "formula": "summarize" }]
      }
  }
---

# Summarize Skill

When the user asks to summarize text:

1. Use `read` to get the file content
2. Run `{baseDir}/bin/summarize` with the text
3. Return the summary to the user

Use `{baseDir}` to reference the skill folder path.

Skill的加载位置

OpenClaw从三个位置加载Skill，优先级从高到低：

位置 说明 优先级
<workspace>/skills 工作区Skill 最高
~/.openclaw/skills 托管/本地Skill 中
Bundled Skills 内置Skill 最低

Skill的核心机制

1. Gating（门控过滤）

Skill可以在加载时进行条件过滤，决定是否启用：

1
2
3
4
5
6
7
8
9
10
11
12
13
---
metadata:
  {
    "openclaw":
      {
        "requires": {
          "bins": ["uv"],           // 需要二进制文件
          "env": ["GEMINI_API_KEY"], // 需要环境变量
          "config": ["browser.enabled"] // 需要配置项
        }
      }
  }
---

支持的过滤条件：

  • bins: 必须存在于PATH
  • anyBins: 至少一个存在
  • env: 环境变量必须存在
  • config: 配置项必须为真
  • os: 限定操作系统（darwin/linux/win32）

2. 环境注入

Skill可以注入环境变量和API Key：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// ~/.openclaw/openclaw.json
{
  skills: {
    entries: {
      "gemini": {
        enabled: true,
        apiKey: "YOUR_API_KEY",
        env: {
          GEMINI_API_KEY: "YOUR_API_KEY",
        },
      },
    },
  },
}

3. 热重载

OpenClaw支持Skill的热重载：

1
2
3
4
5
6
7
8
{
  skills: {
    load: {
      watch: true,
      watchDebounceMs: 250,
    },
  },
}

修改SKILL.md后，无需重启Gateway即可生效。

4. 安装器集成

Skill可以声明安装方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
---
metadata:
  {
    "openclaw":
      {
        "install":
          [
            { "kind": "brew", "formula": "gemini-cli", "bins": ["gemini"] },
            { "kind": "node", "package": "some-cli" },
            { "kind": "download", "url": "https://...", "archive": "tar.gz" }
          ]
      }
  }
---

支持的安装方式：

  • brew: Homebrew
  • node: npm/pnpm/yarn/bun
  • go: Go install
  • download: 直接下载

Skill vs MCP：设计理念对比

维度 OpenClaw Skill MCP
定位 Agent能力扩展包 通用协议标准
协议 无协议，直接加载 JSON-RPC 2.0
传输 无（本地文件） Stdio / HTTP
粒度 细粒度（单个能力） 粗粒度（完整服务器）
发现 自动扫描目录 手动连接 + */list
状态 无状态 有状态（生命周期）
扩展性 修改Markdown 实现完整服务器

设计哲学差异

Skill的设计哲学：

“简单至上，一个Markdown文件就是一个能力”

  • 轻量级：不需要写服务器代码
  • 零协议：直接在Agent进程中加载
  • 即插即用：放个目录就能用
  • 人类可读：直接编辑Markdown

MCP的设计哲学：

“标准化优先，通用协议连接一切”

  • 完整协议：JSON-RPC + 生命周期管理
  • 进程隔离：独立服务器进程
  • 跨应用：任何MCP客户端都能用
  • 企业级：支持认证、会话、流式

技术实现对比

Skill的执行流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
用户消息
    │
    ▼
┌─────────────────────────────┐
│   Gateway (同一进程)         │
│                             │
│  ┌─────────────────────┐   │
│  │ 加载 SKILL.md        │   │
│  │ 注入环境变量          │   │
│  │ 构建System Prompt    │   │
│  └─────────────────────┘   │
│                             │
│  ┌─────────────────────┐   │
│  │ Agent Loop          │   │
│  │ (调用内置工具)        │   │
│  └─────────────────────┘   │
└─────────────────────────────┘

特点：

  • 无进程间通信
  • 无序列化开销
  • 共享Agent上下文

MCP的执行流程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
用户消息
    │
    ▼
┌─────────────────────────────┐
│   MCP Host (AI Application)  │
│                             │
│  ┌─────────────────────┐   │
│  │ MCP Client          │   │
│  │ JSON-RPC over Stdio │───┼────┐
│  └─────────────────────┘   │    │
└─────────────────────────────┘    │
                                   │
                    ┌──────────────▼──────────────┐
                    │      MCP Server (独立进程)   │
                    │                             │
                    │  ┌─────────────────────┐   │
                    │  │ tools/call          │   │
                    │  │ 执行工具            │   │
                    │  └─────────────────────┘   │
                    └─────────────────────────────┘

特点：

  • 进程隔离
  • JSON-RPC序列化
  • 需要生命周期管理

Token开销对比

Skill的Token开销：

1
2
3
4
5
基础开销（有Skill时）: 195 chars
每个Skill: 97 chars + name + description + location

示例（3个Skill）:
≈ 195 + 3 × (97 + 20 + 50 + 30) = 732 chars ≈ 183 tokens

MCP的Token开销：

1
2
3
4
5
6
7
每个Tool需要完整描述:
- name
- description
- inputSchema (JSON Schema)

示例（3个Tool，每个inputSchema约200 chars）:
≈ 3 × (20 + 80 + 200) = 900 chars ≈ 225 tokens

Skill略轻量，但差异不大。关键是MCP的inputSchema通常更详细。

使用场景对比

什么时候用Skill？

✅ 适合Skill的场景：

  • 快速添加新能力（5分钟搞定）
  • 个人或小团队使用
  • 不需要跨应用共享
  • 能力相对简单
  • 不需要独立进程隔离
1
2
3
4
5
6
7
8
# 创建一个Skill只需要
mkdir -p ~/.openclaw/workspace/skills/my-tool
echo '---
name: my-tool
description: Do something cool
---

Instructions here...' > ~/.openclaw/workspace/skills/my-tool/SKILL.md

什么时候用MCP？

✅ 适合MCP的场景：

  • 需要跨多个AI应用使用（Claude Desktop、VS Code、Zed）
  • 企业级部署
  • 需要独立的认证和权限管理
  • 能力复杂，需要完整的服务器逻辑
  • 需要支持Sampling/Elicitation等高级特性
1
2
3
4
5
6
7
// 创建一个MCP Server需要
import { Server } from "@modelcontextprotocol/sdk/server/index.js";

const server = new Server({ name: "my-server", version: "1.0.0" });
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [{ name: "my-tool", description: "...", inputSchema: {...} }]
}));

深度对比：核心能力

1. 工具定义

Skill方式：

1
2
3
When user asks to search:
- Call the browser tool with URL https://google.com/search?q={query}
- Extract the results

特点：自然语言描述，灵活但不够严格

MCP方式：

1
2
3
4
5
6
7
8
9
10
{
  "name": "search",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string", "description": "Search query" }
    },
    "required": ["query"]
  }
}

特点：结构化定义，类型安全，自动验证

2. 状态管理

Skill：无状态，每次调用独立

MCP：有状态，支持：

  • 会话管理（Mcp-Session-Id）
  • 能力协商（initialize）
  • 动态通知（notifications/tools/list_changed）

3. 双向通信

Skill：单向（Agent → Skill指令）

MCP：双向

  • Sampling：Server可请求LLM补全
  • Elicitation：Server可请求用户输入

4. 安全模型

Skill：

  • 直接在Agent进程内执行
  • 共享Agent权限
  • 依赖沙箱隔离

MCP：

  • 进程隔离
  • 独立认证
  • 用户显式授权

实战：创建一个Skill

场景：翻译助手

1
mkdir -p ~/.openclaw/workspace/skills/translator

SKILL.md:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
---
name: translator
description: Translate text between languages
metadata:
  { "openclaw": { "emoji": "🌐" } }
---

# Translator Skill

When user asks to translate text:

1. Identify source and target languages
2. Use your built-in translation capability
3. Return the translated text

Example commands:
- "Translate this to Japanese: Hello World"
- "把这段话翻译成英文"

就这么简单！无需编写任何服务器代码。

实战：创建一个MCP Server

同样的翻译功能，用MCP实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// server.ts
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({
  name: "translator-server",
  version: "1.0.0"
}, {
  capabilities: { tools: {} }
});

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [{
    name: "translate",
    description: "Translate text between languages",
    inputSchema: {
      type: "object",
      properties: {
        text: { type: "string", description: "Text to translate" },
        targetLang: { type: "string", description: "Target language code" }
      },
      required: ["text", "targetLang"]
    }
  }]
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { text, targetLang } = request.params.arguments;
  // 调用翻译API...
  return { content: [{ type: "text", text: translatedText }] };
});

const transport = new StdioServerTransport();
await server.connect(transport);

明显更复杂，但换来的是：

  • 类型安全
  • 跨应用兼容
  • 独立部署

ClawHub：Skill生态

OpenClaw提供了 ClawHub 作为公开的Skill注册中心：

  • 网址：clawhub.com
  • 浏览、安装、更新Skill
  • 一键安装：clawhub install <skill-slug>
  • 批量更新：clawhub update --all

这类似于：

融合：OpenClaw对MCP的支持

OpenClaw并不排斥MCP，事实上它可以作为MCP Host连接MCP Server：

1
2
3
4
5
6
7
8
9
10
11
{
  mcp: {
    servers: {
      "github": {
        command: "mcp-server-github",
        args: [],
        env: { GITHUB_TOKEN: "..." }
      }
    }
  }
}

这意味着你可以在OpenClaw中：

  • 使用Skill进行轻量级扩展
  • 同时连接MCP Server获取复杂能力
  • 两者并存，各取所长

决策指南

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
              ┌─────────────────────┐
              │ 需要扩展AI能力？     │
              └──────────┬──────────┘
                         │
          ┌──────────────┴──────────────┐
          │                             │
          ▼                             ▼
┌─────────────────┐          ┌─────────────────┐
│ 只在OpenClaw用？ │          │ 需要跨应用？     │
└────────┬────────┘          └────────┬────────┘
         │                            │
         ▼                            ▼
┌─────────────────┐          ┌─────────────────┐
│    用 Skill     │          │    用 MCP       │
└─────────────────┘          └─────────────────┘
         │                            │
         ▼                            ▼
┌─────────────────┐          ┌─────────────────┐
│ 5分钟搞定       │          │ 需要写服务器     │
│ Markdown即可    │          │ 但可跨应用复用   │
└─────────────────┘          └─────────────────┘

总结

特性 Skill MCP
上手难度 ⭐ 极低 ⭐⭐⭐ 中等
灵活性 ⭐⭐⭐⭐⭐ ⭐⭐⭐
跨应用 ❌ ✅
类型安全 ⭐⭐ ⭐⭐⭐⭐⭐
进程隔离 ❌ ✅
双向通信 ❌ ✅
企业级 ⭐⭐ ⭐⭐⭐⭐⭐
个人使用 ⭐⭐⭐⭐⭐ ⭐⭐⭐

我的建议：

  • 个人开发者：优先用Skill，快速迭代
  • 团队/企业：核心能力用MCP，确保标准化
  • 混合场景：Skill处理小需求，MCP处理大能力

OpenClaw的Skill系统代表了极简主义的扩展哲学，而MCP代表了标准化的企业级方案。两者并非对立，而是为不同场景提供了合适的工具。

相关链接：

感谢你的阅读，如果文章对你有帮助，可以请作者喝杯茶!