Skip to content

Instantly share code, notes, and snippets.

@lowkingshih
Created February 7, 2026 03:49
Show Gist options
  • Select an option

  • Save lowkingshih/c1f1a5e93ca314d8b08979b8f53b3060 to your computer and use it in GitHub Desktop.

Select an option

Save lowkingshih/c1f1a5e93ca314d8b08979b8f53b3060 to your computer and use it in GitHub Desktop.
OpenClaw 完整研究報告:架構分析、比較報告、自我擴展 Agent 系統

OpenClaw 完整架構指南

本文檔旨在讓你幾乎不需要查看 Source Code,就能完全理解 OpenClaw 這個開源 AI Agent 系統。


目錄

  1. 概述與定位
  2. 整體架構
  3. Gateway 系統
  4. Channel 頻道系統
  5. Agent 系統
  6. Provider 系統
  7. 路由與會話管理
  8. 工具系統 (Tools)
  9. 配置系統
  10. CLI 命令
  11. 自動回覆系統
  12. 記憶與上下文
  13. 媒體處理
  14. 安全與認證
  15. Hooks 系統
  16. 插件與擴展
  17. 日誌與監控
  18. 部署與安裝

1. 概述與定位

1.1 OpenClaw 是什麼?

OpenClaw(原名 Clawdbot → Moltbot → OpenClaw)是一個開源的 AI Agent 系統,由奧地利工程師 Peter Steinberger 於 2025 年 11 月發布。

核心定位

  • 本地運行的 AI Gateway:在你的機器上運行,作為 AI 模型與外部世界的橋樑
  • 多頻道訊息整合:連接 WhatsApp、Telegram、Discord、Slack、Signal、iMessage 等通訊軟體
  • 自動化任務執行:可執行 shell 命令、檔案操作、網頁自動化等

1.2 核心價值

特性 說明
統一入口 透過任何通訊軟體傳訊息即可操控電腦
會話持久化 自動保存對話歷史與上下文
多 Agent 路由 不同群組/使用者可對應不同 Agent
模型回退 主模型失敗時自動切換備用模型
可靠執行 Lane Queue 串行執行防止 race condition

1.3 專案結構

openclaw/
├── src/                    # 核心源碼
│   ├── entry.ts           # 程式進入點
│   ├── index.ts           # 程式庫匯出
│   ├── cli/               # CLI 層
│   ├── gateway/           # Gateway 閘道層(130+ 檔案)
│   ├── agents/            # Agent 系統(290+ 檔案)
│   ├── channels/          # 頻道系統
│   ├── routing/           # 路由系統
│   ├── config/            # 配置系統
│   ├── commands/          # 命令實現(180+ 檔案)
│   ├── auto-reply/        # 自動回覆
│   ├── memory/            # 記憶系統
│   ├── hooks/             # Hooks 系統
│   ├── plugins/           # 插件系統
│   ├── media/             # 媒體處理
│   ├── infra/             # 基礎設施
│   └── logging/           # 日誌系統
├── extensions/            # 擴展頻道(30+ 個)
├── docs/                  # 文檔
├── scripts/               # 腳本工具
├── apps/                  # 原生應用(iOS、Android、macOS)
└── test/                  # 測試

2. 整體架構

2.1 架構圖

┌─────────────────────────────────────────────────────────────────┐
│                     使用者介面層                                  │
│   Telegram │ Discord │ WhatsApp │ Slack │ Signal │ iMessage    │
│            │ Matrix  │ Teams    │ Feishu │ LINE  │ ...         │
└──────────────────────────┬──────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────────┐
│                      Gateway Server                              │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │ Channel Dock │  │   Router     │  │ Session Mgr  │          │
│  │ (Adapters)   │  │ (Bindings)   │  │ (Persist)    │          │
│  └──────────────┘  └──────────────┘  └──────────────┘          │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │ Lane Queue   │  │  WebSocket   │  │   Config     │          │
│  │ (Serial Exec)│  │  (Client)    │  │  (Reload)    │          │
│  └──────────────┘  └──────────────┘  └──────────────┘          │
└──────────────────────────┬──────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────────┐
│                      Agent 執行層                                │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │ Agent Config │  │  Pi Runner   │  │   Tools      │          │
│  │ (Scope/Model)│  │ (Executor)   │  │ (Capabilities)│         │
│  └──────────────┘  └──────────────┘  └──────────────┘          │
└──────────────────────────┬──────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────────┐
│                      Provider 層                                 │
│   Anthropic │ OpenAI │ Google │ Bedrock │ Ollama │ ...         │
└─────────────────────────────────────────────────────────────────┘

2.2 資訊流

使用者訊息(如 Telegram)
    │
    ▼
Channel Monitor(監聽訊息)
    │
    ▼
dispatchInboundMessage()(訊息分發)
    │
    ▼
resolveAgentRoute()(決定由哪個 Agent 處理)
    │
    ▼
getReplyFromConfig()(準備回覆配置)
    │
    ▼
runReplyAgent()(執行 Agent)
    │
    ├─→ 呼叫 AI 模型(Claude/GPT/...)
    │
    ├─→ 執行 Tools(如需要)
    │
    └─→ 生成回覆
    │
    ▼
Channel Outbound(發送回覆到原頻道)

2.3 核心模組職責

模組 路徑 職責
Entry src/entry.ts 程式進入點,環境初始化
Gateway src/gateway/ 中央樞紐,管理頻道連接、WebSocket 通訊
Channels src/channels/ 頻道 Adapter,統一各平台介面
Agents src/agents/ Agent 定義、執行、工具管理
Routing src/routing/ 訊息路由,決定哪個 Agent 處理
Config src/config/ 配置系統(JSON5 格式)
CLI src/cli/ 命令列介面
Auto-Reply src/auto-reply/ 自動回覆邏輯
Memory src/memory/ 會話記憶管理
Hooks src/hooks/ 事件鉤子
Extensions extensions/ 擴展頻道(Matrix、Teams、Feishu 等)

3. Gateway 系統

Gateway 是 OpenClaw 的核心樞紐,負責管理所有頻道連接和訊息路由。

3.1 啟動流程

openclaw gateway run
    │
    ▼
startGatewayServer()
    ├─→ loadConfig()              # 載入配置
    ├─→ createChannelManager()    # 初始化頻道管理器
    ├─→ attachGatewayWsHandlers() # 設置 WebSocket 處理
    ├─→ startGatewaySidecars()    # 啟動邊車服務
    ├─→ startGatewayConfigReloader() # 啟動配置熱重載
    ├─→ startHeartbeatRunner()    # 啟動心跳
    ├─→ startGatewayDiscovery()   # 啟動服務發現
    └─→ startGatewayMaintenanceTimers() # 啟動維護計時器

3.2 關鍵檔案

檔案 職責
src/gateway/server.impl.ts Gateway 伺服器主實現
src/gateway/boot.ts 啟動序列
src/gateway/client.ts Gateway 客戶端
src/gateway/server-ws-runtime.ts WebSocket 執行時

3.3 GatewayServer 類型

type GatewayServer = {
  // 生命週期
  start(): Promise<void>;
  stop(): Promise<void>;
  isHealthy(): boolean;

  // 頻道管理
  getChannelManager(): ChannelManager;

  // Agent 執行
  dispatchMessage(msg: InboundMessage): Promise<void>;

  // WebSocket
  handleWsConnection(ws: WebSocket): void;

  // 配置
  reloadConfig(): Promise<void>;

  // 事件
  on(event: string, handler: Function): void;
};

3.4 Lane Queue 機制

Lane Queue 是 OpenClaw 的核心創新之一,用於確保訊息串行執行,避免 race condition。

訊息 A(使用者 1)──┐
                  │
訊息 B(使用者 1)──┼──→ Lane Queue(使用者 1)──→ 串行執行
                  │
訊息 C(使用者 1)──┘

訊息 D(使用者 2)──┐
                  │
訊息 E(使用者 2)──┼──→ Lane Queue(使用者 2)──→ 串行執行

特點

  • 同一使用者的訊息串行處理(避免衝突)
  • 不同使用者的訊息並行處理(提高效率)
  • 支援優先級設定

4. Channel 頻道系統

4.1 支援的頻道

核心頻道(內建):

  • telegram - Telegram Bot API
  • whatsapp - WhatsApp Web(QR 登入)
  • discord - Discord Bot API
  • slack - Slack Socket Mode
  • signal - signal-cli 連結裝置
  • imessage - iMessage(macOS)
  • googlechat - Google Chat API

擴展頻道extensions/ 目錄):

  • matrix - Matrix/Synapse 協定
  • msteams - Microsoft Teams
  • feishu - 飛書/Lark
  • line - LINE Messaging
  • bluebubbles - BlueBubbles(iMessage 替代)
  • mattermost - Mattermost
  • nextcloud-talk - Nextcloud Talk
  • zalo - Zalo(越南)
  • 更多...

4.2 Adapter Pattern

每個頻道實作統一的 ChannelPlugin 介面:

type ChannelPlugin<ResolvedAccount = any> = {
  // 標識
  id: ChannelId;
  meta: ChannelMeta;
  capabilities: ChannelCapabilities;

  // 核心 Adapter
  config: ChannelConfigAdapter<ResolvedAccount>;  // 帳戶管理
  setup?: ChannelSetupAdapter;                    // 初始化設定
  security?: ChannelSecurityAdapter;              // 安全政策
  outbound?: ChannelOutboundAdapter;              // 訊息發送
  status?: ChannelStatusAdapter;                  // 狀態查詢

  // 訊息處理
  messaging?: ChannelMessagingAdapter;
  mentions?: ChannelMentionAdapter;
  actions?: ChannelMessageActionAdapter;

  // 群組與線程
  groups?: ChannelGroupAdapter;
  threading?: ChannelThreadingAdapter;
  commands?: ChannelCommandAdapter;

  // 路由
  pairing?: ChannelPairingAdapter;
  directory?: ChannelDirectoryAdapter;
  resolver?: ChannelResolverAdapter;

  // Gateway 整合
  gateway?: ChannelGatewayAdapter<ResolvedAccount>;
  auth?: ChannelAuthAdapter;
  elevated?: ChannelElevatedAdapter;

  // 其他
  streaming?: ChannelStreamingAdapter;
  heartbeat?: ChannelHeartbeatAdapter;
  agentTools?: ChannelAgentToolFactory;
  onboarding?: ChannelOnboardingAdapter;
};

4.3 頻道能力宣告

type ChannelCapabilities = {
  chatTypes: Array<"direct" | "group" | "channel" | "thread">;
  polls?: boolean;            // 投票功能
  reactions?: boolean;        // 表情反應
  edit?: boolean;             // 編輯訊息
  unsend?: boolean;           // 取消發送
  reply?: boolean;            // 回覆功能
  effects?: boolean;          // 視覺效果
  groupManagement?: boolean;  // 群組管理
  threads?: boolean;          // 線程支援
  media?: boolean;            // 媒體支援
  nativeCommands?: boolean;   // 斜槓命令
  blockStreaming?: boolean;   // 禁止串流
};

4.4 各頻道差異對照

頻道 訊息限制 串流 線程 特色
Telegram 4096 chars Bot 市場、群組管理
Discord 2000 chars 公會/頻道結構、按鈕
WhatsApp 4096 chars QR 登入、商業帳戶
Slack 40000 chars Socket Mode、豐富互動
iMessage 無限制 原生整合、效果

4.5 新增頻道步驟

  1. extensions/ 建立目錄
  2. 實作 ChannelPlugin 介面
  3. 實作 resolveAccount()listAccountIds()
  4. 實作 sendMessage() 出站邏輯
  5. 實作 monitor() 入站監聽
  6. 實作 onboarding 登入流程

5. Agent 系統

5.1 Agent 定義

Agent 是 OpenClaw 中的獨立執行單位,每個 Agent 有自己的:

  • 身份(ID、名稱)
  • 模型配置
  • 工作目錄
  • 技能列表
  • 會話歷史

5.2 Agent 配置結構

type AgentEntry = {
  id: string;                      // Agent ID(如 "main"、"code-agent")
  default?: boolean;               // 是否為預設 Agent
  name?: string;                   // 顯示名稱
  workspace?: string;              // 工作目錄
  agentDir?: string;               // Agent 資料目錄
  model?: AgentModelConfig;        // 模型配置
  skills?: string[];               // 技能列表
  memorySearch?: MemorySearchConfig;
  heartbeat?: HeartbeatConfig;
  identity?: IdentityConfig;
  subagents?: {
    allowAgents?: string[];        // 可生成的子 Agent
    model?: ModelConfig;
  };
  sandbox?: SandboxConfig;
  tools?: AgentToolsConfig;
};

5.3 Agent 執行流程

agentCommand(opts)
    │
    ├─→ 驗證輸入(訊息、會話、目標)
    │
    ├─→ loadConfig()
    │
    ├─→ resolveAgentConfig()
    │       ├─→ 取得 Agent ID
    │       ├─→ 解析工作目錄
    │       └─→ 解析模型配置
    │
    ├─→ ensureAgentWorkspace()
    │
    ├─→ loadModelDirectory()
    │
    ├─→ 選擇執行器:
    │       ├─→ runCliAgent()(CLI 模式)
    │       └─→ runEmbeddedPiAgent()(內嵌模式)
    │
    └─→ 遞交結果

5.4 Session Key 格式

agent:{agentId}:{channel}:{chatType}:{peerId}

例如:

  • agent:main:telegram:dm:123456789
  • agent:code-agent:discord:channel:guild-123:channel-456
  • agent:main:slack:thread:workspace-1:channel-2:thread-3

5.5 多 Agent 配置範例

{
  "agents": {
    "defaults": {
      "model": "anthropic/claude-3-5-sonnet"
    },
    "list": [
      {
        "id": "main",
        "default": true,
        "name": "主要助手"
      },
      {
        "id": "code-agent",
        "name": "程式助手",
        "model": "anthropic/claude-3-opus",
        "workspace": "/path/to/code",
        "skills": ["code-execution", "git"]
      },
      {
        "id": "research-agent",
        "name": "研究助手",
        "model": "openai/gpt-4",
        "tools": {
          "webSearch": { "enabled": true }
        }
      }
    ]
  }
}

6. Provider 系統

6.1 支援的 Provider

Provider API 類型 說明
anthropic anthropic-messages Claude 系列
openai openai-completions GPT 系列
google google Gemini 系列
bedrock bedrock-converse-stream AWS Bedrock
ollama openai-completions 本地 Ollama
minimax anthropic-messages MiniMax AI
moonshot openai-completions Moonshot (Kimi)
qwen-portal openai-completions 阿里 Qwen
venice openai-completions Venice AI
github-copilot 自訂 GitHub Copilot

6.2 Provider 配置

{
  "models": {
    "providers": {
      "anthropic": {
        "baseUrl": "https://api.anthropic.com",
        "apiKey": "${ANTHROPIC_API_KEY}",
        "models": [
          { "id": "claude-3-5-sonnet", "contextWindow": 200000 },
          { "id": "claude-3-opus", "contextWindow": 200000 }
        ]
      },
      "ollama": {
        "baseUrl": "http://localhost:11434",
        "models": [
          { "id": "llama3", "contextWindow": 8192 }
        ]
      }
    }
  }
}

6.3 模型回退機制

// 配置
{
  "model": {
    "primary": "anthropic/claude-3-5-sonnet",
    "fallbacks": [
      "anthropic/claude-3-opus",
      "openai/gpt-4",
      "google/gemini-2-flash"
    ]
  }
}

回退流程:

Primary Model
    │
    ├─→ 成功 → 返回結果
    │
    └─→ 失敗(認證錯誤、Rate Limit)
            │
            ▼
        嘗試下一個 Auth Profile
            │
            └─→ 全部失敗 → 切換到 Fallback #1
                    │
                    └─→ 失敗 → Fallback #2 → ...

6.4 隱式 Provider 發現

OpenClaw 會自動檢測可用的 Provider:

  • 檢查環境變數(ANTHROPIC_API_KEYOPENAI_API_KEY 等)
  • 檢查認證存儲
  • 探測本地服務(Ollama)

7. 路由與會話管理

7.1 路由解析流程

function resolveAgentRoute(input): ResolvedAgentRoute {
  // 1. 列出所有綁定規則
  const bindings = listBindings(config);

  // 2. 按優先級匹配
  for (const binding of bindings) {
    if (matchBinding(binding, input)) {
      return {
        agentId: binding.agentId,
        matchedBy: binding.type
      };
    }
  }

  // 3. 使用預設 Agent
  return { agentId: defaultAgentId, matchedBy: "default" };
}

7.2 綁定優先級

  1. binding.peer - 特定對話/群組
  2. binding.peer.parent - 父級線程(線程繼承)
  3. binding.guild - Discord 公會
  4. binding.team - Slack 工作區
  5. binding.account - 特定帳戶
  6. binding.channel - 特定頻道類型
  7. default - 預設 Agent

7.3 綁定配置範例

{
  "bindings": [
    {
      "agentId": "code-agent",
      "match": {
        "channel": "telegram",
        "peer": { "kind": "group", "id": "dev-group-123" }
      }
    },
    {
      "agentId": "support-agent",
      "match": {
        "channel": "discord",
        "guild": "support-guild-456"
      }
    },
    {
      "agentId": "main",
      "match": {
        "channel": "telegram"
      }
    }
  ]
}

7.4 會話持久化

會話資料儲存在:

  • ~/.openclaw/sessions/ - 會話檔案
  • ~/.openclaw/agents/{agentId}/sessions/ - Agent 專屬會話

8. 工具系統 (Tools)

8.1 內建工具列表

工具 說明 檔案
browser 網頁自動化 src/agents/tools/browser-tool.ts
message 跨頻道訊息發送 src/agents/tools/message-tool.ts
cron 排程任務 src/agents/tools/cron-tool.ts
tts 文字轉語音 src/agents/tools/tts-tool.ts
image 圖片處理/識別 src/agents/tools/image-tool.ts
canvas 圖片生成 src/agents/tools/canvas-tool.ts
nodes 程式碼執行 src/agents/tools/nodes-tool.ts
gateway Gateway 操作 src/agents/tools/gateway-tool.ts
agents.list 列出 Agent src/agents/tools/agents-list-tool.ts
sessions.list 列出會話 src/agents/tools/sessions-list-tool.ts
sessions.history 會話歷史 src/agents/tools/sessions-history-tool.ts
sessions.send 發送到會話 src/agents/tools/sessions-send-tool.ts
sessions.spawn 生成子 Agent src/agents/tools/sessions-spawn-tool.ts
sessions.status 會話狀態 src/agents/tools/sessions-status-tool.ts
webSearch 網路搜尋 src/agents/tools/web-search-tool.ts
webFetch 網頁抓取 src/agents/tools/web-fetch-tool.ts

8.2 工具定義介面

type AgentTool<Input = any, Output = unknown> = {
  name: string;
  description: string;
  inputSchema: JSONSchema;
  handler: (params: Input) => Promise<AgentToolResult>;
};

8.3 Message Tool 詳解

用於跨頻道發送訊息:

// 支援的操作
type MessageToolAction =
  | "send"           // 發送訊息
  | "reply"          // 回覆訊息
  | "thread-reply"   // 線程回覆
  | "sendAttachment" // 發送附件
  | "react"          // 添加反應
  | "fetch"          // 獲取訊息歷史
  | "edit"           // 編輯訊息
  | "delete";        // 刪除訊息

8.4 Sessions Spawn Tool

用於生成子 Agent:

// Agent 內呼叫
const result = await tool.spawn({
  agentId: "research-agent",
  prompt: "研究主題 X",
  model: "anthropic/claude-3-opus",
  thinking: "extended"
});

9. 配置系統

9.1 配置檔案位置

主配置檔:~/.openclaw/config.json5

9.2 完整配置結構

{
  // Agent 配置
  "agents": {
    "defaults": {
      "model": "anthropic/claude-3-5-sonnet",
      "workspace": "~"
    },
    "list": [/* Agent 列表 */]
  },

  // 頻道配置
  "channels": {
    "telegram": {
      "botToken": "xxx",
      "allowFrom": [123456789]
    },
    "discord": {
      "accounts": {
        "main": {
          "token": "xxx",
          "guilds": { "allow": ["guild-id"] }
        }
      }
    }
  },

  // 路由綁定
  "bindings": [/* 綁定規則 */],

  // 會話配置
  "session": {
    "dmScope": "per-peer",
    "identityLinks": {}
  },

  // 模型配置
  "models": {
    "providers": {/* Provider 配置 */}
  },

  // Gateway 配置
  "gateway": {
    "mode": "local",
    "port": 18789
  }
}

9.3 配置驗證

使用 Zod schema 驗證:

  • src/config/zod-schema.ts - 定義驗證規則
  • 啟動時自動驗證
  • 熱重載時重新驗證

9.4 環境變數

支援在配置中引用環境變數:

{
  "channels": {
    "telegram": {
      "botToken": "${TELEGRAM_BOT_TOKEN}"
    }
  }
}

9.4 完整配置範例

{
  // 元資料(自動生成)
  "meta": {
    "lastTouchedVersion": "2025.2.6",
    "lastTouchedAt": "2025-02-06T10:30:00.000Z"
  },

  // 環境變數配置
  "env": {
    "shellEnv": {
      "enabled": false,
      "timeoutMs": 15000
    },
    "vars": {
      "CUSTOM_VAR": "value"
    }
  },

  // Agent 配置
  "agents": {
    "defaults": {
      "workspace": "/path/to/workspace",
      "model": {
        "primary": "anthropic/claude-3-5-sonnet",
        "fallbacks": ["openai/gpt-4"]
      },
      "memorySearch": { "enabled": true }
    },
    "list": [
      {
        "id": "main",
        "default": true,
        "name": "主要助手"
      },
      {
        "id": "code-agent",
        "workspace": "/path/to/code",
        "skills": ["code_execution"]
      }
    ]
  },

  // 綁定規則
  "bindings": [
    {
      "agentId": "code-agent",
      "match": {
        "channel": "telegram",
        "peer": { "kind": "group", "id": "-100xxx" }
      }
    }
  ],

  // Gateway 設定
  "gateway": {
    "mode": "local",
    "port": 18789
  },

  // 頻道配置
  "channels": {
    "telegram": {
      "botToken": "${TELEGRAM_BOT_TOKEN}",
      "dmPolicy": "allowlist",
      "allowFrom": [123456789]
    }
  },

  // 工具配置
  "tools": {
    "profile": "full",
    "web": {
      "search": { "enabled": true },
      "fetch": { "enabled": true }
    }
  },

  // 會話設定
  "session": {
    "dmScope": "main"
  }
}

📁 Source: src/config/types.ts, src/config/zod-schema.ts

9.5 配置載入流程

1. 解析 JSON5 檔案
   └─→ src/config/io.ts: loadConfig()
        │
2. 處理 $include 指令(支援多檔案)
   └─→ src/config/includes.ts
        │
3. 套用 config.env 至 process.env
        │
4. 環境變數代換 ${VAR}
   └─→ src/config/env-substitution.ts
        │
5. Zod Schema 驗證
   └─→ src/config/validation.ts
        │
6. 套用預設值
   └─→ src/config/defaults.ts
        │
7. 正規化路徑
   └─→ src/config/normalize-paths.ts
        │
8. 套用執行時覆蓋
        │
        ▼
    ✓ 配置就緒

9.6 DM 政策類型

政策 說明
"pairing" 未知使用者需配對碼
"allowlist" 只允許 allowFrom 中的使用者
"open" 允許所有 DM
"disabled" 禁用所有 DM

10. CLI 命令

10.1 主要命令

命令 說明
openclaw gateway run 啟動 Gateway
openclaw agent --message "..." 執行 Agent
openclaw message send 發送訊息
openclaw channels status 頻道狀態
openclaw config set/get 配置管理
openclaw doctor 診斷工具
openclaw login 登入 Web 服務

10.2 Gateway 命令

# 啟動 Gateway
openclaw gateway run --bind loopback --port 18789

# 強制重啟
openclaw gateway run --force

# 指定配置
openclaw gateway run --config /path/to/config.json5

10.3 Agent 命令

# 傳送訊息給 Agent
openclaw agent --message "你好"

# 指定 Agent
openclaw agent --agent code-agent --message "寫一個函數"

# 指定會話
openclaw agent --session "agent:main:telegram:dm:123" --message "..."

10.4 頻道命令

# 查看頻道狀態
openclaw channels status

# 深度探測
openclaw channels status --deep

# 特定頻道
openclaw channels status telegram

10.5 配置命令

# 查看配置
openclaw config get agents.defaults.model

# 設定配置
openclaw config set agents.defaults.model anthropic/claude-3-opus

# 列出所有配置
openclaw config list

13. 媒體處理

13.1 媒體限制

類型 大小限制
圖片 6 MB
音訊 16 MB
影片 16 MB
文件 100 MB

13.2 媒體儲存

  • 位置:~/.openclaw/media/
  • 格式:{sanitized-name}---{uuid}.{ext}
  • TTL:2 分鐘(自動清理)

13.3 MIME 類型檢測

多層檢測策略:

  1. Buffer sniffing(魔術數字)
  2. 副檔名推斷
  3. HTTP Content-Type header

13.4 圖片處理

  • 後端:Sharp 或 sips(macOS)
  • 功能:
    • EXIF 方向自動修正
    • HEIC → JPEG 轉換
    • PNG/JPEG 自適應壓縮

13.5 TTS(文字轉語音)

支援的服務:

  • ElevenLabs
  • OpenAI TTS
  • Edge TTS

模式:

  • auto - 自動判斷
  • always - 總是語音
  • inbound - 收到語音時回語音
  • tagged - 標記時才語音

14. 安全與認證

14.1 DM 政策

三種模式:

政策 說明
open 允許所有人 DM
pairing 需要配對碼
allowlist 僅允許清單內的使用者

14.2 AllowFrom 設定

{
  "channels": {
    "telegram": {
      "allowFrom": [
        123456789,      // 使用者 ID
        -100123456789   // 群組 ID
      ]
    }
  }
}

14.3 認證檔案管理

  • 位置:~/.openclaw/auth-profiles/
  • 支援多個 API key 輪替
  • 自動處理 rate limit

14.4 沙箱隔離

{
  "agents": {
    "list": [{
      "id": "untrusted-agent",
      "sandbox": {
        "enabled": true,
        "allowedPaths": ["/tmp/sandbox"]
      }
    }]
  }
}

14.5 沙箱隔離(Sandbox)

{
  "agents": {
    "list": [{
      "id": "untrusted-agent",
      "sandbox": {
        "mode": "all",              // off | non-main | all
        "scope": "session",         // session | agent | shared
        "workspaceAccess": "ro",    // none | ro | rw
        "tools": {
          "deny": ["bash_exec", "file_write"]
        }
      }
    }]
  }
}
模式 說明 安全級別
off 無沙箱 🔴 最低
non-main 非主 Agent 使用沙箱 🟡 中等
all 所有 Agent 使用沙箱 🟢 高

📁 Source: src/config/types.ts (SandboxConfig)

14.6 安全審計

# 基本審計
openclaw security audit

# 深度審計(含 Gateway 探測)
openclaw security audit --deep

# 自動修復權限問題
openclaw security audit --fix

14.7 安全最佳實踐

  1. 永遠使用 allowlist:不要用 dmPolicy: "open"
  2. 隔離會話:設定 session.dmScope: "per-channel-peer"
  3. 保護配置檔chmod 600 ~/.openclaw/config.json5
  4. Gateway 認證:暴露於網路時設定 token
  5. 沙箱不信任模型:小型/未知模型使用沙箱

15. Hooks 系統

15.1 Hook 類型

事件類型 觸發點 用途
command:new /new 命令 會話重置前執行
command:reset /reset 命令 會話重置前執行
command:stop /stop 命令 停止前執行
agent:bootstrap Agent 啟動 注入 bootstrap 檔案前
gateway:startup Gateway 就緒 初始化任務

📁 Source: src/hooks/types.ts, src/hooks/internal-hooks.ts

15.2 Hook 目錄結構

my-hook/
├── HOOK.md          # 元數據 + 文檔(必須)
└── handler.ts       # 實現(必須)

15.3 HOOK.md 格式

---
name: my-hook
description: "Hook 描述"
metadata:
  {
    "openclaw": {
      "emoji": "🎯",
      "events": ["command:new", "command:reset"],
      "export": "default",
      "requires": {
        "bins": ["node"],
        "env": ["MY_VAR"]
      }
    }
  }
enabled: true
---

15.4 Hook 發現優先級

  1. Workspace Hooks(最高):<workspace>/hooks/
  2. Managed Hooks~/.openclaw/hooks/
  3. Bundled Hooks:OpenClaw 內建
  4. Extra Dirs:配置中指定的額外目錄

15.5 內建 Hooks

Hook 事件 功能
session-memory command:new 保存會話摘要到記憶
command-logger command 記錄所有命令到日誌
soul-evil agent:bootstrap 根據配置替換 SOUL.md
boot-md gateway:startup 執行 BOOT.md 任務

15.6 Hook 配置

{
  "hooks": {
    "internal": {
      "enabled": true,
      "entries": {
        "session-memory": {
          "enabled": true,
          "messages": 25  // 保存最近 N 條訊息
        }
      },
      "load": {
        "extraDirs": ["/path/to/custom/hooks"]
      }
    }
  }
}

15.7 Hook CLI 命令

# 列出 hooks
openclaw hooks list
openclaw hooks list --eligible   # 只顯示符合條件的

# Hook 資訊
openclaw hooks info session-memory

# 啟用/禁用
openclaw hooks enable session-memory
openclaw hooks disable command-logger

# 安裝 hook pack
openclaw hooks install @acme/my-hooks

📁 Source: src/hooks/loader.ts, src/cli/hooks-cli.ts


16. 插件與擴展

16.1 插件架構

插件位於 extensions/ 目錄,每個插件是獨立的 npm package。

16.2 現有擴展

擴展 說明
matrix Matrix 協定
msteams Microsoft Teams
feishu 飛書/Lark
line LINE Messaging
bluebubbles BlueBubbles
mattermost Mattermost
voice-call 語音通話

16.3 開發擴展

  1. 建立 extensions/{name}/ 目錄
  2. 初始化 package.json
  3. 實作 src/channel.ts
  4. 匯出 ChannelPlugin

17. 日誌與監控

17.1 日誌級別

級別 說明
silent 完全關閉
fatal 致命錯誤
error 錯誤
warn 警告
info 一般資訊(預設)
debug 除錯資訊
trace 最詳細追蹤

17.2 日誌配置

{
  "logging": {
    "level": "info",                    // 檔案日誌級別
    "file": "/tmp/openclaw/openclaw-YYYY-MM-DD.log",
    "consoleLevel": "info",             // 控制台級別
    "consoleStyle": "pretty",           // pretty | compact | json
    "redactSensitive": "tools"          // off | tools(自動清理敏感資訊)
  }
}

17.3 日誌查看

# 即時尾部(推薦)
openclaw logs --follow

# JSON 格式
openclaw logs --follow --json

# 頻道特定日誌
openclaw channels logs --channel whatsapp

17.4 健康檢查

# 基本健康檢查
openclaw health

# 詳細檢查
openclaw health --verbose

# JSON 輸出
openclaw health --json

17.5 狀態查詢

# 本地摘要
openclaw status

# 完整診斷
openclaw status --all

# 同時探測 Gateway
openclaw status --deep

# 使用量報告
openclaw status --usage

17.6 敏感資料清理

自動清理的模式:

  • API Keys:sk-***, ghp_***, npm_***
  • 環境變數:API_KEY=***
  • Authorization headers:Bearer ***
  • PEM 私鑰塊

📁 Source: src/logging/redact.ts, src/logging/console.ts

17.7 Doctor 診斷

# 互動式診斷
openclaw doctor

# 自動修復
openclaw doctor --fix

# 非互動模式
openclaw doctor --non-interactive

Doctor 檢查項目包括:

  • 配置驗證
  • Gateway 連接
  • 頻道狀態
  • 安全審計
  • 工作區完整性

18. 部署與安裝

18.1 安裝方式

npm 全域安裝

npm install -g openclaw

Docker

docker run -v ~/.openclaw:/root/.openclaw openclaw/openclaw

macOS App: 從官網下載 DMG 安裝

18.2 系統需求

  • Node.js 22+
  • 記憶體:建議 4GB+
  • 磁碟:建議 1GB+(含媒體快取)

18.3 部署模式

模式 說明
本地 在個人電腦運行
Docker 容器化部署
Fly.io 雲端部署
Render 雲端部署

18.4 macOS 整合

  • Menubar App:狀態列圖示
  • LaunchAgent:開機自動啟動
  • 快捷鍵:全域快捷鍵支援

附錄:關鍵檔案索引

用途 檔案路徑
程式進入點 src/entry.ts
Gateway 實作 src/gateway/server.impl.ts
Agent 執行 src/agents/pi-embedded-runner/run.ts
頻道 Adapter src/channels/plugins/types.adapters.ts
路由解析 src/routing/resolve-route.ts
工具定義 src/agents/openclaw-tools.ts
配置類型 src/config/types.ts
配置驗證 src/config/zod-schema.ts
自動回覆 src/auto-reply/dispatch.ts
記憶系統 src/memory/
媒體處理 src/media/

本文檔基於 OpenClaw 源碼分析產生,最後更新:2026-02-06

OpenClaw Cheatsheet

快速查詢表 - 常用命令與配置


🚀 常用命令

Gateway

# 啟動 Gateway
openclaw gateway run

# 強制重啟(殺掉舊的)
openclaw gateway run --force

# 指定 port
openclaw gateway run --port 18789

# 綁定到 loopback(僅本機)
openclaw gateway run --bind loopback

📁 Source: src/commands/gateway.ts

Agent

# 傳訊息給預設 Agent
openclaw agent --message "你好"
openclaw agent -m "你好"

# 指定 Agent
openclaw agent --agent code-agent -m "寫個函數"

# 指定 Session
openclaw agent --session "agent:main:telegram:dm:123" -m "..."

# 使用 extended thinking
openclaw agent -m "..." --thinking extended

📁 Source: src/commands/agent.ts

訊息發送

# 發送到 Telegram
openclaw message send --channel telegram --to 123456789 --text "Hello"

# 發送到 Discord
openclaw message send --channel discord --to channel-id --text "Hello"

# 發送到 WhatsApp
openclaw message send --channel whatsapp --to "phone@c.us" --text "Hello"

📁 Source: src/commands/message.ts

頻道狀態

# 所有頻道狀態
openclaw channels status

# 深度探測(實際連線測試)
openclaw channels status --deep

# 特定頻道
openclaw channels status telegram

# JSON 輸出
openclaw channels status --json

📁 Source: src/commands/channels.ts

配置管理

# 查看配置
openclaw config get agents.defaults.model

# 設定配置
openclaw config set agents.defaults.model anthropic/claude-3-opus

# 列出所有
openclaw config list

# 編輯配置檔
openclaw config edit

📁 Source: src/commands/config.ts

診斷

# 執行診斷
openclaw doctor

# 健康檢查
openclaw health

📁 Source: src/commands/doctor.ts


⚙️ 配置速查

配置檔位置

~/.openclaw/config.json5

最小配置範例

{
  "agents": {
    "defaults": {
      "model": "anthropic/claude-3-5-sonnet"
    }
  },
  "channels": {
    "telegram": {
      "botToken": "YOUR_BOT_TOKEN",
      "allowFrom": [YOUR_TELEGRAM_USER_ID]
    }
  }
}

多 Agent 配置

{
  "agents": {
    "list": [
      { "id": "main", "default": true },
      { "id": "code", "model": "anthropic/claude-3-opus" }
    ]
  },
  "bindings": [
    {
      "agentId": "code",
      "match": { "channel": "telegram", "peer": { "kind": "group", "id": "-100xxx" } }
    }
  ]
}

📁 Source: src/config/types.ts, src/config/zod-schema.ts


🔑 環境變數

變數 用途
ANTHROPIC_API_KEY Anthropic API 金鑰
OPENAI_API_KEY OpenAI API 金鑰
TELEGRAM_BOT_TOKEN Telegram Bot Token
DISCORD_TOKEN Discord Bot Token
OLLAMA_BASE_URL 本地 Ollama 位址

📍 Session Key 格式

agent:{agentId}:{channel}:{chatType}:{peerId}

範例:

  • agent:main:telegram:dm:123456789
  • agent:main:discord:channel:guild-1:channel-2
  • agent:main:slack:thread:workspace:channel:thread

📁 Source: src/routing/session-key.ts


📂 重要目錄

目錄 用途
~/.openclaw/ 主設定目錄
~/.openclaw/config.json5 主配置檔
~/.openclaw/sessions/ 會話資料
~/.openclaw/media/ 媒體快取
~/.openclaw/auth-profiles/ API 金鑰
~/.openclaw/agents/ Agent 資料

🔌 支援的頻道

頻道 ID 配置 Key
Telegram telegram channels.telegram
Discord discord channels.discord
WhatsApp whatsapp channels.whatsapp
Slack slack channels.slack
Signal signal channels.signal
iMessage imessage channels.imessage
Matrix matrix channels.matrix
Teams msteams channels.msteams

🤖 支援的 Provider

Provider Model 格式
Anthropic anthropic/claude-3-5-sonnet
OpenAI openai/gpt-4
Google google/gemini-2-flash
Bedrock bedrock/anthropic.claude-3
Ollama ollama/llama3

📁 Source: src/agents/models-config.providers.ts


🛠️ 內建工具

工具 用途
browser 網頁自動化
message 跨頻道訊息
cron 排程任務
tts 文字轉語音
image 圖片處理
webSearch 網路搜尋
webFetch 網頁抓取
sessions.spawn 子 Agent

📁 Source: src/agents/openclaw-tools.ts


📊 媒體限制

類型 限制
圖片 6 MB
音訊 16 MB
影片 16 MB
文件 100 MB

📁 Source: src/media/constants.ts


🔒 DM 政策

政策 設定值 說明
開放 "open" 允許所有人
配對 "pairing" 需配對碼
白名單 "allowlist" 僅允許清單

設定方式:

{
  "channels": {
    "telegram": {
      "dmPolicy": "allowlist",
      "allowFrom": [123456789]
    }
  }
}

快速查詢表 v1.0 | 2026-02-06

OpenClaw FAQ

常見問題與解答


基礎問題

Q: OpenClaw 是什麼?

A: OpenClaw 是一個開源的 AI Agent 系統,讓你可以透過 Telegram、WhatsApp、Discord 等通訊軟體與 AI 助手互動,並讓 AI 在你的電腦上執行任務。

📁 官網:https://openclaw.ai/


Q: OpenClaw 與 ChatGPT/Claude.ai 有什麼不同?

A: 主要差異:

面向 ChatGPT/Claude.ai OpenClaw
運行位置 雲端 你的電腦
入口 網頁/App 任何通訊軟體
執行能力 無法操作你的系統 可執行 shell、操作檔案
會話持久 平台管理 本地儲存,完全掌控
成本 訂閱制 API 費用(按使用量)

Q: OpenClaw 與 Claude Code 有什麼不同?

A:

面向 Claude Code OpenClaw
入口 Terminal(需 SSH) 通訊軟體(隨時可用)
權限 直接操作,權限大 透過 Tools,權限受控
會話 每次新啟動 自動持久化
多頻道 單一 多頻道統一入口
即時性 直接回饋 經過 Gateway

📁 詳見比較報告:04-comparison-report.md


Q: 需要什麼硬體?

A:

  • 最低:任何可運行 Node.js 22+ 的電腦
  • 建議:4GB+ RAM、SSD
  • 適合:Mac mini、NAS、雲端 VM

安裝與設定

Q: 如何安裝?

A:

# npm 全域安裝
npm install -g openclaw

# 或 Docker
docker pull openclaw/openclaw

📁 Source: docs/install/


Q: 配置檔在哪裡?

A: ~/.openclaw/config.json5

最小配置範例:

{
  "agents": {
    "defaults": { "model": "anthropic/claude-3-5-sonnet" }
  },
  "channels": {
    "telegram": {
      "botToken": "YOUR_TOKEN",
      "allowFrom": [YOUR_USER_ID]
    }
  }
}

📁 Source: src/config/io.ts


Q: 如何取得 Telegram User ID?

A:

  1. 在 Telegram 搜尋 @userinfobot
  2. 發送任何訊息
  3. 它會回覆你的 User ID

Q: 如何設定多個頻道?

A: 在 channels 區塊加入各頻道配置:

{
  "channels": {
    "telegram": { "botToken": "..." },
    "discord": { "token": "..." },
    "slack": { "botToken": "...", "appToken": "..." }
  }
}

Q: 如何使用本地模型(Ollama)?

A:

  1. 安裝 Ollama:https://ollama.ai/
  2. 拉取模型:ollama pull llama3
  3. 配置 OpenClaw:
{
  "agents": {
    "defaults": { "model": "ollama/llama3" }
  },
  "models": {
    "providers": {
      "ollama": {
        "baseUrl": "http://localhost:11434"
      }
    }
  }
}

📁 Source: src/agents/models-config.providers.ts


Gateway 相關

Q: Gateway 是什麼?

A: Gateway 是 OpenClaw 的核心服務,負責:

  • 監聽各頻道訊息
  • 路由到對應 Agent
  • 管理會話
  • 發送回覆

📁 Source: src/gateway/server.impl.ts


Q: 如何啟動 Gateway?

A:

openclaw gateway run

在 macOS 上也可以透過 Menubar App 啟動。


Q: Gateway 佔用什麼 port?

A: 預設 18789。可透過 --port 參數修改:

openclaw gateway run --port 8080

Q: 如何讓 Gateway 開機自動啟動?

A:

  • macOS: 安裝 Menubar App,勾選「開機啟動」
  • Linux: 使用 systemd service
  • Docker: 使用 --restart always

Agent 相關

Q: 什麼是 Agent?

A: Agent 是 OpenClaw 中的執行單位,每個 Agent 有:

  • 自己的 ID 和名稱
  • 模型配置
  • 工作目錄
  • 技能列表
  • 會話歷史

📁 Source: src/agents/agent-scope.ts


Q: 如何設定多個 Agent?

A:

{
  "agents": {
    "list": [
      { "id": "main", "default": true, "model": "anthropic/claude-3-5-sonnet" },
      { "id": "code", "model": "anthropic/claude-3-opus", "workspace": "/code" }
    ]
  },
  "bindings": [
    { "agentId": "code", "match": { "channel": "telegram", "peer": { "kind": "group", "id": "-100xxx" } } }
  ]
}

Q: Session Key 是什麼?

A: Session Key 是會話的唯一識別碼,格式為:

agent:{agentId}:{channel}:{chatType}:{peerId}

例如:agent:main:telegram:dm:123456789

📁 Source: src/routing/session-key.ts


工具相關

Q: OpenClaw 可以做什麼?

A: 透過內建工具,OpenClaw 可以:

  • 🌐 瀏覽網頁、填表單
  • 📁 讀寫檔案、執行腳本
  • 📧 發送 email
  • 📅 管理行事曆
  • 🔍 網路搜尋
  • 🖼️ 處理圖片
  • 🎙️ 文字轉語音
  • ⏰ 設定排程任務

📁 Source: src/agents/openclaw-tools.ts


Q: 如何限制 Agent 可用的工具?

A: 在 Agent 配置中指定:

{
  "agents": {
    "list": [{
      "id": "limited-agent",
      "tools": {
        "browser": { "enabled": false },
        "shell": { "enabled": false }
      }
    }]
  }
}

安全相關

Q: 誰可以跟我的 Bot 對話?

A: 透過 allowFrom 設定白名單:

{
  "channels": {
    "telegram": {
      "dmPolicy": "allowlist",
      "allowFrom": [123456789, 987654321]
    }
  }
}

📁 Source: src/channels/plugins/types.adapters.ts


Q: 如何保護 API 金鑰?

A:

  1. 使用環境變數:
{ "apiKey": "${ANTHROPIC_API_KEY}" }
  1. 使用 auth-profiles 管理多個金鑰:
~/.openclaw/auth-profiles/

📁 Source: src/agents/auth-profiles.ts


Q: 可以用沙箱隔離嗎?

A: 可以:

{
  "agents": {
    "list": [{
      "id": "sandbox-agent",
      "sandbox": {
        "enabled": true,
        "allowedPaths": ["/tmp/sandbox"]
      }
    }]
  }
}

問題排解

Q: Bot 沒有回應?

A: 檢查清單:

  1. Gateway 是否正在運行?openclaw health
  2. 頻道是否正確配置?openclaw channels status
  3. User ID 是否在 allowFrom 清單中?
  4. API 金鑰是否有效?

Q: 看到「Rate limit」錯誤?

A:

  1. 設定模型回退:
{
  "model": {
    "primary": "anthropic/claude-3-5-sonnet",
    "fallbacks": ["openai/gpt-4"]
  }
}
  1. 配置多個 API 金鑰輪替

Q: 如何查看日誌?

A:

# 查看 Gateway 日誌
tail -f /tmp/openclaw-gateway.log

# macOS 統一日誌
log show --predicate 'subsystem == "ai.openclaw"' --last 1h

Q: 如何執行診斷?

A:

openclaw doctor

這會檢查:

  • 配置檔有效性
  • 頻道連接狀態
  • API 金鑰
  • 系統依賴

📁 Source: src/commands/doctor.ts


進階問題

Q: 如何自訂 System Prompt?

A: 在 Agent 配置中設定 identity:

{
  "agents": {
    "list": [{
      "id": "custom-agent",
      "identity": {
        "name": "小助手",
        "prompt": "你是一個專業的程式助手..."
      }
    }]
  }
}

Q: 如何實作自訂工具?

A: 透過插件系統。參考 extensions/ 目錄下的範例。

📁 Source: src/plugins/


Q: 支援 MCP(Model Context Protocol)嗎?

A: 是的,OpenClaw 支援 MCP 整合。


Q: 如何更新 OpenClaw?

A:

npm update -g openclaw

FAQ v1.0 | 2026-02-06

OpenClaw 架構圖集

視覺化流程圖 - 快速理解系統架構


1. 整體系統架構

┌─────────────────────────────────────────────────────────────────────────┐
│                           使用者入口層                                    │
│                                                                          │
│  📱 Telegram   📱 Discord   📱 WhatsApp   📱 Slack   📱 Signal          │
│       │            │            │            │           │               │
│       └────────────┴────────────┴────────────┴───────────┘               │
│                               │                                          │
│                    各頻道的 Bot/監聽服務                                  │
└───────────────────────────────┬─────────────────────────────────────────┘
                                │
                                ▼
┌───────────────────────────────────────────────────────────────────────────┐
│                         OpenClaw Gateway                                  │
│  ┌─────────────────────────────────────────────────────────────────────┐ │
│  │                    Channel Manager                                   │ │
│  │   ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐              │ │
│  │   │ Telegram │ │ Discord  │ │ WhatsApp │ │  Slack   │  ...         │ │
│  │   │ Adapter  │ │ Adapter  │ │ Adapter  │ │ Adapter  │              │ │
│  │   └──────────┘ └──────────┘ └──────────┘ └──────────┘              │ │
│  └─────────────────────────────────────────────────────────────────────┘ │
│                                │                                          │
│  ┌─────────────────────────────▼───────────────────────────────────────┐ │
│  │                         Router                                       │ │
│  │   • Session Key 解析                                                 │ │
│  │   • Agent 綁定匹配                                                   │ │
│  │   • 路由決策                                                         │ │
│  └─────────────────────────────────────────────────────────────────────┘ │
│                                │                                          │
│  ┌─────────────────────────────▼───────────────────────────────────────┐ │
│  │                      Lane Queue                                      │ │
│  │   • 串行執行保證                                                     │ │
│  │   • 防止 Race Condition                                              │ │
│  └─────────────────────────────────────────────────────────────────────┘ │
│                                │                                          │
│  ┌─────────────────────────────▼───────────────────────────────────────┐ │
│  │                    Session Manager                                   │ │
│  │   • 會話持久化                                                       │ │
│  │   • 歷史管理                                                         │ │
│  └─────────────────────────────────────────────────────────────────────┘ │
└───────────────────────────────┬─────────────────────────────────────────┘
                                │
                                ▼
┌───────────────────────────────────────────────────────────────────────────┐
│                          Agent 執行層                                     │
│  ┌─────────────────────────────────────────────────────────────────────┐ │
│  │                      Agent Executor                                  │ │
│  │   ┌──────────────┐  ┌──────────────┐  ┌──────────────┐             │ │
│  │   │ Agent Config │  │  Pi Runner   │  │    Tools     │             │ │
│  │   │  • Model     │  │  • Execute   │  │  • Browser   │             │ │
│  │   │  • Skills    │  │  • Stream    │  │  • Message   │             │ │
│  │   │  • Workspace │  │  • Fallback  │  │  • File      │             │ │
│  │   └──────────────┘  └──────────────┘  └──────────────┘             │ │
│  └─────────────────────────────────────────────────────────────────────┘ │
└───────────────────────────────┬─────────────────────────────────────────┘
                                │
                                ▼
┌───────────────────────────────────────────────────────────────────────────┐
│                          Provider 層                                      │
│   ┌───────────┐  ┌───────────┐  ┌───────────┐  ┌───────────┐            │
│   │ Anthropic │  │  OpenAI   │  │  Google   │  │  Ollama   │   ...      │
│   │  Claude   │  │   GPT     │  │  Gemini   │  │  (Local)  │            │
│   └───────────┘  └───────────┘  └───────────┘  └───────────┘            │
└───────────────────────────────────────────────────────────────────────────┘

📁 Source: src/gateway/server.impl.ts, src/channels/, src/agents/


2. 訊息處理流程

使用者傳送訊息(Telegram)
        │
        ▼
┌───────────────────────┐
│  Telegram Bot API     │
│  (監聽 webhook)       │
└───────────┬───────────┘
            │
            ▼
┌───────────────────────┐
│  Channel Monitor      │  ← src/telegram/monitor.ts
│  - 接收訊息           │
│  - 提取內容           │
│  - 標準化格式         │
└───────────┬───────────┘
            │
            ▼
┌───────────────────────┐
│  dispatchInbound      │  ← src/auto-reply/dispatch.ts
│  Message()            │
│  - 建立 MsgContext    │
│  - 觸發處理流程       │
└───────────┬───────────┘
            │
            ▼
┌───────────────────────┐
│  resolveAgentRoute()  │  ← src/routing/resolve-route.ts
│  - 解析 Session Key   │
│  - 匹配 Binding 規則  │
│  - 決定由哪個 Agent   │
│    處理               │
└───────────┬───────────┘
            │
            ▼
┌───────────────────────┐
│  Lane Queue           │  ← 串行執行
│  - 確保同一使用者     │
│    訊息按序處理       │
└───────────┬───────────┘
            │
            ▼
┌───────────────────────┐
│  getReplyFromConfig() │  ← src/auto-reply/reply/get-reply.ts
│  - 載入 Agent 配置    │
│  - 準備執行環境       │
└───────────┬───────────┘
            │
            ▼
┌───────────────────────┐
│  runReplyAgent()      │  ← src/auto-reply/reply/agent-runner.ts
│  - 建立工具集         │
│  - 執行 Agent         │
└───────────┬───────────┘
            │
            ▼
┌───────────────────────┐
│  runEmbeddedPiAgent() │  ← src/agents/pi-embedded-runner/run.ts
│  - 呼叫 AI 模型       │
│  - 處理 Tool 呼叫     │
│  - 生成回覆           │
└───────────┬───────────┘
            │
            ▼
┌───────────────────────┐
│  Channel Outbound     │  ← src/channels/plugins/outbound/
│  - 格式化回覆         │
│  - 分塊(如需要)     │
│  - 發送到原頻道       │
└───────────┬───────────┘
            │
            ▼
      使用者收到回覆

3. Agent 路由決策樹

收到訊息
    │
    ▼
解析來源資訊
├─ channel: telegram
├─ chatType: group
├─ peerId: -100123456
└─ userId: 789
    │
    ▼
查詢 Bindings 配置
    │
    ├─→ 有 peer 綁定?
    │       │
    │       ├─ 是 → 使用綁定的 agentId ──────────────┐
    │       │                                         │
    │       └─ 否 ↓                                   │
    │                                                 │
    ├─→ 有 guild/team 綁定?(Discord/Slack)         │
    │       │                                         │
    │       ├─ 是 → 使用綁定的 agentId ──────────────┤
    │       │                                         │
    │       └─ 否 ↓                                   │
    │                                                 │
    ├─→ 有 account 綁定?                             │
    │       │                                         │
    │       ├─ 是 → 使用綁定的 agentId ──────────────┤
    │       │                                         │
    │       └─ 否 ↓                                   │
    │                                                 │
    ├─→ 有 channel 綁定?                             │
    │       │                                         │
    │       ├─ 是 → 使用綁定的 agentId ──────────────┤
    │       │                                         │
    │       └─ 否 ↓                                   │
    │                                                 │
    └─→ 使用 default Agent ─────────────────────────┤
                                                      │
                                                      ▼
                                              決定使用的 Agent
                                                      │
                                                      ▼
                                              建立 Session Key
                                              agent:{id}:{channel}:{type}:{peer}

📁 Source: src/routing/resolve-route.ts


4. 模型回退流程

執行 AI 呼叫
    │
    ▼
┌─────────────────────────────────────────────────┐
│              Primary Model                       │
│         anthropic/claude-3-5-sonnet             │
└─────────────────────────────────────────────────┘
    │
    ├─→ 成功 ──────────────────────────────────→ 返回結果
    │
    └─→ 失敗
            │
            ├─→ 認證錯誤?
            │       │
            │       └─→ 嘗試下一個 Auth Profile
            │               │
            │               ├─→ 成功 → 返回結果
            │               │
            │               └─→ 全部失敗 ↓
            │
            ├─→ Rate Limit?
            │       │
            │       └─→ 標記 Provider 冷卻
            │
            └─→ 其他錯誤
                    │
                    ▼
┌─────────────────────────────────────────────────┐
│              Fallback #1                         │
│           anthropic/claude-3-opus               │
└─────────────────────────────────────────────────┘
    │
    ├─→ 成功 → 返回結果
    │
    └─→ 失敗 ↓
            │
            ▼
┌─────────────────────────────────────────────────┐
│              Fallback #2                         │
│              openai/gpt-4                        │
└─────────────────────────────────────────────────┘
    │
    ├─→ 成功 → 返回結果
    │
    └─→ 失敗 ↓
            │
            ▼
┌─────────────────────────────────────────────────┐
│              Fallback #3                         │
│          google/gemini-2-flash                   │
└─────────────────────────────────────────────────┘
    │
    ├─→ 成功 → 返回結果
    │
    └─→ 全部失敗 → 拋出 FailoverError

📁 Source: src/agents/model-fallback.ts


5. Lane Queue 並發模型

┌─────────────────────────────────────────────────────────────────────┐
│                        使用者 A 的訊息                               │
│                                                                      │
│   訊息 A1 ─┬─→ ┌─────────┐                                          │
│            │   │ Queue A │ ═══════════════════════════════╗          │
│   訊息 A2 ─┤   └─────────┘                                ║          │
│            │        ↓                                      ║          │
│   訊息 A3 ─┘   串行執行                                   ║          │
│                A1 → A2 → A3                               ║          │
│                                                            ║          │
└────────────────────────────────────────────────────────────╬─────────┘
                                                             ║ 並行
┌────────────────────────────────────────────────────────────╬─────────┐
│                        使用者 B 的訊息                      ║          │
│                                                            ║          │
│   訊息 B1 ─┬─→ ┌─────────┐                                ║          │
│            │   │ Queue B │ ═══════════════════════════════╝          │
│   訊息 B2 ─┘   └─────────┘                                           │
│                     ↓                                                 │
│                串行執行                                               │
│                B1 → B2                                                │
│                                                                       │
└───────────────────────────────────────────────────────────────────────┘

關鍵特性:
┌─────────────────────────────────────────────────────────────────────┐
│ ✅ 同一使用者的訊息:串行處理(避免衝突)                           │
│ ✅ 不同使用者的訊息:並行處理(提高效率)                           │
│ ✅ 每個 Queue 獨立:一個使用者慢不影響其他人                        │
└─────────────────────────────────────────────────────────────────────┘

6. Channel Adapter 架構

┌─────────────────────────────────────────────────────────────────────┐
│                        ChannelPlugin 介面                            │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌─────────────────────────────────────────────────────────────────┐│
│  │                     核心 Adapters                                ││
│  │  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐       ││
│  │  │ ConfigAdapter │  │ SetupAdapter  │  │SecurityAdapter│       ││
│  │  │ • 帳戶管理    │  │ • 初始化     │  │ • DM 政策    │       ││
│  │  │ • 配置解析    │  │ • 驗證       │  │ • 白名單     │       ││
│  │  └───────────────┘  └───────────────┘  └───────────────┘       ││
│  └─────────────────────────────────────────────────────────────────┘│
│                                                                      │
│  ┌─────────────────────────────────────────────────────────────────┐│
│  │                     訊息 Adapters                                ││
│  │  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐       ││
│  │  │OutboundAdapter│  │MessagingAdptr │  │ ActionAdapter │       ││
│  │  │ • 發送訊息    │  │ • 訊息處理   │  │ • 按鈕/卡片  │       ││
│  │  │ • 分塊       │  │ • 格式化     │  │ • 反應       │       ││
│  │  └───────────────┘  └───────────────┘  └───────────────┘       ││
│  └─────────────────────────────────────────────────────────────────┘│
│                                                                      │
│  ┌─────────────────────────────────────────────────────────────────┐│
│  │                     功能 Adapters                                ││
│  │  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐       ││
│  │  │ GroupAdapter  │  │ThreadingAdptr │  │ CommandAdptr  │       ││
│  │  │ • 群組管理    │  │ • 線程回覆   │  │ • 斜槓命令   │       ││
│  │  └───────────────┘  └───────────────┘  └───────────────┘       ││
│  └─────────────────────────────────────────────────────────────────┘│
│                                                                      │
│  ┌─────────────────────────────────────────────────────────────────┐│
│  │                    Gateway Adapters                              ││
│  │  ┌───────────────┐  ┌───────────────┐  ┌───────────────┐       ││
│  │  │GatewayAdapter │  │  AuthAdapter  │  │ StatusAdapter │       ││
│  │  │ • 啟動/停止   │  │ • QR 登入    │  │ • 狀態查詢   │       ││
│  │  │ • 連線管理    │  │ • Token 驗證 │  │ • 健康檢查   │       ││
│  │  └───────────────┘  └───────────────┘  └───────────────┘       ││
│  └─────────────────────────────────────────────────────────────────┘│
│                                                                      │
└─────────────────────────────────────────────────────────────────────┘

各頻道實作範例:
┌─────────────┬─────────────┬─────────────┬─────────────┐
│  Telegram   │   Discord   │   Slack     │  WhatsApp   │
├─────────────┼─────────────┼─────────────┼─────────────┤
│ Bot API     │ Bot API     │ Socket Mode │ Web Client  │
│ Webhook     │ WebSocket   │ WebSocket   │ QR 登入     │
│ 4096 chars  │ 2000 chars  │ 40000 chars │ 4096 chars  │
│ 支援線程    │ 支援線程    │ 支援線程    │ 無線程      │
└─────────────┴─────────────┴─────────────┴─────────────┘

📁 Source: src/channels/plugins/types.adapters.ts


7. 配置載入流程

程式啟動
    │
    ▼
┌───────────────────────────┐
│  尋找配置檔               │
│  ~/.openclaw/config.json5 │
└───────────┬───────────────┘
            │
            ▼
┌───────────────────────────┐
│  讀取檔案內容             │
│  (JSON5 格式)             │
└───────────┬───────────────┘
            │
            ▼
┌───────────────────────────┐
│  解析 JSON5               │
│  • 支援註解               │
│  • 支援 trailing comma    │
└───────────┬───────────────┘
            │
            ▼
┌───────────────────────────┐
│  展開環境變數             │
│  ${VAR} → 實際值          │
└───────────┬───────────────┘
            │
            ▼
┌───────────────────────────┐
│  Zod Schema 驗證          │  ← src/config/zod-schema.ts
│  • 類型檢查               │
│  • 必要欄位               │
│  • 格式驗證               │
└───────────┬───────────────┘
            │
            ├─→ 驗證失敗 → 拋出錯誤,列出問題
            │
            └─→ 驗證成功 ↓
                    │
                    ▼
┌───────────────────────────┐
│  建立 OpenClawConfig      │
│  物件                     │
└───────────┬───────────────┘
            │
            ▼
        配置可用

📁 Source: src/config/io.ts, src/config/zod-schema.ts


8. 工具執行流程

Agent 決定呼叫工具
    │
    ▼
┌───────────────────────────────────────────────────────────────┐
│                    Tool Use Request                           │
│  {                                                            │
│    "name": "browser",                                         │
│    "input": { "action": "navigate", "url": "https://..." }   │
│  }                                                            │
└───────────────────────────────────┬───────────────────────────┘
                                    │
                                    ▼
┌───────────────────────────────────────────────────────────────┐
│                    Tool Registry                               │
│  查找已註冊的工具                                              │
│  tools.find(t => t.name === "browser")                        │
└───────────────────────────────────┬───────────────────────────┘
                                    │
                                    ▼
┌───────────────────────────────────────────────────────────────┐
│                    Input Validation                            │
│  驗證輸入是否符合 inputSchema                                  │
└───────────────────────────────────┬───────────────────────────┘
                                    │
                                    ├─→ 驗證失敗 → 返回錯誤
                                    │
                                    └─→ 驗證成功 ↓
                                            │
                                            ▼
┌───────────────────────────────────────────────────────────────┐
│                    Tool Handler                                │
│  await tool.handler(input)                                     │
│                                                                │
│  ┌─────────────────────────────────────────────────────────┐  │
│  │  Browser Tool 內部:                                     │  │
│  │  1. 啟動 Playwright                                     │  │
│  │  2. 導航到 URL                                          │  │
│  │  3. 擷取頁面內容                                        │  │
│  │  4. 返回結果                                            │  │
│  └─────────────────────────────────────────────────────────┘  │
└───────────────────────────────────┬───────────────────────────┘
                                    │
                                    ▼
┌───────────────────────────────────────────────────────────────┐
│                    Tool Result                                 │
│  {                                                             │
│    "success": true,                                            │
│    "content": "Page content..."                                │
│  }                                                             │
└───────────────────────────────────┬───────────────────────────┘
                                    │
                                    ▼
                            返回給 Agent 繼續處理

📁 Source: src/agents/openclaw-tools.ts, src/agents/tools/


9. 目錄結構概覽

~/.openclaw/                         ← 主設定目錄
├── config.json5                     ← 主配置檔
├── sessions/                        ← 會話資料
│   └── {session-key}.jsonl
├── media/                           ← 媒體快取(TTL: 2分鐘)
│   └── {name}---{uuid}.{ext}
├── auth-profiles/                   ← API 金鑰管理
│   └── {provider}.json
├── agents/                          ← Agent 專屬資料
│   └── {agentId}/
│       ├── sessions/
│       └── workspace/
└── credentials/                     ← Web 服務認證


openclaw/                            ← 專案源碼
├── src/
│   ├── entry.ts                     ← 程式進入點
│   ├── index.ts                     ← 程式庫匯出
│   ├── cli/                         ← CLI 層
│   │   ├── program/                 ← Commander.js 程式
│   │   └── deps.ts                  ← 依賴注入
│   ├── gateway/                     ← Gateway(130+ 檔案)
│   │   ├── server.impl.ts           ← 主實現
│   │   └── boot.ts                  ← 啟動序列
│   ├── agents/                      ← Agent 系統(290+ 檔案)
│   │   ├── agent-scope.ts           ← 作用域解析
│   │   ├── openclaw-tools.ts        ← 工具定義
│   │   └── tools/                   ← 各工具實現
│   ├── channels/                    ← 頻道系統
│   │   ├── dock.ts                  ← 停靠定義
│   │   ├── registry.ts              ← 頻道註冊
│   │   └── plugins/                 ← Adapter 類型
│   ├── routing/                     ← 路由系統
│   │   ├── resolve-route.ts         ← 路由解析
│   │   └── session-key.ts           ← Session Key
│   ├── config/                      ← 配置系統
│   │   ├── io.ts                    ← 配置 I/O
│   │   ├── types.ts                 ← 類型定義
│   │   └── zod-schema.ts            ← 驗證 Schema
│   ├── auto-reply/                  ← 自動回覆
│   │   ├── dispatch.ts              ← 訊息分發
│   │   └── reply/                   ← 回覆邏輯
│   ├── memory/                      ← 記憶系統
│   ├── hooks/                       ← Hooks
│   ├── plugins/                     ← 插件系統
│   ├── media/                       ← 媒體處理
│   └── logging/                     ← 日誌
├── extensions/                      ← 擴展頻道
│   ├── matrix/
│   ├── msteams/
│   ├── feishu/
│   └── ...
└── docs/                            ← 文檔

架構圖集 v1.0 | 2026-02-06

OpenClaw vs Terminal + Claude Code 比較報告

深入分析兩種 AI 助手使用模式的差異,幫助你決定在什麼情況下使用哪種工具


執行摘要

面向 Terminal + Claude Code OpenClaw
最適合 複雜開發、深度程式工作 日常自動化、遠端控制
入口便利性 需 SSH 連線 任何通訊軟體
執行能力 直接、權限大 透過 Tools、受控
學習曲線 低(已熟悉 Terminal) 中(需設定 Gateway)
投資建議 持續使用 補充使用

1. 根本差異

1.1 使用模式對比

【Terminal + Claude Code】

     你                    Mac mini M4
      │                         │
      ▼                         │
  手機 Blink Shell              │
      │                         │
      ▼                         ▼
  SSH 連線 ───────────────→ Terminal
      │                         │
      ▼                         ▼
  Claude Code CLI ←──────→ 檔案系統
      │                         │
      ▼                         │
  即時互動、串流輸出            │
                                ▼
                          直接執行任務


【OpenClaw】

     你                    Mac mini M4
      │                         │
      ▼                         │
  手機 通訊軟體                  │
  (Telegram/WhatsApp/...)       │
      │                         │
      ▼                         ▼
  通訊軟體 Server ─────→ OpenClaw Gateway
      │                         │
      ▼                         ▼
  訊息 ────────────────→ Agent 執行
      │                         │
      ▼                         ▼
  收到回覆 ←───────────── 結果發送回來

1.2 核心差異表

維度 Terminal + Claude Code OpenClaw
進入點 SSH(需網路+終端機) 通訊軟體(隨時可發訊息)
啟動時間 需手動連線啟動 Gateway 常駐,隨時可用
權限範圍 完整 shell 權限 透過預定義 Tools
會話管理 tmux 可保持終端 session AI 對話跨裝置/頻道持久化
多裝置 各自獨立連線 統一入口
離線支援 無(斷線即停) 支援(訊息排隊)
輸出體驗 即時串流 完成後回傳
上下文 當前 session 跨 session 記憶
多 Agent 單一 支援多 Agent 路由

💡 注意:Terminal + Claude Code 搭配 tmux 可以保持終端機 session 不中斷(SSH 斷線後可重連)。OpenClaw 的「會話持久化」指的是 AI 對話記憶——你可以在 WhatsApp 開始對話,之後用 Telegram 繼續,AI 會記得之前的上下文。這是兩種不同層次的「持久化」。


2. 任務適用性比較

2.1 適合 Terminal + Claude Code 的任務

✅ 強烈建議使用

任務類型 原因
複雜程式開發 直接操作檔案、即時編譯測試
Git 操作 需要即時看到 diff、處理衝突
除錯 Debug 即時看到錯誤訊息、互動式除錯
重構程式碼 需要大量讀寫多個檔案
建立專案 scaffolding、初始化、安裝依賴
探索程式碼 快速瀏覽、搜尋、理解程式碼
撰寫文檔 即時預覽、多次修改
系統管理 需要即時看到系統狀態

範例場景

場景:開發新功能

你:「幫我在 user.ts 加上 email 驗證功能」

Claude Code 可以:
1. 讀取現有程式碼 → 即時顯示
2. 分析需要修改的地方 → 互動討論
3. 編輯檔案 → 你即時看到改動
4. 執行測試 → 看到測試結果
5. 修復問題 → 重新測試
6. Git commit → 你確認後提交

2.2 適合 OpenClaw 的任務

✅ 強烈建議使用

任務類型 原因
日常指令 不需要開終端機
遠端控制 在外面也能操作家中電腦
排程任務 設定後自動執行
訊息轉發 跨頻道訊息處理
簡單查詢 問天氣、查資料等
檔案下載 下載影片、資料等
網頁監控 監控網站變化、價格等
家庭自動化 控制智慧家電
通知提醒 設定提醒、發送通知

範例場景

場景:在外面臨時需要家中電腦做事

你(在 Telegram):「幫我把桌面的 report.pdf 上傳到 Google Drive」

OpenClaw:
1. 收到訊息
2. 執行上傳任務
3. 回覆:「已上傳到 Google Drive,連結:...」

你不需要:
- 找地方連 SSH
- 開終端機
- 記複雜的指令

2.3 決策流程圖

                           你要做什麼任務?
                                 │
                                 ▼
                    ┌───────────────────────┐
                    │   需要即時互動嗎?    │
                    └───────────────────────┘
                           │         │
                          是        否
                           │         │
                           ▼         ▼
              ┌─────────────────┐   ┌─────────────────┐
              │  需要看到即時   │   │   簡單指令?    │
              │  輸出/串流?    │   └─────────────────┘
              └─────────────────┘          │         │
                    │         │           是        否
                   是        否            │         │
                    │         │            ▼         ▼
                    ▼         ▼     ┌──────────┐   ┌──────────┐
          ┌────────────────────┐    │ OpenClaw │   │需要多步驟│
          │ Terminal +         │    │ 最適合   │   │複雜操作?│
          │ Claude Code        │    └──────────┘   └──────────┘
          │ 最適合             │                      │     │
          └────────────────────┘                     是    否
                    │                                 │     │
                    │                                 ▼     ▼
                    │                    ┌────────────────────────┐
                    │                    │ Terminal + Claude Code │
                    │                    │ 或 兩者皆可           │
                    │                    └────────────────────────┘
                    │
                    ▼
          ┌────────────────────┐
          │   複雜開發任務:   │
          │   • 寫程式         │
          │   • 除錯           │
          │   • Git 操作       │
          │   • 系統管理       │
          └────────────────────┘

3. 是否適合投資 OpenClaw?

3.1 投資評估

成本分析

項目 Terminal + Claude Code OpenClaw
軟體成本 免費(Claude Code 免費) 免費(開源)
API 成本 按使用量(已有) 共用同樣的 API
時間成本 低(已會用) 中(需學習設定)
維護成本 低-中(Gateway 需維護)

收益分析

收益 說明
便利性提升 隨時隨地透過通訊軟體操控電腦
自動化能力 可設定排程、觸發式任務
多頻道整合 統一管理多個通訊平台
會話持久化 自動保存對話歷史

3.2 建議投資策略

┌─────────────────────────────────────────────────────────────────┐
│                     建議:補充使用                               │
│                                                                  │
│   你目前的模式(Terminal + Claude Code)已經很強大,            │
│   不需要完全替換。建議:                                         │
│                                                                  │
│   1. 保持 Terminal + Claude Code 作為主力開發工具               │
│                                                                  │
│   2. 加入 OpenClaw 作為補充:                                   │
│      • 在外面時透過 Telegram 下簡單指令                         │
│      • 設定自動化任務                                           │
│      • 當作「緊急遙控器」                                       │
│                                                                  │
│   3. 不建議完全依賴 OpenClaw 做複雜開發                         │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

3.3 投資決策矩陣

如果你... 建議
經常在外面需要遠端操控電腦 ✅ 建議安裝 OpenClaw
想要自動化日常任務 ✅ 建議安裝 OpenClaw
主要在電腦前工作 ⚠️ 可以嘗試,但不急
只做程式開發 ❌ 維持現狀即可
想要統一多個通訊平台的 AI 助手 ✅ 建議安裝 OpenClaw

4. OpenClaw 特別厲害的應用場景

4.1 場景一:隨時隨地的遠端助手

情境:你正在通勤,突然想到要下載一個影片

傳統方式:
1. 到家後開電腦
2. 找到網址
3. 執行下載指令
4. 等待完成

OpenClaw 方式:
1. 在 Telegram 傳訊息:「幫我下載這個影片 https://...」
2. OpenClaw 在背景執行
3. 回到家,影片已經下載好了

4.2 場景二:多頻道統一管理

情境:你有 Telegram、Discord、WhatsApp 多個群組需要 AI 助手

傳統方式:
• 每個平台各自設定 bot
• 無法共享會話記憶
• 維護多套系統

OpenClaw 方式:
• 單一 Gateway 管理所有頻道
• 共享 Agent 和配置
• 可以設定不同群組用不同 Agent
• 會話記憶可跨頻道

4.3 場景三:自動化工作流

情境:每天早上自動整理並發送報告

OpenClaw 可以:
• 設定 cron 排程
• 每天早上 8:00 自動執行
• 收集資料、整理報告
• 透過 Telegram 發送給你

你不需要:
• 記得手動執行
• 開電腦等待
• 擔心忘記

4.4 場景四:智慧路由與多 Agent

情境:不同群組需要不同的 AI 行為

配置:
{
  "agents": {
    "list": [
      { "id": "general", "model": "claude-3-5-sonnet" },
      { "id": "code", "model": "claude-3-opus", "skills": ["code"] },
      { "id": "research", "model": "gpt-4", "tools": { "webSearch": true } }
    ]
  },
  "bindings": [
    { "agentId": "code", "match": { "peer": { "id": "dev-group" } } },
    { "agentId": "research", "match": { "peer": { "id": "research-group" } } }
  ]
}

效果:
• 開發群組 → 使用程式專精 Agent
• 研究群組 → 使用搜尋專精 Agent
• 其他 → 使用通用 Agent

4.5 場景五:模型回退保障

情境:API rate limit 或服務中斷

OpenClaw 自動處理:
1. 主要模型 Claude 失敗
2. 自動切換到 GPT-4
3. GPT-4 也失敗
4. 切換到本地 Ollama
5. 確保你的請求不會失敗

你不需要:
• 手動切換模型
• 擔心服務中斷
• 重試請求

5. 混合使用建議

5.1 最佳實踐

┌─────────────────────────────────────────────────────────────────┐
│                      日常工作流                                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  在電腦前:                                                      │
│  └─→ 使用 Terminal + Claude Code                                │
│      • 寫程式、除錯、Git 操作                                   │
│      • 即時互動、串流輸出                                       │
│      • 深度開發工作                                             │
│                                                                  │
│  在外面 / 離開電腦:                                            │
│  └─→ 使用 OpenClaw(Telegram)                                  │
│      • 簡單指令、查詢                                           │
│      • 下載任務                                                 │
│      • 檢查狀態                                                 │
│                                                                  │
│  自動化:                                                        │
│  └─→ 使用 OpenClaw                                              │
│      • 排程任務                                                 │
│      • 監控、通知                                               │
│                                                                  │
│  緊急情況:                                                      │
│  └─→ 使用 OpenClaw                                              │
│      • 不需要開電腦也能操控                                     │
│      • 快速處理緊急事項                                         │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

5.2 設定建議

如果決定同時使用兩者:

// OpenClaw 配置建議
{
  "agents": {
    "defaults": {
      // 使用與 Claude Code 相同的模型
      "model": "anthropic/claude-3-5-sonnet"
    },
    "list": [
      {
        "id": "main",
        "default": true,
        // 限制一些危險操作,因為是遠端控制
        "tools": {
          "shell": {
            "enabled": true,
            "allowedCommands": ["ls", "cat", "grep", "find", "curl", "wget"]
          }
        }
      }
    ]
  },
  "channels": {
    "telegram": {
      // 只允許你自己
      "dmPolicy": "allowlist",
      "allowFrom": [YOUR_USER_ID]
    }
  }
}

6. 結論

6.1 一句話總結

Terminal + Claude Code 是你的「主力開發工具」,OpenClaw 是你的「遠端遙控器」。

6.2 建議行動

步驟 行動
1 維持現有的 Terminal + Claude Code 工作流
2 安裝 OpenClaw,設定 Telegram 頻道
3 從簡單任務開始嘗試(查詢、下載)
4 逐步建立自動化任務
5 找到兩者的最佳平衡點

6.3 最終建議

┌─────────────────────────────────────────────────────────────────┐
│                                                                  │
│   ✅ Terminal + Claude Code:繼續作為主力                        │
│      • 複雜開發任務                                              │
│      • 需要即時互動的工作                                        │
│      • 在電腦前的大部分時間                                      │
│                                                                  │
│   ✅ OpenClaw:值得投資作為補充                                  │
│      • 便利性提升                                                │
│      • 遠端控制能力                                              │
│      • 自動化潛力                                                │
│      • 低風險(開源、免費)                                      │
│                                                                  │
│   ❌ 不建議:完全用 OpenClaw 取代 Claude Code                    │
│      • 複雜開發仍需直接互動                                      │
│      • 即時回饋對開發很重要                                      │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

比較報告 v1.0 | 2026-02-06

OpenClaw 快速上手指南

從零開始,5 分鐘內讓 OpenClaw 運行起來


前置需求

  • Mac mini M4(或任何可運行 Node.js 的電腦)
  • Node.js 22+ 已安裝
  • Anthropic API Key(或其他 Provider)
  • Telegram 帳號(我們用 Telegram 作為範例)

步驟 1:安裝 OpenClaw

# 全域安裝
npm install -g openclaw

# 確認安裝成功
openclaw --version

📁 Source: package.json


步驟 2:建立 Telegram Bot

  1. 在 Telegram 搜尋 @BotFather
  2. 發送 /newbot
  3. 按照指示設定 bot 名稱
  4. 記下 Bot Token(格式:123456789:ABCdefGHIjklMNOpqrsTUVwxyz

步驟 3:取得你的 Telegram User ID

  1. 在 Telegram 搜尋 @userinfobot
  2. 發送任何訊息
  3. 記下你的 User ID(純數字)

步驟 4:設定環境變數

# 編輯 shell 設定檔
nano ~/.zshrc  # 或 ~/.bashrc

# 加入以下內容
export ANTHROPIC_API_KEY="sk-ant-xxxxx"
export TELEGRAM_BOT_TOKEN="123456789:ABCdefGHIjklMNOpqrsTUVwxyz"

# 套用設定
source ~/.zshrc

步驟 5:建立配置檔

# 建立配置目錄
mkdir -p ~/.openclaw

# 建立配置檔
cat > ~/.openclaw/config.json5 << 'EOF'
{
  // Agent 配置
  "agents": {
    "defaults": {
      "model": "anthropic/claude-3-5-sonnet"
    }
  },

  // Telegram 頻道配置
  "channels": {
    "telegram": {
      "botToken": "${TELEGRAM_BOT_TOKEN}",
      // 只允許你自己(替換成你的 User ID)
      "allowFrom": [YOUR_USER_ID]
    }
  }
}
EOF

重要:把 YOUR_USER_ID 替換成步驟 3 取得的數字。


步驟 6:啟動 Gateway

# 啟動 Gateway
openclaw gateway run

# 你應該會看到類似輸出:
# [INFO] Gateway started on port 18789
# [INFO] Telegram channel connected

步驟 7:測試

  1. 在 Telegram 找到你的 Bot
  2. 發送:你好
  3. 應該會收到 AI 的回覆!

常見問題

Bot 沒有回應?

  1. 檢查 Gateway 是否運行

    openclaw health
  2. 檢查頻道狀態

    openclaw channels status
  3. 確認 User ID 正確

    • 重新用 @userinfobot 確認
    • 更新配置檔中的 allowFrom
  4. 檢查 API Key

    echo $ANTHROPIC_API_KEY

想要開機自動啟動?

方法一:使用 nohup

nohup openclaw gateway run > /tmp/openclaw.log 2>&1 &

方法二:使用 macOS LaunchAgent

# 建立 plist 檔
cat > ~/Library/LaunchAgents/ai.openclaw.gateway.plist << 'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>ai.openclaw.gateway</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/local/bin/openclaw</string>
        <string>gateway</string>
        <string>run</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
</dict>
</plist>
EOF

# 載入
launchctl load ~/Library/LaunchAgents/ai.openclaw.gateway.plist

下一步

加入更多頻道

{
  "channels": {
    "telegram": { /* ... */ },
    "discord": {
      "token": "${DISCORD_TOKEN}"
    },
    "slack": {
      "botToken": "${SLACK_BOT_TOKEN}",
      "appToken": "${SLACK_APP_TOKEN}"
    }
  }
}

設定多個 Agent

{
  "agents": {
    "list": [
      { "id": "main", "default": true },
      { "id": "code", "model": "anthropic/claude-3-opus" }
    ]
  },
  "bindings": [
    { "agentId": "code", "match": { "peer": { "id": "-100xxx" } } }
  ]
}

設定模型回退

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "anthropic/claude-3-5-sonnet",
        "fallbacks": ["openai/gpt-4", "ollama/llama3"]
      }
    }
  }
}

實用指令速查

# 查看狀態
openclaw channels status
openclaw health

# 手動發送訊息
openclaw agent -m "你好"

# 診斷問題
openclaw doctor

# 查看配置
openclaw config list

# 編輯配置
openclaw config edit

# 重新載入配置(不需重啟 Gateway)
# Gateway 會自動偵測配置變更並重新載入

進階閱讀


快速上手指南 v1.0 | 2026-02-06

OpenClaw 實際使用案例集

真實世界的應用場景和最佳實踐


案例分類

  1. 個人助手類
  2. 開發者工具類
  3. 自動化類
  4. 家庭/IoT 類
  5. 團隊協作類

個人助手類

案例 1:隨時隨地的私人助手

場景:你想要一個可以隨時透過 Telegram 聯繫的 AI 助手

配置

{
  "agents": {
    "defaults": {
      "model": "anthropic/claude-3-5-sonnet"
    }
  },
  "channels": {
    "telegram": {
      "botToken": "${TELEGRAM_BOT_TOKEN}",
      "allowFrom": [YOUR_USER_ID]
    }
  }
}

使用方式

你:今天天氣如何?
Bot:[查詢天氣 API 後回覆]

你:幫我整理明天的待辦事項
Bot:好的,讓我查看你的行事曆...

你:提醒我下午 3 點開會
Bot:已設定提醒。我會在下午 2:50 提醒你。

案例 2:多語言翻譯助手

場景:需要快速翻譯訊息

使用方式

你:翻譯成日文:明天我們要開會討論新專案
Bot:明日、新しいプロジェクトについて会議を行います。

你:這句英文什麼意思:The quick brown fox jumps over the lazy dog
Bot:這句話的意思是:敏捷的棕色狐狸跳過懶狗。這是一個包含所有英文字母的練習句。

案例 3:學習輔助

場景:用 AI 幫助學習

使用方式

你:解釋什麼是 async/await
Bot:async/await 是 JavaScript 中處理非同步操作的語法糖...
[詳細解釋 + 範例程式碼]

你:給我一個練習題
Bot:練習題:請寫一個函數,使用 async/await 從 API 獲取資料...

你:我的答案是...
Bot:讓我檢查你的程式碼...
[提供反饋和建議]

開發者工具類

案例 4:遠端程式碼助手

場景:在外面時需要在電腦上執行程式碼操作

配置

{
  "agents": {
    "list": [{
      "id": "code-agent",
      "model": "anthropic/claude-3-opus",
      "workspace": "/Users/you/projects"
    }]
  }
}

使用方式

你:幫我看一下 app/main.ts 有沒有語法錯誤
Bot:[讀取檔案,分析後回覆]
第 45 行有一個錯誤:缺少分號。

你:幫我修復
Bot:已修復。變更如下:
- 第 45 行:加入分號

案例 5:Git 操作助手

場景:透過聊天進行 Git 操作

使用方式

你:my-project 的 git status
Bot:my-project 目前狀態:
- 修改的檔案:src/index.ts, README.md
- 未追蹤:src/new-feature.ts

你:commit 這些變更,訊息是 "Add new feature"
Bot:已提交。
Commit: abc1234
Changed files: 3

你:push 到 origin
Bot:已推送到 origin/main。

案例 6:日誌監控

場景:監控伺服器日誌

配置

{
  "agents": {
    "list": [{
      "id": "monitor",
      "tools": {
        "shell": {
          "enabled": true,
          "allowedCommands": ["tail", "grep", "cat"]
        }
      }
    }]
  }
}

使用方式

你:最近有沒有錯誤日誌?
Bot:[執行 grep 'ERROR' /var/log/app.log]
發現 3 個錯誤:
1. 2024-02-06 10:30:15 - Database connection failed
2. 2024-02-06 11:45:22 - API timeout
3. 2024-02-06 14:20:33 - Out of memory

你:第一個錯誤的詳細資訊
Bot:[顯示完整日誌條目和上下文]

自動化類

案例 7:定時報告

場景:每天自動發送報告

配置(使用 cron tool)

你:每天早上 8 點幫我整理昨天的 GitHub notifications
Bot:已設定排程。每天 08:00 會自動執行並發送報告給你。

自動執行結果

Bot(每天 08:00):
📊 昨日 GitHub 報告

新的 Issues:3
- #123 Bug fix needed
- #124 Feature request
- #125 Documentation update

合併的 PR:2
- #120 Fix login bug
- #122 Add dark mode

需要你處理的:
- 請審查 #126 PR

案例 8:網站監控

場景:監控網站狀態

使用方式

你:每小時檢查 mywebsite.com 是否正常
Bot:已設定監控。如果網站異常,我會立即通知你。

當網站出問題時

Bot(自動):
⚠️ 警報!

mywebsite.com 無法訪問
- 時間:2024-02-06 15:30
- 錯誤:Connection timeout
- 持續時間:5 分鐘

建議:請檢查伺服器狀態

案例 9:檔案同步

場景:自動同步重要檔案

使用方式

你:把 ~/Documents/important 資料夾每天備份到 Google Drive
Bot:已設定自動備份。
- 時間:每天凌晨 2:00
- 來源:~/Documents/important
- 目的:Google Drive/Backup

你:現在手動執行一次
Bot:備份中...
已完成!
- 檔案數:156
- 總大小:2.3 GB
- 新增:3 個檔案
- 更新:12 個檔案

家庭/IoT 類

案例 10:智慧家庭控制

場景:透過聊天控制智慧家電

使用方式

你:開燈
Bot:已開啟客廳燈。

你:把冷氣調到 25 度
Bot:已將冷氣設定為 25°C。

你:晚安模式
Bot:已啟動晚安模式:
- 關閉客廳燈
- 臥室調暗至 30%
- 冷氣調至 26°C
- 開啟勿擾模式

案例 11:媒體下載

場景:在外面時讓電腦下載影片

使用方式

你:下載這個影片 https://youtube.com/watch?v=xxx
Bot:開始下載...
- 標題:Video Title
- 畫質:1080p
- 大小:約 500 MB

你:下載完了嗎?
Bot:已完成!
- 檔案:~/Downloads/video-title.mp4
- 大小:512 MB
- 用時:3 分 25 秒

團隊協作類

案例 12:多 Agent 路由

場景:不同群組使用不同 Agent

配置

{
  "agents": {
    "list": [
      { "id": "general", "default": true },
      { "id": "dev", "model": "claude-3-opus", "skills": ["code"] },
      { "id": "support", "model": "gpt-4", "identity": { "prompt": "你是客服助手..." } }
    ]
  },
  "bindings": [
    { "agentId": "dev", "match": { "peer": { "id": "-100dev" } } },
    { "agentId": "support", "match": { "peer": { "id": "-100support" } } }
  ]
}

效果

  • 開發群組:收到程式相關問題用 Claude Opus
  • 客服群組:收到客服問題用客服專用 prompt
  • 其他:使用通用 Agent

案例 13:知識庫問答

場景:讓 Agent 回答團隊知識庫問題

配置

{
  "agents": {
    "list": [{
      "id": "kb-agent",
      "workspace": "/path/to/knowledge-base",
      "identity": {
        "prompt": "你是團隊知識庫助手。請根據 workspace 中的文件回答問題。"
      }
    }]
  }
}

使用方式

同事:如何申請休假?
Bot:根據公司政策,申請休假的步驟如下:
1. 登入 HR 系統
2. 選擇「假期申請」
3. 填寫日期和類型
4. 提交給主管審批

詳見:docs/hr/leave-policy.md

進階使用模式

模式 1:串聯多個服務

你:幫我查今天的匯率,然後計算 1000 美金換成台幣是多少,最後發到 #finance 群組
Bot:
1. 查詢匯率中...
2. USD/TWD = 31.5
3. 1000 USD = 31,500 TWD
4. 已發送到 #finance 群組

模式 2:互動式工作流

你:幫我建立新專案

Bot:好的,我需要一些資訊:
1. 專案名稱是什麼?

你:my-awesome-project

Bot:2. 使用什麼框架?
- React
- Vue
- Svelte

你:React

Bot:3. 需要 TypeScript 嗎?

你:是

Bot:正在建立專案...
✅ 已建立:my-awesome-project
✅ 已安裝依賴
✅ 已初始化 Git

專案已準備好!路徑:~/projects/my-awesome-project

模式 3:Sub-Agent 協作

你:幫我做市場調研,然後根據結果寫一份報告

Bot:我會啟動兩個子任務:
1. 🔍 研究 Agent:收集市場資料
2. ✍️ 寫作 Agent:根據資料撰寫報告

[數分鐘後]

Bot:完成!
報告已儲存至:~/Documents/market-research-2024-02-06.pdf

摘要:
- 市場規模:$50B
- 成長率:15%/年
- 主要競爭者:A, B, C
- 建議:專注於 X 領域

最佳實踐

1. 安全配置

{
  "channels": {
    "telegram": {
      // 永遠使用白名單
      "dmPolicy": "allowlist",
      "allowFrom": [YOUR_USER_ID]
    }
  },
  "agents": {
    "list": [{
      "id": "main",
      // 限制危險命令
      "tools": {
        "shell": {
          "allowedCommands": ["ls", "cat", "grep", "find"]
        }
      }
    }]
  }
}

2. 模型回退

{
  "agents": {
    "defaults": {
      "model": {
        "primary": "anthropic/claude-3-5-sonnet",
        "fallbacks": [
          "openai/gpt-4",
          "ollama/llama3"  // 本地備援
        ]
      }
    }
  }
}

3. 工作目錄隔離

{
  "agents": {
    "list": [
      { "id": "personal", "workspace": "~/personal" },
      { "id": "work", "workspace": "~/work" }
    ]
  }
}

常見痛點與解決方案

痛點 解決方案
回覆太慢 使用更快的模型或本地 Ollama
Token 消耗高 啟用上下文壓縮
訊息被截斷 調整頻道的 chunker 設定
不記得之前的對話 啟用 memory search
執行指令不安全 設定 allowedCommands

使用案例集 v1.0 | 2026-02-06

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

目錄

  1. 分析背景
  2. Token 消耗分析框架
  3. 真實使用場景比較
  4. 工程師視角分析
  5. 本地多 Agent 架構設計
  6. 各 Agent 的 CLAUDE.md 範例
  7. MCP Server 整合建議
  8. tmux 工作流建議
  9. 成本效益分析
  10. 最終建議

分析背景

使用者情境

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

核心問題

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

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)                                       │
│   • 對成本敏感的使用者                                           │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

下一步行動

  1. 建立 Agent 目錄結構

    mkdir -p ~/agents/{calendar,dev,research,sysadmin}-agent
  2. 設定 Calendar Agent(優先)

    • 建立 CLAUDE.md
    • 配置 Google Calendar MCP
  3. 測試 Token 消耗

    • 執行相同任務
    • 比較實際 Token 使用量
  4. 配置 tmux 工作流

    • 加入快捷鍵
    • 建立啟動腳本

附錄:驗證方式

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

  1. 建立測試 Agent

    cd ~/agents/calendar-agent
    claude
    # 執行:「今天有什麼行程?」
    # 記錄 Token 使用量
  2. 比較基準

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

    節省率 = (一般專案 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"]
    }
  }
}

使用方式

你:「記一下:MCP Server 開發要注意 transport 的選擇,標籤 mcp, dev」
Agent:呼叫 add_note 工具

你:「我之前關於 mcp 的筆記有哪些?」
Agent:呼叫 search_notes { tag: "mcp" }

自動化腳本範例

每日摘要腳本

需求:「每天早上自動整理昨天的活動」

Agent 產生的腳本 (~/agents/scripts/daily-summary.sh):

#!/bin/bash
# 每日摘要產生器
# 建議 cron: 0 8 * * * ~/agents/scripts/daily-summary.sh

OUTPUT_DIR=~/agents/data/daily-summaries
TODAY=$(date +%Y-%m-%d)
YESTERDAY=$(date -v-1d +%Y-%m-%d)  # macOS
OUTPUT_FILE="$OUTPUT_DIR/$TODAY.md"

mkdir -p "$OUTPUT_DIR"

cat > "$OUTPUT_FILE" << EOF
# 每日摘要:$TODAY

## 昨日 Git 活動

$(git -C ~/projects/main-project log --oneline --since="$YESTERDAY 00:00" --until="$TODAY 00:00" 2>/dev/null || echo "無活動")

## 時間追蹤

$(bun ~/agents/tools/time-tracker.ts report 1 2>/dev/null || echo "無資料")

## 最近筆記

$(ls -lt ~/agents/data/notes/*.json 2>/dev/null | head -5 || echo "無筆記")

---
*自動產生於 $(date)*
EOF

echo "✅ 已產生:$OUTPUT_FILE"

設定 cron

# 編輯 crontab
crontab -e

# 加入這行(每天早上 8 點執行)
0 8 * * * ~/agents/scripts/daily-summary.sh

進階:工具發現與自動載入

讓 Agent 知道有哪些工具

更新 CLAUDE.md 加入工具發現機制:

# Self-Extending Agent

## 工具發現
執行以下指令查看可用工具:
\`\`\`bash
ls ~/agents/tools/*.ts | xargs -I {} basename {} .ts
\`\`\`

## 工具使用
所有工具都在 ~/agents/tools/,用 bun 執行:
\`\`\`bash
bun ~/agents/tools/<tool-name>.ts [args]
\`\`\`

## 新增工具時
1. 寫入 ~/agents/tools/<name>.ts
2. 加入使用說明註解
3. 更新 ~/agents/docs/tool-usage.md

工具使用文檔自動維護

Agent 應維護的文檔 (~/agents/docs/tool-usage.md):

# 工具使用手冊

## gh-pr-summary
- 用途:GitHub PR 摘要
- 用法:`bun gh-pr-summary.ts <owner/repo> <pr-number>`
- 範例:`bun gh-pr-summary.ts facebook/react 28000`

## time-tracker
- 用途:專案時間追蹤
- 用法:
  - `bun time-tracker.ts start <project>` - 開始
  - `bun time-tracker.ts stop` - 停止
  - `bun time-tracker.ts report [days]` - 報告

## notes (MCP)
- 用途:筆記管理
- 工具:add_note, search_notes, list_tags
- 透過 MCP 自動可用

---
*最後更新:2026-02-07*

最終架構總覽

┌─────────────────────────────────────────────────────────────────┐
│                    自我擴展 Agent 系統                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐       │
│  │   你 (SSH)   │───►│ Claude Code  │───►│   工具庫     │       │
│  └──────────────┘    └──────────────┘    └──────────────┘       │
│         │                   │                   │                │
│         │                   │                   ▼                │
│         │                   │            ┌──────────────┐       │
│         │                   │            │ MCP Servers  │       │
│         │                   │            └──────────────┘       │
│         │                   │                   │                │
│         │                   ▼                   ▼                │
│         │            ┌─────────────────────────────────┐        │
│         │            │         本地檔案系統            │        │
│         │            ├─────────────────────────────────┤        │
│         │            │  tools/     - 自訂工具          │        │
│         │            │  mcp-servers/ - MCP 擴展        │        │
│         │            │  scripts/   - 自動化腳本        │        │
│         │            │  docs/      - 累積知識          │        │
│         │            │  data/      - 持久化資料        │        │
│         │            └─────────────────────────────────┘        │
│         │                                                        │
│         │  ┌────────────────────────────────────────────┐       │
│         └─►│  cron jobs (scripts/daily-summary.sh 等)  │       │
│            └────────────────────────────────────────────┘       │
│                              │                                   │
│                              ▼                                   │
│                    ┌──────────────────┐                         │
│                    │  完全自動執行    │                         │
│                    │  (零 Token 消耗) │                         │
│                    └──────────────────┘                         │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

與 OpenClaw 的最終比較

面向 OpenClaw 自我擴展本地 Agent
架構 中心化 Gateway 分散式本地工具
擴展方式 安裝插件 Agent 即時寫 code
Token 效率 每次請求固定 overhead 工具寫好後幾乎免費
持久化 Gateway 管理 直接本地檔案
自動化 內建 Cron 系統 cron + 腳本
學習曲線 學習 OpenClaw 生態 就是寫 TypeScript
客製化 受限插件 API 無限制
版本控制 需額外設定 天然支援 Git
遷移性 綁定 OpenClaw 純檔案,隨時遷移
適合對象 非技術用戶 工程師

結論

┌─────────────────────────────────────────────────────────────────┐
│                                                                  │
│   對工程師而言,自我擴展本地 Agent 是最佳選擇                   │
│                                                                  │
│   核心優勢:                                                     │
│                                                                  │
│   1. 無限彈性 — 任何需求都可以寫 code 解決                      │
│   2. 成本遞減 — 工具越多,Token 效益越高                        │
│   3. 完全控制 — 程式碼、資料、文檔都在你手上                    │
│   4. 持續進化 — Agent 可以改進自己的工具                        │
│   5. 知識累積 — 文檔和決策記錄持久保存                          │
│                                                                  │
│   這不只是「多個專用 Agent」,而是一個:                        │
│                                                                  │
│   ╔═══════════════════════════════════════════════════════╗     │
│   ║  會自我擴展、持續進化、成本遞減的個人 AI 系統        ║     │
│   ╚═══════════════════════════════════════════════════════╝     │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

文件建立日期:2026-02-07 最後更新:2026-02-07

OpenClaw 研究報告

深度分析 OpenClaw 開源 AI Agent 系統


📚 文件索引

文件 說明 閱讀時間
00-complete-guide.md 完整架構指南 - 詳盡的 OpenClaw 文檔 30-45 分鐘
01-cheatsheet.md 命令速查表 - 常用命令與配置 5 分鐘
02-faq.md 常見問題 - FAQ 格式 10 分鐘
03-architecture-diagrams.md 架構圖集 - 視覺化流程圖 15 分鐘
04-comparison-report.md 比較報告 - OpenClaw vs Claude Code 15 分鐘
05-quickstart.md 快速上手 - 5 分鐘開始使用 5 分鐘
06-use-cases.md 使用案例 - 實際應用場景 20 分鐘
07-engineer-deep-comparison.md 工程師深度比較 - 本地多 Agent vs OpenClaw 25 分鐘

🎯 閱讀建議

如果你時間有限(15 分鐘)

  1. 先看 04-comparison-report.md 了解核心差異
  2. 瀏覽 01-cheatsheet.md 快速掌握

如果你是工程師想做決策(30 分鐘)⭐ 推薦

  1. 直接看 07-engineer-deep-comparison.md 深度比較分析
  2. 包含:
    • Token 消耗估算與成本效益分析
    • 自我擴展 Agent 系統架構設計
    • 具體工具範例(TypeScript 程式碼)
    • MCP Server 開發模板
    • 自動化腳本與 cron 設定

如果你想快速上手(30 分鐘)

  1. 05-quickstart.md 安裝設定
  2. 06-use-cases.md 了解用法
  3. 備查 01-cheatsheet.md

如果你想完全理解(1-2 小時)

  1. 完整閱讀 00-complete-guide.md
  2. 搭配 03-architecture-diagrams.md 理解架構
  3. 有問題查 02-faq.md

📋 研究結論摘要

OpenClaw 是什麼?

  • 開源的 AI Agent 系統
  • 透過通訊軟體(Telegram、Discord、WhatsApp 等)操控電腦
  • 可執行 shell 命令、檔案操作、網頁自動化

與 Terminal + Claude Code 的差異

面向 Terminal + Claude Code OpenClaw
入口 SSH 連線 通訊軟體
最適合 複雜開發 日常自動化
會話 手動管理 自動持久化
便利性 需要終端機 隨時可用

投資建議

對工程師:建立「自我擴展本地 Agent 系統」— 讓 Agent 自己寫工具、MCP Server、自動化腳本。工具越多,Token 效益越高,形成持續進化的個人 AI 系統。

OpenClaw 備用:僅在需要非工程師使用、多頻道整合、或複雜排程時考慮。


🔗 相關連結


研究日期:2026-02-06

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment