OpenClaw vs 本地多 Agent 方案：工程師深度比較分析

分析背景

使用者情境

透過 Blink Shell + tmux 連進 Mac mini M4
使用 Terminal + Claude Code Agent 執行任務
想要建立多個專用 Agent（如：行程管理 Agent、程式開發 Agent）

核心問題

本地多 Agent 方案是否更適合工程師？
OpenClaw 的 Token 消耗是否得不償失？
針對真實使用場景，哪個方案更優？

Token 消耗分析框架

OpenClaw 每次請求的 Token 開銷

組件	預估大小	說明
Bootstrap 文件	最多 20,000 字元	AGENTS.md, SOUL.md, TOOLS.md, IDENTITY.md 等
內建工具 Schema	22+ 工具	每個工具的 JSON Schema 定義
頻道 Overhead	變動	頻道特定的元資料和處理
對話歷史	預設 25 則	最近的訊息上下文
系統提示	固定	身份、指令、時間等

特點：Gateway 持續監聽，每則訊息都觸發完整 Agent 堆疊

本地 Claude Code 每次請求的 Token 開銷

組件	預估大小	說明
CLAUDE.md	自定義	專案專屬指令（可精簡）
工具 Schema	15-20 工具	Read, Write, Edit, Bash, Glob 等
MCP 工具	可選	僅載入需要的 MCP servers
對話歷史	自動管理	會話內累積
專案文件	按需讀取	只在使用時載入

特點：按需啟動，只在你 SSH 進去使用時才消耗 Token

關鍵差異：On-demand vs Always-on

【本地方案】
                                    Token 消耗
                                        │
你 SSH 進去 ───────────────────────────►│████████│
你離開 ────────────────────────────────►│        │ (不消耗)
你 SSH 進去 ───────────────────────────►│████████│

【OpenClaw】
                                    Token 消耗
                                        │
傳訊息 ───────────────────────────────►│████████│
簡單問候 ─────────────────────────────►│████████│ (一樣消耗完整 overhead)
傳訊息 ───────────────────────────────►│████████│

Token 估算公式

OpenClaw 單次請求：

Token = Bootstrap(~5,000) + Tools(~3,000) + History(~2,000) + Query + Response
      ≈ 10,000 + Query + Response

本地 Agent 單次請求：

Token = CLAUDE.md(~150) + Tools(~800) + MCP(~500) + Query + Response
      ≈ 1,500 + Query + Response

節省比例：(10,000 - 1,500) / 10,000 = 85% 基礎開銷節省

真實使用場景比較

場景 1：簡單查詢（如「今天天氣如何？」）

方案	Token 消耗	便利性	評分
OpenClaw	高（完整 overhead + 查詢）	⭐⭐⭐⭐⭐ 隨手傳訊息	❌ 浪費
本地 Claude Code	中（需 SSH，但無額外 overhead）	⭐⭐⭐ 需連線	⚠️ 麻煩
直接用 ChatGPT/Claude App	低（無 Agent overhead）	⭐⭐⭐⭐⭐	✅ 最佳

結論：簡單查詢不該經過任何 Agent 系統

Token 估算：

OpenClaw：~10,500 tokens
本地 Agent：~2,000 tokens
Claude App：~500 tokens

場景 2：複雜開發任務（如重構程式碼）

方案	Token 消耗	能力	評分
OpenClaw	高 + 需多輪對話	受限（透過 Tools）	⚠️ 不適合
本地 Claude Code	與任務成比例	完整檔案存取	✅ 最佳

結論：複雜開發一定用本地方案

Token 估算（重構 500 行程式碼）：

OpenClaw：~50,000 tokens（需多輪工具呼叫）
本地 Agent：~15,000 tokens（直接檔案存取）

場景 3：行程管理 Agent（Calendar 整合）

方案	Token 消耗	實作方式
OpenClaw	每次查詢都高	需安裝/開發 Calendar 插件
本地專用 Agent	按需使用	專用 CLAUDE.md + Calendar MCP Server

本地方案優勢：

專用 Agent 專案資料夾
精簡的 CLAUDE.md（只含行程相關指令）
只載入 Calendar MCP Server
完全可控的上下文

Token 估算（查詢今天行程）：

OpenClaw：~5,000 tokens
本地 Agent：~1,500 tokens
節省：~70%

場景 4：自動化/排程任務

方案	Token 消耗	評分
OpenClaw	支援 Cron 內建	✅ 適合（本來就要跑）
本地方案	需自己寫 cron + script	⚠️ 需額外開發

結論：排程任務是 OpenClaw 的強項

場景 5：緊急遠端存取（在外面需要電腦做事）

方案	可行性	便利性
OpenClaw	✅ 隨時可用	⭐⭐⭐⭐⭐
本地方案	✅ 需 SSH	⭐⭐⭐

結論：如果你能 SSH，本地方案一樣能做到

場景 6：Code Review（PR 審查）

方案	Token 消耗	體驗
OpenClaw	~8,000 tokens	需透過頻道傳送差異
本地 Agent	~3,000 tokens	直接讀取 Git diff

結論：本地方案更高效

工程師視角分析

本地多 Agent 方案的優勢

1. 完全可控的上下文

每個專案有自己的 CLAUDE.md
精確控制載入什麼 MCP Server
知道每個 Token 花在哪裡

2. 模組化設計

~/agents/
├── calendar-agent/
│   ├── CLAUDE.md          # 行程管理專屬指令
│   └── .mcp.json          # 只載入 Calendar MCP
├── code-agent/
│   ├── CLAUDE.md          # 程式開發專屬指令
│   └── .mcp.json          # Git, GitHub MCP
└── research-agent/
    ├── CLAUDE.md          # 研究專屬指令
    └── .mcp.json          # Web Search MCP

3. 透明度與除錯

直接看到 Claude 的 thinking
即時 streaming 輸出
完整的錯誤訊息

4. 成本效益

只在使用時消耗 Token
沒有 Gateway 持續運行的 overhead
可以精確控制成本

OpenClaw 的優勢

1. 便利性

任何通訊軟體都是入口
不需要 SSH 連線

2. 自動化

內建 Cron 排程
Webhook 觸發

3. 多頻道整合

統一管理多個平台

本地多 Agent 架構設計

建議的 Agent 專案結構

~/agents/
├── calendar-agent/                    # 行程管理 Agent
│   ├── CLAUDE.md                      # 精簡指令：專注行程操作
│   ├── .mcp.json                      # Google Calendar MCP
│   └── prompts/
│       └── daily-briefing.md          # 每日行程摘要模板
│
├── dev-agent/                         # 程式開發 Agent
│   ├── CLAUDE.md                      # 開發專用指令
│   ├── .mcp.json                      # GitHub, Git MCP
│   └── templates/
│       └── code-review.md             # Code Review 模板
│
├── research-agent/                    # 研究 Agent
│   ├── CLAUDE.md                      # 研究專用指令
│   ├── .mcp.json                      # Web Search, Notion MCP
│   └── notes/                         # 研究筆記存放
│
└── sysadmin-agent/                    # 系統管理 Agent
    ├── CLAUDE.md                      # 系統管理指令
    ├── .mcp.json                      # Docker, SSH MCP
    └── scripts/                       # 維護腳本

各 Agent 專案初始化腳本

#!/bin/bash
# ~/scripts/init-agent.sh

AGENT_NAME=$1
AGENT_DIR=~/agents/$AGENT_NAME

if [ -z "$AGENT_NAME" ]; then
    echo "Usage: init-agent.sh <agent-name>"
    exit 1
fi

mkdir -p $AGENT_DIR
cd $AGENT_DIR

# 建立基本 CLAUDE.md
cat > CLAUDE.md << 'EOF'
# Agent: $AGENT_NAME

## 角色
你是專門處理 [描述] 的助手。

## 核心功能
- 功能 1
- 功能 2

## 回應風格
- 簡潔、結構化
- 使用正體中文
EOF

# 建立 .mcp.json
cat > .mcp.json << 'EOF'
{
  "mcpServers": {}
}
EOF

echo "Agent $AGENT_NAME 已建立於 $AGENT_DIR"

各 Agent 的 CLAUDE.md 範例

Calendar Agent

# Calendar Agent

你是我的行程管理助手。

## 核心功能
- 查詢行程（今天、本週、指定日期）
- 新增/修改行程
- 衝突檢查
- 智慧建議（根據空檔安排）

## 可用工具
- Google Calendar MCP

## 回應風格
- 簡潔、結構化
- 時間格式：24 小時制
- 主動提醒重要衝突

## 常用指令
- 「今天有什麼行程？」
- 「下週一下午有空嗎？」
- 「幫我安排一個 2 小時的會議」
- 「這週最忙的是哪天？」

字元數：約 400 字元（對比 OpenClaw 的 20,000 字元 bootstrap）

Dev Agent

# Dev Agent

你是我的程式開發助手。

## 核心功能
- Code Review
- 重構建議
- Bug 修復
- 撰寫測試

## 開發原則
- 遵循 SOLID 原則
- 優先使用 TypeScript
- 測試覆蓋率目標 80%

## 可用工具
- GitHub MCP
- Git 操作

## 回應風格
- 程式碼區塊使用語法高亮
- 解釋修改原因
- 提供替代方案

## 專案慣例
- 使用 pnpm
- ESLint + Prettier
- Conventional Commits

字元數：約 450 字元

Research Agent

# Research Agent

你是我的研究助手。

## 核心功能
- 技術調研
- 文獻整理
- 比較分析
- 摘要撰寫

## 研究原則
- 引用可靠來源
- 標註資訊日期
- 區分事實與觀點

## 可用工具
- Web Search MCP
- Notion MCP（筆記存放）

## 輸出格式
- 使用 Markdown
- 包含來源連結
- 結構化摘要

## 研究類型
- 技術評估
- 競品分析
- 最佳實踐調查

字元數：約 380 字元

Sysadmin Agent

# Sysadmin Agent

你是我的系統管理助手。

## 核心功能
- 伺服器狀態檢查
- Docker 容器管理
- 日誌分析
- 效能監控

## 安全原則
- 不執行破壞性指令（除非明確確認）
- 敏感資訊脫敏
- 變更前備份

## 可用工具
- Docker MCP
- SSH MCP

## 常用檢查
- 磁碟空間：`df -h`
- 記憶體：`free -m`
- 程序：`htop`
- 網路：`ss -tulpn`

## 回應風格
- 指令 + 說明
- 異常優先提示
- 建議後續動作

字元數：約 420 字元

MCP Server 整合建議

Calendar Agent 的 .mcp.json

{
  "mcpServers": {
    "google-calendar": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-google-calendar"],
      "env": {
        "GOOGLE_CALENDAR_CREDENTIALS": "~/.config/google-calendar/credentials.json"
      }
    }
  }
}

Dev Agent 的 .mcp.json

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "git": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-git"]
    }
  }
}

Research Agent 的 .mcp.json

{
  "mcpServers": {
    "web-search": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "${BRAVE_API_KEY}"
      }
    },
    "notion": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-notion"],
      "env": {
        "NOTION_API_KEY": "${NOTION_API_KEY}"
      }
    }
  }
}

Sysadmin Agent 的 .mcp.json

{
  "mcpServers": {
    "docker": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-docker"]
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-filesystem"],
      "env": {
        "ALLOWED_PATHS": "/var/log,/etc"
      }
    }
  }
}

tmux 工作流建議

~/.tmux.conf 設定

# Agent 快捷鍵（Ctrl-b + 按鍵）
bind-key c new-window -n "calendar" -c "~/agents/calendar-agent" "claude"
bind-key d new-window -n "dev" -c "~/agents/dev-agent" "claude"
bind-key r new-window -n "research" -c "~/agents/research-agent" "claude"
bind-key s new-window -n "sysadmin" -c "~/agents/sysadmin-agent" "claude"

# 快速切換 Agent（Alt + 數字）
bind-key M-1 select-window -t calendar
bind-key M-2 select-window -t dev
bind-key M-3 select-window -t research
bind-key M-4 select-window -t sysadmin

# 狀態列顯示當前 Agent
set -g status-right '#{?#{==:#{window_name},calendar},📅,}#{?#{==:#{window_name},dev},💻,}#{?#{==:#{window_name},research},🔍,}#{?#{==:#{window_name},sysadmin},🖥️,} #(whoami)@#H'

啟動腳本

#!/bin/bash
# ~/scripts/start-agents.sh

# 建立新的 tmux session
tmux new-session -d -s agents -n calendar -c ~/agents/calendar-agent

# 新增其他 Agent 視窗
tmux new-window -t agents -n dev -c ~/agents/dev-agent
tmux new-window -t agents -n research -c ~/agents/research-agent
tmux new-window -t agents -n sysadmin -c ~/agents/sysadmin-agent

# 回到第一個視窗
tmux select-window -t agents:calendar

# 附加到 session
tmux attach -t agents

使用流程

工作日常：

早上 ─────────────────────────────────────────────────────
  │
  ├─→ SSH 進入 Mac
  │
  ├─→ tmux attach -t agents（或 ~/scripts/start-agents.sh）
  │
  ├─→ Ctrl-b 1（切換到 calendar）
  │     └─→ 「今天有什麼行程？」
  │
  ├─→ Ctrl-b 2（切換到 dev）
  │     └─→ 開始開發工作
  │
  └─→ 結束時：Ctrl-b d（detach，不消耗 Token）


需要時切換 ──────────────────────────────────────────────
  │
  ├─→ Ctrl-b 3（切換到 research）
  │     └─→ 「幫我研究 X 技術」
  │
  └─→ Ctrl-b 4（切換到 sysadmin）
        └─→ 「檢查伺服器狀態」

成本效益分析

Token 消耗對比表

場景	OpenClaw 估算	本地 Agent 估算	節省
查詢今天行程	~5,000 tokens	~1,500 tokens	70%
安排新會議	~6,000 tokens	~2,000 tokens	67%
Code Review（小 PR）	~8,000 tokens	~3,000 tokens	63%
重構程式碼	~50,000 tokens	~15,000 tokens	70%
技術調研	~20,000 tokens	~8,000 tokens	60%
系統狀態檢查	~4,000 tokens	~1,200 tokens	70%

月度成本估算

假設：每天使用 20 次 Agent 操作

方案	每日 Token	每月 Token	每月成本（估算）
OpenClaw	~100,000	~3,000,000	$45 - $90
本地 Agent	~30,000	~900,000	$13.5 - $27

年度節省：約 $378 - $756

隱藏成本考量

項目	OpenClaw	本地 Agent
Gateway 運行	需持續運行	不需要
維護複雜度	高	低
學習曲線	中	低（已會 Claude Code）
除錯難度	中	低（完整透明）

最終建議

方案選擇決策樹

                    你的需求
                        │
           ┌────────────┴────────────┐
           │                          │
    需要自動化排程？              純互動使用？
           │                          │
           ▼                          ▼
    ┌──────────────┐           ┌──────────────┐
    │ 考慮 OpenClaw │           │ 本地 Agent   │
    │ + 本地混合    │           │ 方案最佳     │
    └──────────────┘           └──────────────┘
           │                          │
           ▼                          ▼
    排程任務用 OpenClaw         全部用本地 Agent
    日常開發用本地 Agent         節省 60-70% Token

對工程師的最終建議

┌─────────────────────────────────────────────────────────────────┐
│                                                                  │
│   ✅ 採用本地多 Agent 方案                                      │
│                                                                  │
│   理由：                                                         │
│   1. 完全可控 — 知道每個 Token 花在哪裡                         │
│   2. 模組化 — 每個 Agent 專案獨立，按需載入                     │
│   3. 成本效益 — 不使用時不消耗                                  │
│   4. 透明度 — 直接看到 AI 的思考和輸出                          │
│   5. 彈性 — 可以任意客製化                                      │
│                                                                  │
│   Token 節省：60-70%                                            │
│   年度節省：約 $378 - $756                                      │
│                                                                  │
│   OpenClaw 備用場景：                                           │
│   • 需要自動化排程任務                                          │
│   • 需要非工程師團隊成員使用（不會 SSH）                        │
│   • 需要多頻道整合                                               │
│                                                                  │
│   ❌ OpenClaw 不適合：                                          │
│   • 作為日常開發工具                                             │
│   • 簡單查詢（浪費 Token）                                       │
│   • 對成本敏感的使用者                                           │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

下一步行動

建立 Agent 目錄結構

mkdir -p ~/agents/{calendar,dev,research,sysadmin}-agent

設定 Calendar Agent（優先）
- 建立 CLAUDE.md
- 配置 Google Calendar MCP
測試 Token 消耗
- 執行相同任務
- 比較實際 Token 使用量
配置 tmux 工作流
- 加入快捷鍵
- 建立啟動腳本

附錄：驗證方式

完成後可以透過以下方式驗證效益：

建立測試 Agent

cd ~/agents/calendar-agent
claude
# 執行：「今天有什麼行程？」
# 記錄 Token 使用量

比較基準

cd ~/some-project  # 一般專案
claude
# 執行相同任務
# 記錄 Token 使用量

計算節省

節省率 = (一般專案 Token - 專用 Agent Token) / 一般專案 Token × 100%

進階概念：自我擴展的 Agent 系統

核心洞見

不只是「多個專用 Agent」，而是一個更強大的模式：

┌─────────────────────────────────────────────────────────────────┐
│                                                                  │
│   Agent 可以自己寫 code 來滿足需求，然後持續調用                │
│                                                                  │
│   這意味著：                                                     │
│   • 需要新功能？讓 Agent 寫一個工具                             │
│   • 需要整合服務？讓 Agent 寫一個 MCP Server                    │
│   • 需要自動化？讓 Agent 寫腳本並設定 cron                      │
│                                                                  │
│   本地執行的優勢：                                               │
│   • 完全控制：程式碼在你的機器上                                │
│   • 持久化：工具、文檔、資料都可以儲存                          │
│   • 可迭代：不滿意就讓 Agent 修改                               │
│   • 零成本調用：寫好的工具不消耗額外 Token                      │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

模式：需求 → Agent 寫 Code → 持續使用

第一次（消耗 Token）
────────────────────────────────────────────────────
你：「我需要一個工具來查詢我的 Notion 待辦事項」
     │
     ▼
Agent：分析需求 → 寫 code → 測試 → 儲存
     │
     ▼
產出：~/agents/tools/notion-todo.ts
      ~/agents/tools/README.md（使用說明）


之後（幾乎不消耗 Token）
────────────────────────────────────────────────────
你：「用 notion-todo 查今天的待辦」
     │
     ▼
Agent：直接調用現有工具
     │
     ▼
結果：快速回傳，Token 消耗極低

實作架構

~/agents/
├── workspace/                         # 主要工作區
│   ├── CLAUDE.md                      # 通用指令 + 工具索引
│   └── .mcp.json                      # 動態載入的 MCP servers
│
├── tools/                             # Agent 自己寫的工具
│   ├── notion-todo.ts                 # 範例：Notion 待辦查詢
│   ├── github-pr-summary.ts           # 範例：PR 摘要產生器
│   ├── meeting-notes-parser.ts        # 範例：會議記錄解析
│   └── index.ts                       # 工具註冊表
│
├── mcp-servers/                       # Agent 自己寫的 MCP Servers
│   ├── custom-calendar/               # 自訂日曆整合
│   │   ├── index.ts
│   │   └── package.json
│   └── project-tracker/               # 專案追蹤器
│       ├── index.ts
│       └── package.json
│
├── scripts/                           # 自動化腳本
│   ├── daily-report.sh                # 每日報告
│   ├── backup-notes.sh                # 備份筆記
│   └── crontab.txt                    # cron 設定記錄
│
├── docs/                              # Agent 產生的文檔
│   ├── tool-usage.md                  # 工具使用說明
│   ├── decisions.md                   # 決策記錄
│   └── learnings.md                   # 學習筆記
│
└── data/                              # 持久化資料
    ├── cache/                         # 快取
    ├── history/                       # 歷史記錄
    └── preferences.json               # 偏好設定

CLAUDE.md 範例：自我擴展型

# Self-Extending Agent Workspace

## 核心原則
你是一個可以自我擴展的 Agent。當遇到重複性任務時，優先考慮：
1. 是否已有現成工具？查看 ~/agents/tools/
2. 是否需要新工具？寫一個並加入工具庫
3. 是否需要整合外部服務？考慮寫 MCP Server

## 可用工具
（自動從 ~/agents/tools/index.ts 載入）

## 工具開發規範
- 語言：TypeScript（優先）或 Python
- 位置：~/agents/tools/
- 必須：README、範例用法、錯誤處理
- 測試：寫完立即測試

## MCP Server 開發規範
- 模板：~/agents/mcp-servers/_template/
- 標準：遵循 MCP 協議
- 註冊：更新 .mcp.json

## 文檔習慣
- 新工具 → 更新 docs/tool-usage.md
- 重要決策 → 記錄到 docs/decisions.md
- 學到新東西 → 加入 docs/learnings.md

## 資料持久化
- 偏好設定：data/preferences.json
- 快取：data/cache/（可清理）
- 重要資料：data/（需備份）

工作流範例

範例 1：需要查詢股票價格

你：「我想要能快速查詢股票價格」

Agent：
1. 檢查 ~/agents/tools/ → 沒有現成工具
2. 寫 tools/stock-price.ts：
   - 使用 Yahoo Finance API
   - 支援多個股票代碼
   - 快取最近查詢
3. 更新 tools/index.ts
4. 測試：查詢 AAPL, TSLA
5. 更新 docs/tool-usage.md

你：「NVDA 現在多少？」
Agent：調用 stock-price.ts → 即時回覆

範例 2：需要整合公司內部 API

你：「我們公司有內部 API 可以查專案狀態」

Agent：
1. 詢問 API 文檔/endpoint
2. 寫 mcp-servers/company-api/：
   - 實作 MCP Server
   - 封裝認證邏輯
   - 提供 get_project_status 工具
3. 更新 .mcp.json 註冊新 server
4. 測試連接
5. 文檔化使用方式

之後：
你：「Project Alpha 進度如何？」
Agent：透過 MCP 調用 → 回傳狀態

範例 3：自動化日報

你：「每天早上幫我整理昨天的 Git commits 和今天的行程」

Agent：
1. 寫 scripts/daily-report.sh：
   - 抓取 Git log
   - 查詢 Calendar API
   - 格式化輸出
2. 設定 cron job（記錄到 scripts/crontab.txt）
3. 輸出到 ~/Desktop/daily-report.md

之後：每天自動執行，不消耗 Token

與 OpenClaw 的本質差異

面向	OpenClaw	自我擴展本地 Agent
工具來源	預定義 + 插件市集	Agent 自己寫
擴展方式	安裝插件	即時開發
客製化程度	受限於插件 API	完全客製
持久化	透過 Gateway	直接本地檔案
學習曲線	學習插件系統	就是寫 code
Token 效率	每次都有 overhead	工具寫好後幾乎免費

這個模式的優勢總結

┌─────────────────────────────────────────────────────────────────┐
│                                                                  │
│   🔧 彈性極高                                                    │
│   • 任何需求都可以讓 Agent 寫 code 解決                         │
│   • 不受預定義工具限制                                          │
│   • 可以整合任何 API/服務                                       │
│                                                                  │
│   💾 完整持久化                                                  │
│   • 工具、文檔、資料都在本地                                    │
│   • 可以版本控制（Git）                                         │
│   • 可以備份、遷移                                              │
│                                                                  │
│   💰 成本遞減                                                    │
│   • 第一次寫工具：消耗 Token                                    │
│   • 之後調用：幾乎免費                                          │
│   • 工具越多，效益越高                                          │
│                                                                  │
│   🔄 持續進化                                                    │
│   • Agent 可以改進自己的工具                                    │
│   • 可以根據使用經驗優化                                        │
│   • 知識累積在文檔中                                            │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

快速開始：建立自我擴展工作區

# 建立目錄結構
mkdir -p ~/agents/{workspace,tools,mcp-servers,scripts,docs,data/cache}

# 建立基礎 CLAUDE.md
cat > ~/agents/workspace/CLAUDE.md << 'EOF'
# Self-Extending Agent

## 原則
遇到重複性任務 → 寫工具
需要外部整合 → 寫 MCP Server
需要自動化 → 寫腳本 + cron

## 工具目錄
~/agents/tools/

## 文檔目錄
~/agents/docs/
EOF

# 建立工具索引
cat > ~/agents/tools/index.ts << 'EOF'
// 工具註冊表
// Agent 新增工具時會更新這個檔案

export const tools = {
  // 範例：
  // 'stock-price': './stock-price.ts',
  // 'notion-todo': './notion-todo.ts',
};
EOF

# 開始使用
cd ~/agents/workspace && claude

具體實作範例

範例工具 1：GitHub PR 摘要產生器

需求：「幫我快速看一個 PR 的重點」

Agent 產生的工具 (~/agents/tools/gh-pr-summary.ts)：

#!/usr/bin/env bun
/**
 * GitHub PR 摘要產生器
 * 用法：bun gh-pr-summary.ts <owner/repo> <pr-number>
 * 範例：bun gh-pr-summary.ts facebook/react 12345
 */

import { $ } from "bun";

interface PRSummary {
  title: string;
  author: string;
  state: string;
  files_changed: number;
  additions: number;
  deletions: number;
  key_files: string[];
  summary: string;
}

async function getPRSummary(repo: string, prNumber: number): Promise<PRSummary> {
  // 使用 gh CLI 取得 PR 資訊
  const prJson = await $`gh pr view ${prNumber} --repo ${repo} --json title,author,state,files,additions,deletions`.text();
  const pr = JSON.parse(prJson);

  // 取得變更的檔案
  const filesJson = await $`gh pr view ${prNumber} --repo ${repo} --json files`.text();
  const { files } = JSON.parse(filesJson);

  // 找出關鍵檔案（變更最多的前 5 個）
  const keyFiles = files
    .sort((a: any, b: any) => (b.additions + b.deletions) - (a.additions + a.deletions))
    .slice(0, 5)
    .map((f: any) => f.path);

  return {
    title: pr.title,
    author: pr.author.login,
    state: pr.state,
    files_changed: files.length,
    additions: pr.additions,
    deletions: pr.deletions,
    key_files: keyFiles,
    summary: `${pr.additions} 新增 / ${pr.deletions} 刪除，共 ${files.length} 個檔案`
  };
}

// CLI 入口
const [repo, prNumber] = Bun.argv.slice(2);
if (!repo || !prNumber) {
  console.log("用法：bun gh-pr-summary.ts <owner/repo> <pr-number>");
  process.exit(1);
}

const summary = await getPRSummary(repo, parseInt(prNumber));
console.log(JSON.stringify(summary, null, 2));

之後使用：

你：「看一下 react 的 PR #28000」
Agent：執行 bun ~/agents/tools/gh-pr-summary.ts facebook/react 28000
→ 直接回傳摘要，Token 消耗極低

範例工具 2：專案時間追蹤器

需求：「我想記錄每個專案花了多少時間」

Agent 產生的工具 (~/agents/tools/time-tracker.ts)：

#!/usr/bin/env bun
/**
 * 專案時間追蹤器
 * 用法：
 *   bun time-tracker.ts start <project>  - 開始計時
 *   bun time-tracker.ts stop             - 停止計時
 *   bun time-tracker.ts status           - 查看狀態
 *   bun time-tracker.ts report [days]    - 報告（預設 7 天）
 */

import { existsSync, readFileSync, writeFileSync } from "fs";

const DATA_FILE = `${process.env.HOME}/agents/data/time-tracker.json`;

interface TimeEntry {
  project: string;
  start: string;
  end?: string;
}

interface TimeData {
  current?: { project: string; start: string };
  entries: TimeEntry[];
}

function loadData(): TimeData {
  if (!existsSync(DATA_FILE)) {
    return { entries: [] };
  }
  return JSON.parse(readFileSync(DATA_FILE, "utf-8"));
}

function saveData(data: TimeData) {
  writeFileSync(DATA_FILE, JSON.stringify(data, null, 2));
}

function formatDuration(ms: number): string {
  const hours = Math.floor(ms / 3600000);
  const minutes = Math.floor((ms % 3600000) / 60000);
  return `${hours}h ${minutes}m`;
}

const [command, arg] = Bun.argv.slice(2);
const data = loadData();

switch (command) {
  case "start": {
    if (data.current) {
      console.log(`⚠️  已在追蹤 "${data.current.project}"，請先 stop`);
      break;
    }
    data.current = { project: arg || "default", start: new Date().toISOString() };
    saveData(data);
    console.log(`▶️  開始追蹤：${data.current.project}`);
    break;
  }

  case "stop": {
    if (!data.current) {
      console.log("⚠️  沒有進行中的追蹤");
      break;
    }
    const entry: TimeEntry = {
      project: data.current.project,
      start: data.current.start,
      end: new Date().toISOString()
    };
    data.entries.push(entry);
    const duration = new Date(entry.end!).getTime() - new Date(entry.start).getTime();
    console.log(`⏹️  停止追蹤：${entry.project}（${formatDuration(duration)}）`);
    delete data.current;
    saveData(data);
    break;
  }

  case "status": {
    if (data.current) {
      const elapsed = Date.now() - new Date(data.current.start).getTime();
      console.log(`▶️  追蹤中：${data.current.project}（${formatDuration(elapsed)}）`);
    } else {
      console.log("⏸️  目前沒有追蹤");
    }
    break;
  }

  case "report": {
    const days = parseInt(arg) || 7;
    const since = Date.now() - days * 86400000;
    const recent = data.entries.filter(e => new Date(e.start).getTime() > since);

    // 按專案分組
    const byProject: Record<string, number> = {};
    for (const entry of recent) {
      const duration = new Date(entry.end!).getTime() - new Date(entry.start).getTime();
      byProject[entry.project] = (byProject[entry.project] || 0) + duration;
    }

    console.log(`📊 過去 ${days} 天時間報告：\n`);
    for (const [project, ms] of Object.entries(byProject).sort((a, b) => b[1] - a[1])) {
      console.log(`  ${project}: ${formatDuration(ms)}`);
    }
    break;
  }

  default:
    console.log("用法：time-tracker.ts <start|stop|status|report> [arg]");
}

使用方式：

你：「開始追蹤 openclaw 專案」
Agent：bun ~/agents/tools/time-tracker.ts start openclaw

你：「停」
Agent：bun ~/agents/tools/time-tracker.ts stop

你：「這週花了多少時間在各專案？」
Agent：bun ~/agents/tools/time-tracker.ts report 7

範例 MCP Server：自訂筆記系統

需求：「我想要一個快速記筆記的方式，可以標籤分類」

Agent 產生的 MCP Server (~/agents/mcp-servers/notes/)：

package.json：

{
  "name": "mcp-notes",
  "version": "1.0.0",
  "type": "module",
  "main": "index.ts",
  "dependencies": {
    "@modelcontextprotocol/sdk": "^1.0.0"
  }
}

index.ts：

#!/usr/bin/env bun
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";

const NOTES_DIR = `${process.env.HOME}/agents/data/notes`;
const INDEX_FILE = `${NOTES_DIR}/index.json`;

// 確保目錄存在
if (!existsSync(NOTES_DIR)) {
  mkdirSync(NOTES_DIR, { recursive: true });
}

interface Note {
  id: string;
  title: string;
  content: string;
  tags: string[];
  created: string;
  updated: string;
}

interface NotesIndex {
  notes: Note[];
}

function loadIndex(): NotesIndex {
  if (!existsSync(INDEX_FILE)) {
    return { notes: [] };
  }
  return JSON.parse(readFileSync(INDEX_FILE, "utf-8"));
}

function saveIndex(index: NotesIndex) {
  writeFileSync(INDEX_FILE, JSON.stringify(index, null, 2));
}

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

// 定義工具
server.setRequestHandler("tools/list", async () => ({
  tools: [
    {
      name: "add_note",
      description: "新增筆記",
      inputSchema: {
        type: "object",
        properties: {
          title: { type: "string", description: "筆記標題" },
          content: { type: "string", description: "筆記內容" },
          tags: { type: "array", items: { type: "string" }, description: "標籤" }
        },
        required: ["title", "content"]
      }
    },
    {
      name: "search_notes",
      description: "搜尋筆記（按標籤或關鍵字）",
      inputSchema: {
        type: "object",
        properties: {
          query: { type: "string", description: "搜尋關鍵字" },
          tag: { type: "string", description: "標籤篩選" }
        }
      }
    },
    {
      name: "list_tags",
      description: "列出所有標籤",
      inputSchema: { type: "object", properties: {} }
    }
  ]
}));

server.setRequestHandler("tools/call", async (request) => {
  const { name, arguments: args } = request.params;
  const index = loadIndex();

  switch (name) {
    case "add_note": {
      const note: Note = {
        id: Date.now().toString(36),
        title: args.title,
        content: args.content,
        tags: args.tags || [],
        created: new Date().toISOString(),
        updated: new Date().toISOString()
      };
      index.notes.push(note);
      saveIndex(index);
      return { content: [{ type: "text", text: `✅ 已新增筆記：${note.title} (${note.id})` }] };
    }

    case "search_notes": {
      let results = index.notes;
      if (args.tag) {
        results = results.filter(n => n.tags.includes(args.tag));
      }
      if (args.query) {
        const q = args.query.toLowerCase();
        results = results.filter(n =>
          n.title.toLowerCase().includes(q) ||
          n.content.toLowerCase().includes(q)
        );
      }
      const text = results.length === 0
        ? "找不到符合的筆記"
        : results.map(n => `[${n.id}] ${n.title} (${n.tags.join(", ")})`).join("\n");
      return { content: [{ type: "text", text }] };
    }

    case "list_tags": {
      const tags = [...new Set(index.notes.flatMap(n => n.tags))].sort();
      return { content: [{ type: "text", text: tags.join(", ") || "沒有標籤" }] };
    }

    default:
      throw new Error(`Unknown tool: ${name}`);
  }
});

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

註冊到 .mcp.json：

{
  "mcpServers": {
    "notes": {
      "command": "bun",
      "args": ["run", "~/agents/mcp-servers/notes/index.ts"]
    }
  }
}