總字數：約28000字 | 預計閱讀時長：80-90分鐘​

一、Agent智慧體架構概述​

1.1 什麼是Agent智慧體​

Agent智慧體（AI Agent） 是一種能夠自主感知環境、制定計劃、執行任務並從經驗中學習的智慧系統。與傳統的"輸入-輸出"式AI應用不同，Agent具備自主性、適應性和持續性，能夠像人類一樣思考、決策和行動。​

簡單來說，如果把大模型比作一個"聰明的大腦"，那麼Agent就是給這個大腦裝上了"眼睛"（感知）、"手腳"（執行）和"記憶"（學習），讓它能夠獨立完成複雜任務。​

Agent的核心特徵：​

​



| 特徵 | 說明 | 示例 |
| --- | --- | --- |
| 自主性 | 無需人工幹預，自主決策 | 自動分析安全日誌並生成報告 |
| 適應性 | 根據環境變化調整策略 | 發現新威脅時自動更新檢測規則 |
| 持續性 | 長期執行，積累經驗 | 持續監控網路流量，學習正常模式 |
| 社會性 | 與其他Agent或人類協作 | 多個安全Agent協同防禦 |



​

一個直觀的比喻：​

想象你僱傭了一個安全分析師：​

•

傳統AI：你問一句，它答一句，像一個"問答機器人"​

•

Agent智慧體：你給它一個任務（"監控公司網路安全"），它會自主安排工作、處理異常、彙報結果，像一個"智慧助手"​

1.2 Agent與傳統AI應用的區別​

傳統AI應用和Agent智慧體在架構和能力上存在本質差異：​

​



| 對比維度 | 傳統AI應用 | Agent智慧體 |
| --- | --- | --- |
| 互動模式 | 單輪問答，被動響應 | 多輪對話，主動執行 |
| 任務處理 | 單一任務，線性流程 | 複雜任務，動態規劃 |
| 工具使用 | 無或有限 | 自主選擇和呼叫工具 |
| 記憶能力 | 無狀態或短期記憶 | 長期記憶，經驗積累 |
| 錯誤處理 | 失敗即終止 | 自我反思，調整重試 |
| 協作能力 | 獨立執行 | 多Agent協作 |



​

傳統AI應用的工作流程：​

​

Code block​

Plain Text

使用者輸入 → 模型處理 → 輸出結果 → 結束​

​

Agent智慧體的工作流程：​

​

Code block​

Plain Text

使用者目標 → 感知環境 → 制定計劃 → 執行任務 → 觀察結果 → 反思調整 → 繼續執行​

↑ ↓​

└──────────────────── 迴圈迭代 ────────────────────────────────┘​

​

1.3 Agent在安全領域的價值​

在網路安全領域，Agent智慧體正在重塑安全運營的方式：​

傳統安全運營的痛點：​

​



| 痛點 | 具體表現 | Agent解決方案 |
| --- | --- | --- |
| 告警疲勞 | 每天數千條告警，人工難以處理 | Agent自動分類、過濾、優先順序排序 |
| 響應延遲 | 從發現到處置需要數小時 | Agent實時響應，秒級處置 |
| 知識孤島 | 安全知識分散在不同系統 | Agent整合多源知識，統一分析 |
| 人才短缺 | 安全專家供不應求 | Agent輔助決策，降低門檻 |



​

Agent在安全場景中的應用：​

1）威脅檢測Agent：實時監控網路流量，自動識別異常行為​

2）漏洞分析Agent：自動分析漏洞詳情，提供修復建議​

3）應急響應Agent：發現攻擊後自動隔離、取證、修復​

4）安全審計Agent：自動檢查配置合規性，生成審計報告​

行業案例：​

2025年，多家安全廠商釋出了基於Agent的安全運營平臺。例如，某大型金融機構部署了AI Agent後，告警處理效率提升了80%，平均響應時間從4小時縮短到15分鐘。​

二、Agent核心架構​

2.1 Agent架構模型​

Agent智慧體的核心架構可以概括為\*\*"感知-規劃-執行-記憶"\*\*四層模型：​

​

Code block​

Plain Text

┌─────────────────────────────────────────────────────────┐​

│ Agent智慧體架構 │​

├─────────────────────────────────────────────────────────┤​

│ ┌─────────────────────────────────────────────────────┐ │​

│ │ 感知層（Perception） │ │​

│ │ 輸入解析 → 環境感知 → 資訊提取 → 上下文構建 │ │​

│ └─────────────────────────────────────────────────────┘ │​

├─────────────────────────────────────────────────────────┤​

│ ┌─────────────────────────────────────────────────────┐ │​

│ │ 規劃層（Planning） │ │​

│ │ 目標分解 → 任務排序 → 資源分配 → 策略選擇 │ │​

│ └─────────────────────────────────────────────────────┘ │​

├─────────────────────────────────────────────────────────┤​

│ ┌─────────────────────────────────────────────────────┐ │​

│ │ 執行層（Execution） │ │​

│ │ 工具呼叫 → 程式碼執行 → API互動 → 結果收集 │ │​

│ └─────────────────────────────────────────────────────┘ │​

├─────────────────────────────────────────────────────────┤​

│ ┌─────────────────────────────────────────────────────┐ │​

│ │ 記憶層（Memory） │ │​

│ │ 短期記憶 → 長期記憶 → 經驗總結 → 知識更新 │ │​

​

各層職責詳解：​

​



| 層次 | 核心職責 | 關鍵技術 | 安全場景示例 |
| --- | --- | --- | --- |
| 感知層 | 理解使用者意圖和環境狀態 | NLP、意圖識別、實體提取 | 解析安全告警、提取威脅指標 |
| 規劃層 | 分解任務、制定執行計劃 | 任務分解、優先順序排序、資源排程 | 制定應急響應流程、分配處置任務 |
| 執行層 | 呼叫工具完成具體操作 | 工具呼叫、程式碼執行、API整合 | 隔離受感染主機、更新防火牆規則 |
| 記憶層 | 儲存和檢索歷史資訊 | 向量資料庫、摘要、檢索 | 儲存歷史攻擊模式、檢索相似案例 |



​

2.2 感知層（Perception）​

感知層是Agent與外部世界的介面，負責理解使用者意圖和環境狀態。​

1）輸入解析​

Agent需要理解使用者的自然語言輸入，提取關鍵資訊：​

​

Code block​

Python

\# input\_parser.py​

\# pip install langchain-deepseek​

​

from langchain\_deepseek import ChatDeepSeek​

​

2）環境感知​

Agent需要感知當前環境狀態，包括系統狀態、網路狀態、安全態勢等：​

​

Code block​

Python

​

2.3 規劃層（Planning）​

規劃層是Agent的"大腦"，負責將複雜任務分解為可執行的子任務。​

1）任務分解​

Agent需要將高層目標分解為具體的執行步驟：​

​

Code block​

Python

\# task\_planner.py​

\# pip install langchain-deepseek​

​

from langchain\_deepseek import ChatDeepSeek​

from langchain\_core.prompts import ChatPromptTemplate​

from langchain\_core.output\_parsers import JsonOutputParser​

from pydantic import BaseModel, Field​

from typing import List, Optional​

from enum import Enum​

​

class TaskStatus(str, Enum):​

PENDING = "pending"​

IN\_PROGRESS = "in\_progress"​

COMPLETED = "completed"​

FAILED = "failed"​

​

class SubTask(BaseModel):​

"""子任務"""​

id: str = Field(description="任務ID")​

name: str = Field(description="任務名稱")​

description: str = Field(description="任務描述")​

dependencies: List\[str\] = Field(description="依賴的任務ID列表")​

estimated\_time: int = Field(description="預計耗時（分鐘）")​

required\_tools: List\[str\] = Field(description="需要的工具列表")​

status: TaskStatus = Field(default=TaskStatus.PENDING)​

​

class TaskPlan(BaseModel):​

"""任務計劃"""​

goal: str = Field(description="總體目標")​

subtasks: List\[SubTask\] = Field(description="子任務列表")​

total\_estimated\_time: int = Field(description="總預計耗時")​

risk\_level: str = Field(description="風險等級：low/medium/high")​

​

2）策略選擇​

根據任務特點選擇合適的執行策略：​

​



| 策略型別 | 適用場景 | 特點 | 示例 |
| --- | --- | --- | --- |
| 順序執行 | 任務有明確先後依賴 | 穩定可靠，易於除錯 | 漏洞掃描→分析→修復 |
| 並行執行 | 獨立任務可同時進行 | 效率高，節省時間 | 同時掃描多個系統 |
| 迭代執行 | 需要反覆最佳化的任務 | 質量高，但耗時長 | 滲透測試→修復→再測試 |
| 條件執行 | 根據中間結果決定下一步 | 靈活適應，動態調整 | 發現高危漏洞→立即響應 |



​

​

Code block​

Python

​

2.4 執行層（Execution）​

執行層負責呼叫各種工具來完成具體任務。​

1）工具註冊與管理​

Agent需要一個統一的工具管理系統：​

​

Code block​

Python

​

2）工具呼叫示例​

​

Code block​

Python

​

2.5 記憶層（Memory）​

記憶層是Agent的"經驗庫"，負責儲存和檢索歷史資訊。​

1）記憶型別​

​



| 記憶型別 | 儲存內容 | 生命週期 | 實現方式 |
| --- | --- | --- | --- |
| 短期記憶 | 當前對話上下文 | 會話級別 | 對話歷史列表 |
| 長期記憶 | 歷史經驗、知識 | 持久化 | 向量資料庫 |
| 工作記憶 | 當前任務狀態 | 任務級別 | 記憶體資料結構 |
| 情景記憶 | 具體事件記錄 | 持久化 | 結構化儲存 |



​

2）記憶管理器實現​

​

Code block​

Python

\# memory\_manager.py​

\# pip install langchain-deepseek faiss-cpu​

​

from langchain\_deepseek import DeepSeekEmbeddings, ChatDeepSeek​

from langchain\_core.messages import HumanMessage, AIMessage, SystemMessage​

from langchain\_community.vectorstores import FAISS​

from typing import List, Dict, Any​

from datetime import datetime​

import json​

import os​

​

class MemoryManager:​

"""記憶管理器"""​

​

def \_\_init\_\_(self, api\_key: str):​

self.embeddings = DeepSeekEmbeddings(​

model="deepseek-embedding",​

api\_key=api\_key​

)​

self.llm = ChatDeepSeek(​

model="deepseek-chat",​

api\_key=api\_key,​

temperature=0​

​

3）記憶增強的Agent​

​

Code block​

Python

​

三、ReAct推理正規化​

3.1 什麼是ReAct​

ReAct（Reasoning + Acting） 是一種結合推理和行動的Agent正規化，由Yao等人在2022年提出。它讓Agent能夠像人類一樣，邊思考邊行動，而不是先想好再做。​

ReAct的核心思想：​

​

Code block​

Plain Text

​

ReAct與傳統Agent的區別：​

​



| 對比維度 | 傳統Agent | ReAct Agent |
| --- | --- | --- |
| 決策方式 | 一次性決策 | 邊思考邊決策 |
| 執行模式 | 預先規劃，然後執行 | 動態調整，實時最佳化 |
| 錯誤處理 | 失敗後重新規劃 | 觀察錯誤，立即調整 |
| 透明度 | 黑盒，難以解釋 | 思考過程可見，可解釋 |



​

3.2 ReAct實現​

​

Code block​

Python

​

3.3 ReAct在安全場景中的應用​

1）威脅分析場景​

​

Code block​

Plain Text

使用者：分析IP 192.168.1.100的安全威脅​

​

Thought: 使用者想了解一個IP地址的安全威脅情況，我需要先查詢威脅情報資料庫​

Action: query\_threat\_intelligence​

Action Input: {"indicator": "192.168.1.100", "indicator\_type": "ip"}​

​

Observation: {"threat\_level": "high", "threat\_type": "C2 Server", "associated\_malware": \["Emotet"\]}​

​

Thought: 這個IP被標記為C2伺服器，威脅等級很高。我還需要檢查這個IP在我們的日誌中是否有活動記錄​

Action: analyze\_security\_log​

Action Input: {"log\_content": "搜尋包含192.168.1.100的所有日誌"}​

​

2）漏洞響應場景​

​

Code block​

Plain Text

使用者：發現Log4j漏洞，幫我制定修復計劃​

​

Thought: Log4j是一個嚴重的遠端程式碼執行漏洞，我需要先了解漏洞詳情，然後掃描受影響的系統​

Action: scan\_vulnerability​

Action Input: {"target": "192.168.1.0/24", "scan\_type": "full"}​

​

四、多智慧體協作​

4.1 多智慧體系統概述​

多智慧體系統（Multi-Agent System, MAS） 是由多個Agent組成的協作系統，每個Agent負責特定的任務，透過協作完成複雜目標。​

為什麼需要多智慧體？​

​



| 單Agent侷限 | 多Agent優勢 |
| --- | --- |
| 能力有限，難以處理複雜任務 | 分工協作，各司其職 |
| 單點故障，可靠性低 | 冗餘設計，容錯性強 |
| 擴充套件性差，難以適應新需求 | 模組化設計，易於擴充套件 |
| 資源競爭，效率低下 | 並行處理，效率高 |



​

4.2 多智慧體架構模式​

1）主從模式（Master-Slave）​

​

Code block​

Plain Text

┌─────────────────────────────────────┐​

│ 主Agent（Master） │​

│ 任務分配 → 結果整合 → 決策輸出 │​

└──────────────┬──────────────────────┘​

│​

┌──────────┼──────────┐​

│ │ │​

▼ ▼ ▼​

┌───────┐ ┌───────┐ ┌───────┐​

│ Agent1 │ │ Agent2 │ │ Agent3 │​

│ 日誌 │ │ 漏洞 │ │ 威脅 │​

│ 分析 │ │ 掃描 │ │ 情報 │​

└───────┘ └───────┘ └───────┘​

​

特點：​

•

主Agent負責任務分配和結果整合​

•

從Agent執行具體任務​

•

結構清晰，易於管理​

•

主Agent是單點故障​

2）對等模式（Peer-to-Peer）​

​

Code block​

Plain Text

┌─────────┐ ┌─────────┐ ┌─────────┐​

│ Agent A │◄──►│ Agent B │◄──►│ Agent C │​

│ 檢測 │ │ 分析 │ │ 響應 │​

​

特點：​

•

Agent之間平等協作​

•

無中心節點，更健壯​

•

需要協調機制​

•

適合分散式場景​

3）層級模式（Hierarchical）​

​

Code block​

Plain Text

​

特點：​

•

三層架構：戰略層、戰術層、執行層​

•

職責分明，逐級細化​

•

適合大型複雜系統​

•

通訊開銷較大​

4.3 多智慧體實現​

​

Code block​

Python

​

4.4 LangGraph多智慧體實現​

LangGraph是構建有狀態多智慧體應用的理想框架（詳見3.2章節）。以下是使用LangGraph實現安全多智慧體系統的示例：​

​

Code block​

Python

​

五、Agent安全應用場景​

5.1 安全運營中心（SOC）Agent​

1）場景描述​

安全運營中心（SOC）是企業安全的核心，負責監控、檢測和響應安全威脅。Agent可以自動化SOC的許多工。​

2）Agent架構​

​

Code block​

Plain Text

┌─────────────────────────────────────────────────────────┐​

│ SOC Agent系統 │​

├─────────────────────────────────────────────────────────┤​

│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │​

│ │ 監控Agent │ │ 分析Agent │ │ 響應Agent │ │​

│ │ - 日誌監控 │ │ - 威脅分析 │ │ - 自動處置 │ │​

│ │ - 告警檢測 │ │ - 關聯分析 │ │ - 通知告警 │ │​

│ │ - 流量分析 │ │ - 情報查詢 │ │ - 取證記錄 │ │​

│ └─────────────┘ └─────────────┘ └─────────────┘ │​

├─────────────────────────────────────────────────────────┤​

│ ┌─────────────────────────────────────────────────────┐ │​

│ │ 協調Agent │ │​

│ │ 任務分配 → 優先順序管理 → 結果整合 → 報告生成 │ │​

│ └─────────────────────────────────────────────────────┘ │​

└─────────────────────────────────────────────────────────┘​

​

3）實現示例​

​

Code block​

Python

​

5.2 滲透測試Agent​

1）場景描述​

滲透測試Agent可以自動化執行滲透測試任務，包括資訊收集、漏洞掃描、漏洞利用和報告生成。​

2）Agent工作流程​

​

Code block​

Plain Text

​

3）實現示例​

​

Code block​

Python

​

六、Agent最佳實踐​

6.1 Agent設計原則​

1）單一職責原則​

每個Agent應該只負責一個特定的任務領域：​

​



| Agent型別 | 職責範圍 | 避免的職責 |
| --- | --- | --- |
| 檢測Agent | 發現威脅 | 不負責響應處置 |
| 分析Agent | 深度分析 | 不負責執行操作 |
| 響應Agent | 執行處置 | 不負責威脅發現 |



​

2）松耦合原則​

Agent之間應該透過訊息傳遞進行協作，避免直接依賴：​

​

Code block​

Python

\# 好的做法：透過訊息佇列通訊​

class AgentA:​

def send\_to\_b(self, message):​

message\_queue.send("agent\_b", message)​

​

\# 不好的做法：直接呼叫​

class AgentA:​

def process(self):​

agent\_b = AgentB()​

​

3）可觀測性原則​

Agent的決策過程應該是透明和可解釋的：​

​

Code block​

Python

​

6.2 常見問題與解決方案​

1）Agent陷入迴圈​

問題描述：Agent在某些情況下會陷入無限迴圈，反覆執行相同的操作。​

解決方案：​

​

Code block​

Python

​

2）工具呼叫失敗​

問題描述：工具呼叫失敗導致Agent任務中斷。​

解決方案：​

​

Code block​

Python

class RobustAgent:​

def execute\_tool\_with\_retry(self, tool\_name, params, max\_retries=3):​

for attempt in range(max\_retries):​

try:​

result = self.tools.execute\_tool(tool\_name, params)​

if result.success:​

return result​

else:​

self.log(f"工具呼叫失敗: {result.error}")​

except Exception as e:​

self.log(f"工具呼叫異常: {e}")​

​

if attempt < max\_retries - 1:​

time.sleep(2 \*\* attempt) \# 指數退避​

​

​

3）記憶膨脹​

問題描述：隨著執行時間增長，Agent的記憶不斷膨脹，影響效能。​

解決方案：​

​

Code block​

Python

​

6.3 效能最佳化​

1）並行執行​

對於獨立的任務，可以並行執行以提高效率：​

​

Code block​

Python

​

2）快取機制​

快取常用的查詢結果，減少重複計算：​

​

Code block​

Python

​

3）批次處理​

將多個小任務合併為批次處理：​

​

Code block​

Python

​

六、開源Agent架構原始碼分析​

在1.6章節中，我們介紹了OpenClaw、Hermes Agent等開源Agent的特性和使用場景。本節將深入分析它們的底層架構和原始碼實現，幫助你理解這些Agent系統的設計決策。​

6.1 OpenClaw架構原始碼分析​

1）整體架構​

OpenClaw採用分層架構設計，核心是Gateway服務：​

​

Code block​

Plain Text

┌─────────────────────────────────────────────────────────┐​

│ OpenClaw Gateway │​

│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │​

│ │ 會話管理 │ │ 工具排程 │ │ 技能引擎 │ │​

│ └─────────────┘ └─────────────┘ └─────────────┘ │​

└─────────────────────────────────────────────────────────┘​

│ │ │​

┌────┴────┐ ┌────┴────┐ ┌────┴────┐​

​

核心元件：​

•

路由層：根據訊息來源和內容，分發到對應的處理模組​

•

會話管理：維護使用者對話狀態，支援多輪互動​

•

工具外掛：透過統一介面接入各種外部工具和服務​

•

Agent子系統：支援多個Agent協同工作​

2）會話管理模組原始碼​

核心檔案：src/sessions/session-manager.ts​

​

Code block​

TypeScript

​

設計亮點：​

•

三層記憶系統：短期會話上下文 + 長期精選記憶 + 每日原始記錄​

•

懶載入：上下文按需載入，避免記憶體佔用​

•

可持久化：會話可配置保留天數​

3）工具排程模組原始碼​

核心檔案：src/tools/tool-executor.ts​

​

Code block​

TypeScript

// 工具執行器核心邏輯​

class ToolExecutor {​

private tools: Map<string, Tool\>;​

private approvals: ApprovalConfig;​

​

async execute(toolName: string, params: any): Promise<any\> {​

const tool = this.tools.get(toolName);​

if (!tool) throw new Error(\`Tool ${toolName} not found\`);​

​

​

設計亮點：​

•

許可權控制：支援細粒度的許可權配置​

•

執行記錄：完整的執行歷史，便於審計和除錯​

•

錯誤處理：統一的錯誤處理機制​

4）Agent Loop核心流程​

OpenClaw的Agent Loop採用ReAct正規化：​

​

Code block​

TypeScript

​

架構特點：​

•

模組化設計：各元件獨立，可插拔​

•

工具中立：支援50+ AI模型自由切換​

•

渠道統一：20+平臺統一管理​

•

本地優先：資料儲存在使用者裝置​

6.2 Hermes Agent架構原始碼分析​

1）整體架構​

Hermes Agent採用自進化架構，核心是Self-Improvement Loop：​

​

Code block​

Plain Text

┌─────────────────────────────────────────────────────────┐​

│ Hermes Agent Runtime │​

│ ┌─────────────────────────────────────────────────────┐ │​

│ │ AIAgent (run\_agent.py) │ │​

│ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ │​

│ │ │ Prompt │ │ Provider │ │ Tool │ │ │​

│ │ │ Builder │ │ Resolution │ │ Dispatch │ │ │​

│ │ └──────────────┘ └──────────────┘ └──────────────┘ │ │​

│ └─────────────────────────────────────────────────────┘ │​

│ ┌─────────────────────────────────────────────────────┐ │​

│ │ Memory System (四層) │ │​

│ │ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │ │​

│ │ │ 會話記憶 │ │ 情景記憶 │ │ 語義記憶 │ │ │​

│ │ │ (記憶體) │ │ (SQLite FTS5)│ │ (向量資料庫) │ │ │​

│ │ └──────────────┘ └──────────────┘ └──────────────┘ │ │​

│ └─────────────────────────────────────────────────────┘ │​

│ ┌─────────────────────────────────────────────────────┐ │​

│ │ Skill Engine (自動生成) │ │​

│ └─────────────────────────────────────────────────────┘ │​

└─────────────────────────────────────────────────────────┘​

│​

┌────┴────┐​

│LLM API │​

└─────────┘​

​

2）目錄結構​

​

Code block​

Plain Text

hermes-agent/​

├── run\_agent.py # AIAgent類 - 核心對話迴圈​

├── model\_tools.py # 工具編排、\_discover\_tools()、handle\_function\_call()​

├── toolsets.py # 工具集定義、\_HERMES\_CORE\_TOOLS列表​

├── cli.py # HermesCLI類 - 互動式CLI編排器​

├── hermes\_state.py # SessionDB - SQLite會話儲存（FTS5搜尋）​

├── agent/ # Agent內部模組​

│ ├── prompt\_builder.py # 系統提示片語裝​

│ ├── context\_compressor.py # 自動上下文壓縮​

│ ├── prompt\_caching.py # Anthropic提示詞快取​

│ ├── auxiliary\_client.py # 輔助LLM客戶端（視覺、摘要）​

│ └── memory\_manager.py # 記憶管理器​

├── tools/ # 工具實現（每個工具一個檔案）​

│ ├── registry.py # 中心工具登錄檔​

│ ├── terminal\_tool.py # 終端編排​

│ ├── file\_tools.py # 檔案讀寫搜尋​

│ └── mcp\_tool.py # MCP客戶端（~1050行）​

├── gateway/ # 訊息平臺閘道器​

│ ├── run.py # 主迴圈、訊息分發​

│ └── platforms/ # 介面卡：telegram、discord、slack、whatsapp​

└── cron/ # 排程器​

​

3）AIAgent核心類​

核心檔案：run\_agent.py​

​

Code block​

Python

class AIAgent:​

def \_\_init\_\_(self,​

​

4）四層記憶系統​

核心檔案：hermes\_state.py​

​

Code block​

Python

​

記憶層級：​

•

會話記憶：當前對話的上下文（記憶體）​

•

情景記憶：跨會話的互動歷史（SQLite FTS5）​

•

語義記憶：從多次互動中提煉的通用知識（向量資料庫）​

•

技能記憶：成功任務自動提煉為可複用Skill（~/.hermes/skills/）​

5）技能自動生成機制​

Hermes的閉環學習迴圈（Closed Learning Loop）：​

​

Code block​

Python

class SkillGenerator:​

"""技能自動生成器"""​

​

def should\_generate\_skill(self, trajectory: dict) -> bool:​

"""判斷是否應該生成技能"""​

\# 條件1：工具呼叫次數 >= 5​

if trajectory\['tool\_calls'\] >= 5:​

​

6.3 Claude Code架構原始碼分析（洩露版本）​

2026年3月31日，Anthropic意外將Claude Code的完整原始碼打包進了npm釋出包。51萬行TypeScript程式碼，1902個檔案，所有設計決策一覽無餘。這是AI工具領域最重大的意外洩露事件。​

1）架構全景​

​



| 指標 | 數值 |
| --- | --- |
| 語言 | TypeScript (100%) |
| 執行時 | Bun |
| UI框架 | 自定義React終端渲染器 |
| 檔案數量 | 1,884 |
| 程式碼行數 | ~512,000 |
| 主入口檔案 | 803KB (main.tsx) |
| 內建工具 | 80+ |
| 頂層模組 | 35 |



​

2）核心模組結構​

​

Code block​

Plain Text

claude-code/​

├── main.tsx # 主入口（803KB）​

├── QueryEngine.ts # 查詢引擎（46,000行）​

├── Tool.ts # 工具定義（29,000行）​

​

3）雙層查詢引擎設計​

Claude Code的LLM互動迴圈分為兩層：​

外層：QueryEngine.ts（1,295行）​

•

Agent控制：重試、預算執行、許可權檢查、最大輪次限制​

•

預算跟蹤：跟蹤總USD成本、API持續時間、快取讀取/建立token​

內層：query.ts（1,729行）​

•

機制實現：系統提示片語裝、訊息歷史管理、API流式傳輸、Hook執行、工具結果收集​

​

Code block​

TypeScript

// QueryEngine核心邏輯（簡化版）​

class QueryEngine {​

private budget: BudgetTracker;​

private permissionChecker: PermissionChecker;​

​

async run(task: string): Promise<QueryResult\> {​

const messages = \[{ role: 'user', content: task }\];​

​

while (true) {​

​

4）三層許可權系統​

Claude Code的許可權系統採用三層架構：​

​



| 層級 | 機制 | 說明 |
| --- | --- | --- |
| Tier 1 | 規則快速路徑 | 模式匹配（glob和正則），分類：always-allow、always-ask、always-deny |
| Tier 2 | ML分類器 | 呼叫Claude API判斷bash命令或檔案編輯是否危險 |
| Tier 3 | 使用者提示 | 互動式審批對話方塊，支援計劃模式預覽 |



​

​

Code block​

TypeScript

// 許可權檢查流程（簡化版）​

async function checkPermission(toolCall: ToolCall): Promise<boolean\> {​

// Tier 1: 規則快速路徑​

const ruleResult = await checkRules(toolCall);​

if (ruleResult !== 'ambiguous') {​

return ruleResult === 'allow';​

}​

​

// Tier 2: ML分類器​

if (featureFlags.has('BASH\_CLASSIFIER')) {​

const mlResult = await classifyWithML(toolCall);​

​

5）上下文壓縮策略​

Claude Code實現了三種壓縮策略：​

​



| 策略 | 觸發條件 | 預算 | 說明 |
| --- | --- | --- | --- |
| MicroCompact | 區域性清理 | \- | 清理區域性上下文 |
| AutoCompact | 接近上下文限制 | 13K緩衝 + 20K摘要 | 摘要觸發，帶斷路器 |
| FullCompact | 緊急情況 | 50K預算 | 選擇性重新注入 |



​

6）Harness Engineering方法論​

Claude Code的原始碼揭示了一個新興學科：Harness Engineering。​

核心觀點：AI Agent好不好用，不只取決於底層模型多強，更取決於圍繞模型搭建的那套系統有多好。這套系統叫harness（籠具），包括：​

•

工具呼叫​

•

許可權控制​

•

記憶管理​

•

上下文壓縮​

•

安全護欄​

•

多Agent協調​

關鍵資料：Claude Code好用，60%靠模型能力，40%靠harness工程。​

7）設計決策的"為什麼"​

​



| 設計選擇 | 為什麼 |
| --- | --- |
| 搜尋用grep不用RAG | LLM夠聰明，grep更快更可靠 |
| 記憶系統只記偏好不記程式碼 | 程式碼變化快，記了反而有害 |
| 許可權分類器用兩階段 | 第一階段用64 token就能放行大部分操作 |
| 選Bun不選Node.js | 啟動速度快，原生TypeScript支援 |
| 自定義終端渲染器 | 需要精細控制渲染效能和互動體驗 |



​

6.4 三大Agent架構對比​

​



| 對比維度 | OpenClaw | Hermes Agent | Claude Code |
| --- | --- | --- | --- |
| 語言 | TypeScript | Python | TypeScript |
| 執行時 | Node.js | Python | Bun |
| 架構模式 | Gateway閘道器 | 自進化閉環 | Harness工程 |
| 記憶系統 | Markdown檔案 | SQLite FTS5 + 向量資料庫 | 記憶體 + 檔案引用 |
| 工具數量 | 13,700+技能 | 70+內建 | 80+內建 |
| 許可權系統 | 使用者配置 | 預設審批 | 三層架構 |
| 上下文壓縮 | 無 | 自動摘要 | 三種策略 |
| 開源程度 | 完全開源 | 完全開源 | 原始碼洩露 |



​

七、總結與展望​

7.1 核心要點回顧​

本文系統介紹了Agent智慧體架構的核心概念、技術實現和安全應用場景：​

1）Agent架構四層模型：感知層、規劃層、執行層、記憶層，每層都有明確的職責和技術實現​

2）ReAct推理正規化：邊思考邊行動，讓Agent的決策過程更加透明和可解釋​

3）多智慧體協作：透過主從、對等、層級等模式，實現複雜任務的分工協作​

4）安全應用場景：SOC運營、滲透測試、威脅分析等，Agent正在重塑安全工作方式​

5）最佳實踐：單一職責、松耦合、可觀測性等原則，以及常見問題的解決方案​

7.2 Agent技術發展趨勢​

​



| 趨勢 | 說明 | 影響 |
| --- | --- | --- |
| 自主性增強 | Agent將具備更強的自主決策能力 | 減少人工幹預，提高效率 |
| 多模態融合 | 支援文字、影象、音訊等多種輸入 | 更全面的環境感知 |
| 協作能力提升 | Agent之間的協作更加智慧和高效 | 複雜任務的分散式處理 |
| 安全可控 | Agent的行為更加可預測和可控 | 降低安全風險 |



​

7.3 與後續內容的銜接​

在掌握了Agent智慧體架構之後，我們將繼續學習：​

1）MCP協議（Model Context Protocol）：Agent與外部工具通訊的標準協議​

2）Skill工程化：如何將Agent能力封裝為可複用的技能模組​

3）Agent安全：Agent系統面臨的安全威脅和防護措施​

這些內容將在後續章節中詳細展開，幫助你構建更加完善的安全Agent系統。​

7.4 學習建議​

1）理論與實踐結合：在理解架構原理的同時，動手實現簡單的Agent系統​

2）從小處著手：先實現單一功能的Agent，再逐步擴充套件為多Agent系統​

3）關注安全：在開發Agent系統時，始終關注安全性和可控性​

4）持續學習：Agent技術發展迅速，保持對最新進展的關注​

​

​

作者：無涯​