# Hermes Agent vs OpenClaw：源代码级深度对比分析

**分析日期**: 2026-04-18  
**分析方法**: 逐文件阅读源代码，提取关键代码片段作为证据  
**分析版本**: Hermes Agent (GitHub 最新) vs OpenClaw (GitHub 最新)

---

## 目录

1. [并发架构](#1-并发架构)
2. [记忆系统](#2-记忆系统)
3. [Skill 系统](#3-skill-系统)
4. [安全模型](#4-安全模型)
5. [Context 压缩](#5-context-压缩)
6. [代码质量](#6-代码质量)
7. [各自亮点与短板](#7-各自亮点与短板)
8. [总结表格](#8-总结表格)

---

## 1. 并发架构

### Hermes Agent：同步主循环 + 线程隔离

Hermes 的核心 agent 循环是**同步的**——`run_agent.py`（11,741 行）不使用 `asyncio`。并发通过 `threading` 实现。

**关键证据 — 线程安全迭代预算**（`run_agent.py:188-200`）：

```python
self._used = 0
self._lock = threading.Lock()

def consume(self) -> bool:
    """Try to consume one iteration. Returns True if allowed."""
    with self._lock:
        if self._used >= self.max_total:
            return False
        self._used += 1
        return True
```

**API 客户端可重入锁**（`run_agent.py:830-840`）：

```python
self._client_lock = threading.RLock()
self._active_children = []
self._active_children_lock = threading.Lock()
```

**多用户并发依赖 Gateway**：`gateway/run.py`（10,174 行）使用 async event loop + `ThreadPoolExecutor`，每个用户会话在独立线程中运行 agent。审批系统通过 `contextvars.ContextVar` 实现会话隔离（`tools/approval.py:205-209`）：

```python
_lock = threading.Lock()
_pending: dict[str, dict] = {}
_session_approved: dict[str, set] = {}
_session_yolo: set[str] = set()
```

**GIL 影响**：核心 agent 循环是 I/O 密集型（等待 LLM API 返回），GIL 影响有限。但 CPU 密集任务（如大规模 tool output 处理）会受到 GIL 制约。批处理模式使用 `multiprocessing.Pool`（`batch_runner.py`）来绕开 GIL。

**Subagent 机制**：子 agent 在 `concurrent.futures.ThreadPoolExecutor` 线程中运行，父 agent 预算 90 次迭代，子 agent 预算 50 次。

### OpenClaw：ACP 会话管理 + 事件流

OpenClaw 使用 **ACP（Agent Control Plane）** 作为中央会话管理器，基于 Node.js 的单线程 Event Loop 模型。

**关键证据 — ACP 单例管理器**（`src/acp/control-plane/manager.core.ts:16-23`）：

```typescript
getAcpSessionManager(): AcpSessionManager {
  if (!ACP_SESSION_MANAGER_SINGLETON) {
    ACP_SESSION_MANAGER_SINGLETON = new AcpSessionManager();
  }
  return ACP_SESSION_MANAGER_SINGLETON;
}
```

**Subagent 派生**（`src/agents/acp-spawn.ts:81-95`）：

```typescript
export const ACP_SPAWN_MODES = ["run", "session"] as const;
export type SpawnAcpMode = (typeof ACP_SPAWN_MODES)[number];
export const ACP_SPAWN_SANDBOX_MODES = ["inherit", "require"] as const;

export type SpawnAcpParams = {
  task: string;
  label?: string;
  agentId?: string;
  resumeSessionId?: string;
  cwd?: string;
  mode?: SpawnAcpMode;
  thread?: boolean;
  sandbox?: SpawnAcpSandboxMode;
  streamTo?: SpawnAcpStreamTarget;
};
```

**事件流架构**（`src/infra/agent-events.ts`）：

```typescript
export type AgentEventStream =
  | "lifecycle" | "tool" | "assistant" | "error"
  | "item" | "plan" | "approval" | "command_output"
  | "patch" | "compaction" | "thinking"
```

**多会话处理**：每个会话通过 `SessionActorQueue` 串行化消息处理；Gateway（HTTP/WebSocket 服务器，端口 18789）分发消息到 ACP 管理器。Node.js 原生的非阻塞 I/O 让并发 API 调用几乎零开销。

### 对比结论

| 维度 | Hermes | OpenClaw |
|------|--------|----------|
| 核心循环 | 同步 + threading | 异步 Event Loop |
| GIL 影响 | I/O 等待时可释放，CPU 任务受限 | 无 GIL 问题 |
| 多会话隔离 | contextvars + 线程 | ACP SessionActorQueue |
| Subagent | ThreadPoolExecutor | ACP Spawn（run/session 双模式） |
| 批处理 | multiprocessing.Pool | N/A（面向实时交互） |

> **视频旁白**：「Hermes 用 Python 的 threading 做并发，相当于用手动变速箱开跑车——在等 API 返回这种 I/O 场景够用，但遇到 CPU 密集任务就会卡。OpenClaw 用 Node.js 的 Event Loop，天生为高并发设计，多个会话之间几乎零互相干扰。」

---

## 2. 记忆系统

### Hermes：冻结快照 + 双文件持久化 + 内容安全扫描

Hermes 的记忆系统围绕两个 Markdown 文件构建：

- **MEMORY.md**（~2,200 字符上限）：agent 的个人笔记
- **USER.md**（~1,375 字符上限）：关于用户的观察

**关键证据 — 冻结快照机制**（`tools/memory_tool.py:124-140`）：

```python
def load_from_disk(self):
    """Load entries from MEMORY.md and USER.md, capture system prompt snapshot."""
    mem_dir = get_memory_dir()
    mem_dir.mkdir(parents=True, exist_ok=True)

    self.memory_entries = self._read_file(mem_dir / "MEMORY.md")
    self.user_entries = self._read_file(mem_dir / "USER.md")

    # Deduplicate entries (preserves order, keeps first occurrence)
    self.memory_entries = list(dict.fromkeys(self.memory_entries))
    self.user_entries = list(dict.fromkeys(self.user_entries))

    # Capture frozen snapshot for system prompt injection
    self._system_prompt_snapshot = {
        "memory": self._render_block("memory", self.memory_entries),
        "user": self._render_block("user", self.user_entries),
    }
```

**设计精妙之处**：快照在会话开始时冻结，中途写入不会改变 system prompt，这让 Claude 的 prompt cache 在整个会话中保持有效，节省大量 token。

**记忆写入的自动触发**（`agent/memory_manager.py:1-30`）：

```python
"""MemoryManager — orchestrates the built-in memory provider plus at most
ONE external plugin memory provider.

Usage in run_agent.py:
    self._memory_manager = MemoryManager()
    self._memory_manager.add_provider(BuiltinMemoryProvider(...))
    # Only ONE of these:
    self._memory_manager.add_provider(plugin_provider)
"""
```

生命周期：
1. **Turn Start**：`prefetch_all(user_message)` → 召回相关上下文
2. **System Prompt**：冻结快照以 `<memory-context>` 标签注入
3. **Turn End**：`sync_all(user_msg, assistant_response)` → 写入磁盘
4. **Session End**：`on_session_end(messages)` → 最终持久化

**内容安全扫描——防止 prompt injection**（`tools/memory_tool.py:65-102`）：

```python
_MEMORY_THREAT_PATTERNS = [
    (r'ignore\s+(previous|all|above|prior)\s+instructions', "prompt_injection"),
    (r'you\s+are\s+now\s+', "role_hijack"),
    (r'do\s+not\s+tell\s+the\s+user', "deception_hide"),
    (r'system\s+prompt\s+override', "sys_prompt_override"),
    (r'curl\s+[^\n]*\$\{?\w*(KEY|TOKEN|SECRET|PASSWORD)', "exfil_curl"),
    (r'authorized_keys', "ssh_backdoor"),
    # ...30+ patterns
]

_INVISIBLE_CHARS = {
    '\u200b', '\u200c', '\u200d', '\u2060', '\ufeff',
    '\u202a', '\u202b', '\u202c', '\u202d', '\u202e',
}

def _scan_memory_content(content: str) -> Optional[str]:
    for char in _INVISIBLE_CHARS:
        if char in content:
            return f"Blocked: invisible unicode U+{ord(char):04X}"
    for pattern, pid in _MEMORY_THREAT_PATTERNS:
        if re.search(pattern, content, re.IGNORECASE):
            return f"Blocked: threat pattern '{pid}'"
    return None
```

**外部记忆集成**：支持插件式记忆提供者（Honcho 用户建模、Hindsight、Mem0），但同时只允许一个外部提供者。

### OpenClaw：LCM + Pi-Agent-Core + 插件化压缩

OpenClaw 的记忆系统基于 **Pi-Agent-Core**（`@mariozechner/pi-agent-core`），核心概念是 **LCM（Long Context Memory）**。

**记忆架构层级**：
- `src/plugin-sdk/memory-core.ts`（73 行）—— 公共 API barrel
- `src/memory-host-sdk/`（76 文件，8,023 行）—— 记忆宿主 SDK
- `src/plugin-sdk/memory-*.ts`（30+ 文件）—— 记忆插件

**Compaction 常量**（`src/agents/compaction.ts:19-22`）：

```typescript
export const BASE_CHUNK_RATIO = 0.4;
export const MIN_CHUNK_RATIO = 0.15;
export const SAFETY_MARGIN = 1.2; // 20% buffer for estimateTokens() inaccuracy
```

**压缩指令——标识符保留策略**（`src/agents/compaction.ts:40-42`）：

```typescript
const IDENTIFIER_PRESERVATION_INSTRUCTIONS =
  "Preserve all opaque identifiers exactly as written (no shortening or reconstruction), " +
  "including UUIDs, hashes, IDs, hostnames, IPs, ports, URLs, and file names.";
```

**结构化摘要合并**（`src/agents/compaction.ts:28-38`）：

```typescript
const MERGE_SUMMARIES_INSTRUCTIONS = [
  "Merge these partial summaries into a single cohesive summary.",
  "",
  "MUST PRESERVE:",
  "- Active tasks and their current status (in-progress, blocked, pending)",
  "- Batch operation progress (e.g., '5/17 items completed')",
  "- The last thing the user requested and what was being done about it",
  "- Decisions made and their rationale",
  "- TODOs, open questions, and constraints",
].join("\n");
```

**记忆刷新机制**：通过 `src/auto-reply/reply/memory-flush.ts` 在溢出/超时时触发。嵌入式运行器有多种触发方式：
- **超时触发**：`compaction-timeout.ts`
- **预判溢出**：`preemptive-compaction.ts`
- **重试聚合**：`compaction-retry-aggregate-timeout.ts`

### 对比结论

| 维度 | Hermes | OpenClaw |
|------|--------|----------|
| 持久化载体 | MEMORY.md + USER.md（纯文本） | Pi-Agent-Core + 会话 JSONL |
| 字符上限 | ~2,200 + ~1,375 chars | 无硬性限制（token 预算控制） |
| 快照策略 | 会话开始冻结，利于 prompt cache | 按需压缩，动态管理 |
| 注入防护 | 30+ regex + 不可见字符检测 | 结构化摘要审计 |
| 外部集成 | Honcho/Hindsight/Mem0（单插件） | 插件化记忆提供者（plugin-sdk） |
| 标识符保留 | 未明确 | strict/off/custom 三级策略 |

> **视频旁白**：「记忆系统是两个框架差异最大的地方。Hermes 把记忆冻结成快照放进 system prompt——聪明但上限就那么两千多字符。OpenClaw 的 LCM 没有硬性字符上限，靠 token 预算动态管理，而且有专门的标识符保留策略，确保压缩不会丢掉关键的 UUID 和文件路径。」

---

## 3. Skill 系统

### Hermes：Agent 可自主创建 Skill + Hub 生态

Hermes 的 skill 系统允许 agent **在运行时自动创建** skill。

**Skill 存储结构**：

```
~/.hermes/skills/
├── category-name/
│   └── skill-name/
│       ├── SKILL.md          (必须)
│       ├── references/       (可选)
│       ├── templates/        (可选)
│       ├── scripts/          (可选)
│       └── assets/           (可选)
```

**Skill 格式验证**（`tools/skill_manager_tool.py:150-186`）：

```python
def _validate_frontmatter(content: str) -> Optional[str]:
    if not content.startswith("---"):
        return "SKILL.md must start with YAML frontmatter (---)"
    end_match = re.search(r'\n---\s*\n', content[3:])
    if not end_match:
        return "SKILL.md frontmatter is not closed"
    parsed = yaml.safe_load(yaml_content)
    if "name" not in parsed:
        return "Frontmatter must include 'name' field."
    if "description" not in parsed:
        return "Frontmatter must include 'description' field."
```

**自动创建的触发条件**：当 agent 识别出一个反复成功的模式时，可通过 `skill_manager` tool 调用以下 action：

1. **create(name, content, category)** → 创建 SKILL.md
2. **edit(name, content)** → 替换内容
3. **patch(name, find, replace)** → 精确查找替换
4. **write_file(name, content, subdir)** → 添加辅助文件

限制条件：
- `MAX_SKILL_CONTENT_CHARS = 100,000`（~36K tokens）
- `MAX_SKILL_FILE_BYTES = 1,048,576`（1 MiB 每文件）
- 创建前经过安全扫描（`tools.skills_guard`）

**Hub 集成**（`tools/skills_hub.py`）：支持从 GitHub 仓库、官方可选 skill、社区仓库安装。安全扫描后信任等级分 `builtin | trusted | community`。

**Slash 命令加载**（`agent/skill_commands.py:209-378`）：

```python
# Flow:
# 1. scan_skill_commands() — 扫描 ~/.hermes/skills/ 中的 SKILL.md
# 2. resolve_skill_command_key(command) — 映射 /skill-name 到目录
# 3. build_skill_invocation_message(cmd_key) — 读取完整 skill 内容
# 4. 注入到用户消息: "[SYSTEM: The user invoked the 'skill-name' skill...]"
```

### OpenClaw：工作区快照 + 安装管道

OpenClaw 的 skill 系统更侧重于**安装和运行时加载**。

**核心文件**：
- `src/agents/skills.ts`（50 行）—— 8 个导出助手函数
- `src/agents/skills-install.ts`（330+ 行）—— 安装管道

**Skill 发现 API**（`src/agents/skills.ts`）：

```typescript
export {
  buildWorkspaceSkillSnapshot,
  buildWorkspaceSkillsPrompt,
  filterWorkspaceSkillEntries,
  loadWorkspaceSkillEntries,
  resolveSkillsPromptForRun,
  syncSkillsToWorkspace,
  buildWorkspaceSkillCommandSpecs,
}
```

**安装管道**：
1. `skills-install-download.ts` → 下载
2. `skills-install-extract.ts` → 解压
3. `skills-install-fallback.ts` → 降级处理
4. `skills-install-output.ts` → 输出格式化

**Skill 运行时加载**（`src/agents/pi-embedded-runner/skills-runtime.ts`）：按需加载，根据上下文筛选可用 skill。

### 对比结论

| 维度 | Hermes | OpenClaw |
|------|--------|----------|
| Agent 自主创建 | ✅ 运行时可创建/编辑/删除 | ❌ 需人工安装 |
| 格式验证 | YAML frontmatter 严格校验 | 类型系统约束 |
| Hub 生态 | agentskills.io（新兴） | 13,000+ 扩展 |
| 安全扫描 | skills_guard 恶意代码检测 | 安装时校验 |
| 加载方式 | 会话开始或 /command 触发 | 工作区快照 + 按需加载 |

> **视频旁白**：「这是 Hermes 真正让我佩服的设计——agent 自己发现一个好用的模式，就能自动写成 skill 存下来。OpenClaw 的 skill 必须人工安装。但反过来说，OpenClaw 有一万三千多个现成扩展，而 Hermes 的 agentskills.io 还在起步阶段。」

---

## 4. 安全模型

### Hermes：39 条正则规则 + LLM 智能审批

Hermes 的安全系统围绕 `tools/approval.py`（958 行）构建，采用**基于模式匹配的危险命令检测**。

**39 条危险命令模式**（`tools/approval.py:76-139`）：

```python
DANGEROUS_PATTERNS = [
    (r'\brm\s+(-[^\s]*\s+)*/', "delete in root path"),
    (r'\brm\s+-[^\s]*r', "recursive delete"),
    (r'\bchmod\s+(-[^\s]*\s+)*(777|666|o\+[rwx]*w|a\+[rwx]*w)\b', "world-writable"),
    (r'\bDROP\s+(TABLE|DATABASE)\b', "SQL DROP"),
    (r'\bDELETE\s+FROM\b(?!.*\bWHERE\b)', "SQL DELETE without WHERE"),
    (r'\b(curl|wget)\b.*\|\s*(ba)?sh\b', "pipe remote content to shell"),
    (r'\bgit\s+reset\s+--hard\b', "git reset --hard"),
    (r'\bgit\s+push\b.*--force\b', "git force push"),
    (r':\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;\s*:', "fork bomb"),
    (r'\b(pkill|killall)\b.*\b(hermes|gateway|cli\.py)\b', "self-termination"),
    # ... 共39条
]
```

**检测函数**（`tools/approval.py:187-198`）：

```python
def detect_dangerous_command(command: str) -> tuple:
    command_lower = _normalize_command_for_detection(command).lower()
    for pattern, description in DANGEROUS_PATTERNS:
        if re.search(pattern, command_lower, re.IGNORECASE | re.DOTALL):
            return (True, pattern_key, description)
    return (False, None, None)
```

**三种审批模式**：
1. **manual**（默认）：每条危险命令交互式确认
2. **smart**：用辅助 LLM 做风险评估，不确定时才人工确认
3. **off**：跳过所有审批

**Smart 审批亮点**（`tools/approval.py:535-584`）：

```python
def _smart_approve():
    # Calls auxiliary LLM with:
    # "Assess ACTUAL risk (many are false positives)"
    # Rules:
    #   APPROVE - clearly safe
    #   DENY - genuinely dangerous
    #   ESCALATE - uncertain → fall through to manual
    # Temperature=0, max_tokens=16
```

**审批持久化三层范围**：
- `once` — 仅当次
- `session` — 仅当前会话
- `always` — 永久写入 `command_allowlist`

**Unicode 混淆防御**（`tools/approval.py:169-184`）：
- 剥离 ANSI 转义序列
- 移除 null 字节
- NFKC 标准化全角字符（防止用全角绕过检测）

### OpenClaw：分类审批 + Allowlist + 沙箱隔离

OpenClaw 的安全模型更结构化，基于 **tool 分类** 而非命令文本模式匹配。

**审批分类**（`src/acp/approval-classifier.ts:12-32`）：

```typescript
const SAFE_SEARCH_TOOL_IDS = new Set(["search", "web_search", "memory_search"]);
const EXEC_CAPABLE_TOOL_IDS = new Set([
  "exec", "spawn", "shell", "bash", "process", "code_execution",
]);
const CONTROL_PLANE_TOOL_IDS = new Set([
  "sessions_spawn", "sessions_send", "session_status"
]);

export type AcpApprovalClass =
  | "readonly_scoped"      // 安全读操作 → 自动通过
  | "readonly_search"      // 搜索工具 → 自动通过
  | "mutating"             // 状态变更 → 需审批
  | "exec_capable"         // Shell 执行 → 需审批
  | "control_plane"        // 会话控制 → 需审批
  | "interactive"          // 需用户交互
  | "other" | "unknown";
```

**审批请求结构**（`src/infra/exec-approvals.ts:84-100`）：

```typescript
export type ExecApprovalRequestPayload = {
  command: string;
  commandPreview?: string | null;
  commandArgv?: string[];
  envKeys?: string[];
  systemRunBinding?: SystemRunApprovalBinding | null;
  cwd?: string | null;
  host?: string | null;
  security?: "deny" | "allowlist" | "full";
  ask?: "off" | "on-miss" | "always";
};
```

**执行目标隔离**：

```typescript
export type ExecHost = "sandbox" | "gateway" | "node";
```

命令可以在沙箱、网关、或 Node 进程中执行，提供物理隔离层。

**深度代码安全审计**：`src/security/`（80 文件，16,084 行）提供完整的安全审计框架，包括沙箱策略、文件系统策略、网络策略。

### 对比结论

| 维度 | Hermes | OpenClaw |
|------|--------|----------|
| 检测方法 | 39 条正则模式匹配 | Tool ID 分类 + Allowlist |
| LLM 辅助 | ✅ Smart 模式用 LLM 评估 | ❌ 无 LLM 辅助审批 |
| 沙箱隔离 | ❌（靠命令拦截） | ✅ sandbox/gateway/node 三级隔离 |
| Unicode 防御 | ✅ NFKC + 不可见字符 | 未明确 |
| 自保护 | ✅ 防止 agent 杀死自身进程 | ✅ 控制面命令审批 |
| 安全代码量 | ~958 行 (approval.py) | ~16,084 行 (security/) |

> **视频旁白**：「安全这块两家各有千秋。Hermes 用 39 条正则表达式拦截危险命令，还加了个创新的 LLM 智能审批——用一个小模型帮你判断是不是误报。OpenClaw 走的是分类路线，按工具类型分安全等级，还有真正的沙箱隔离。Hermes 像保安站门口查人，OpenClaw 像直接上了门禁卡系统。」

---

## 5. Context 压缩

### Hermes：有损摘要 + 工具输出裁剪 + 反抖动

**压缩触发阈值**（`agent/context_compressor.py:310-330`）：

```python
def should_compress(self, prompt_tokens: int = None) -> bool:
    tokens = prompt_tokens if prompt_tokens is not None else self.last_prompt_tokens
    if tokens < self.threshold_tokens:  # 默认 50% 上下文长度
        return False
    # 反抖动：连续两次压缩节省 <10% 则跳过
    if self._ineffective_compression_count >= 2:
        logger.warning(
            "Compression skipped — last %d compressions saved <10%% each. "
            "Consider /new to start a fresh session",
            self._ineffective_compression_count,
        )
        return False
    return True
```

**5 阶段压缩流程**：
1. **裁剪旧工具输出**（无 LLM，低成本）→ 用一行摘要替代
2. **保护头部消息** → system prompt + 前 3 轮对话
3. **保护尾部消息** → 最近 ~20K tokens
4. **LLM 摘要中间轮次** → 结构化提示
5. **迭代更新** → 后续压缩合并之前的摘要

**压缩后的"交接框架"**（`agent/context_compressor.py:37-50`）：

```python
SUMMARY_PREFIX = (
    "[CONTEXT COMPACTION — REFERENCE ONLY] Earlier turns were compacted "
    "into the summary below. This is a handoff from a previous context "
    "window — treat it as background reference, NOT as active instructions. "
    "Do NOT answer questions or fulfill requests mentioned in this summary; "
    "they were already addressed."
)
```

**Token 预算公式**：
- 摘要最小 tokens：`_MIN_SUMMARY_TOKENS = 2,000`
- 摘要占比：`_SUMMARY_RATIO = 0.20`（压缩内容的 20%）
- 摘要上限：`_SUMMARY_TOKENS_CEILING = 12,000`
- 尾部预算：与目标 token 数成正比

### OpenClaw：多阶段摘要 + 质量审计 + 标识符保留

**压缩常量**（`src/agents/compaction.ts:19-22`）：

```typescript
export const BASE_CHUNK_RATIO = 0.4;
export const MIN_CHUNK_RATIO = 0.15;
export const SAFETY_MARGIN = 1.2; // 20% 缓冲
```

**质量审计守卫**（`src/agents/pi-hooks/compaction-safeguard-quality.ts:1-20`）：

```typescript
const MAX_TOOL_FAILURES = 8;
const MAX_TOOL_FAILURE_CHARS = 240;
const MAX_COMPACTION_SUMMARY_CHARS = 16_000;
const MAX_FILE_OPS_SECTION_CHARS = 2_000;
const DEFAULT_QUALITY_GUARD_MAX_RETRIES = 1;
const MAX_QUALITY_GUARD_MAX_RETRIES = 3;

const REQUIRED_SUMMARY_SECTIONS = [
  "## Decisions",
  "## Open TODOs",
  "## Constraints/Rules",
  "## Pending user asks",
  "## Exact identifiers",
] as const;
```

**插件化压缩提供者**（`src/plugins/compaction-provider.ts:22-34`）：

```typescript
export interface CompactionProvider {
  id: string;
  label: string;
  summarize(params: {
    messages: unknown[];
    signal?: AbortSignal;
    compressionRatio?: number;
    customInstructions?: string;
    summarizationInstructions?: CompactionProviderSummarizationInstructions;
    previousSummary?: string;
  }): Promise<string>;
}
```

注册使用 `Symbol.for("openclaw.compactionProviderRegistryState")` 实现跨模块单例。

**标识符保留策略**（`src/agents/pi-hooks/compaction-safeguard.ts`）：

```typescript
// Policy Options: "strict" | "off" | "custom"
// Strict (默认): 保留所有不透明标识符
// Off: 按需保留
// Custom: 用户自定义规则
```

**多种触发方式**：
- 超时触发：`compaction-timeout.ts`
- 预判溢出：`preemptive-compaction.ts`
- 重试聚合：`compaction-retry-aggregate-timeout.ts`
- 安全超时：`compaction-safety-timeout.ts`（防止压缩卡死）

### 对比结论

| 维度 | Hermes | OpenClaw |
|------|--------|----------|
| 压缩类型 | 有损摘要（LLM 生成） | 有损摘要（LLM 生成） |
| 触发策略 | 50% 上下文阈值 | 多策略（超时/预判/溢出） |
| 反抖动 | ✅ 连续2次<10%则跳过 | ✅ 重试聚合超时 |
| 质量审计 | ❌ 无结构化审计 | ✅ 5 必须章节 + 标识符提取 |
| 标识符保留 | ❌ 无明确策略 | ✅ strict/off/custom 三级 |
| 插件化 | ❌ 内置唯一策略 | ✅ CompactionProvider 接口 |
| 工具输出裁剪 | ✅ 一行摘要替代 | ✅ stripToolResultDetails |
| 头尾保护 | ✅ 保护前3轮+尾部20K | 未明确固定数量 |

> **视频旁白**：「Context 压缩是 AI agent 的"续航能力"。Hermes 用五步流程把长对话压成摘要，有反抖动保护。但 OpenClaw 做得更细致——压缩后的摘要必须包含五个章节：决策、待办、约束、未完成请求、关键标识符。尤其标识符保留策略，保证压缩不会把 UUID 和文件路径搞丢，这在真实开发中太关键了。」

---

## 6. 代码质量

### 代码规模

| 维度 | Hermes Agent | OpenClaw |
|------|-------------|----------|
| 语言 | Python | TypeScript |
| 源文件数 | 316 | 3,936 |
| 源代码行数 | ~228,000 | ~673,000 |
| 测试文件数 | 608 | 2,734 |
| 测试代码行数 | ~203,000 | ~655,000 |
| 测试/源码比 | 0.89 | 0.97 |
| 核心文件最大行数 | run_agent.py: 11,741 行 | acp-spawn.ts: ~500 行 |

### 架构分层对比

**Hermes 架构层级**：

```
┌─────────────────────────────────────┐
│  用户界面 (cli.py / gateway/)       │
├─────────────────────────────────────┤
│  Agent 核心 (run_agent.py 11.7K行)  │  ← 上帝类
├─────────────────────────────────────┤
│  Agent 服务 (agent/ 33文件)          │
├─────────────────────────────────────┤
│  工具系统 (tools/ 150+ 工具)         │
├─────────────────────────────────────┤
│  平台适配 (gateway/adapters/)       │
└─────────────────────────────────────┘
```

**OpenClaw 架构层级**：

```
┌─────────────────────────────────────┐
│  Gateway (HTTP/WebSocket)           │
├─────────────────────────────────────┤
│  ACP (Agent Control Plane)          │
├─────────────────────────────────────┤
│  Agent Runtime (Pi-Agent-Core)      │
├─────────────────────────────────────┤
│  Infrastructure Services            │
├─────────────────────────────────────┤
│  Plugin System                      │
├─────────────────────────────────────┤
│  Channels (Discord/Telegram/...)    │
├─────────────────────────────────────┤
│  Configuration & Storage            │
└─────────────────────────────────────┘
```

### 关键差异

1. **Hermes 的 `run_agent.py` 有 11,741 行**——这是一个"上帝类"（God Object），几乎所有核心逻辑都塞在一个文件里。对比 OpenClaw 最大的单文件大约 500 行左右。

2. **OpenClaw 代码量是 Hermes 的约 3 倍**——这既反映了功能广度（更多平台、更多插件），也反映了 TypeScript 的类型声明开销。

3. **测试比例**两者接近——Hermes 0.89:1，OpenClaw 0.97:1，都达到了工业级水平。

> **视频旁白**：「代码量说明一切——Hermes 二十二万行 Python，OpenClaw 六十七万行 TypeScript。但 Hermes 有个致命问题：核心文件 run_agent.py 一个文件就一万两千行，所有逻辑塞在一起。OpenClaw 拆得很细，最大单文件也就几百行。这说明 OpenClaw 的工程化程度更高，Hermes 更像一个天才的快速原型。」

---

## 7. 各自亮点与短板

### Hermes Agent

#### 最值得称道的设计决策

1. **LLM Smart Approval**：用一个小模型帮用户判断"这条命令真的危险吗？"——大量危险命令检测是误报，smart 模式用 temperature=0、max_tokens=16 的辅助 LLM 快速判断，极大改善用户体验。这是同类产品中首创。

2. **记忆冻结快照**：会话开始时冻结记忆为快照，中途写入不改变 system prompt。这让 prompt cache 在整个会话中保持有效，是一个精妙的性能优化。

3. **Agent 自主创建 Skill**：agent 识别到反复成功的模式后，可以自动创建 skill 并存储。这实现了真正的"运行时学习"——虽然学到的是提示词而不是模型权重。

4. **记忆内容安全扫描**：30+ 条 prompt injection 检测规则 + 不可见 Unicode 字符过滤。由于记忆内容会被注入 system prompt，这道防线至关重要。

5. **多执行环境后端**：local、Docker、SSH、Modal、Daytona、Singularity——6 种执行环境，部署灵活性极高。

#### 最明显的技术债务

1. **`run_agent.py` 上帝类**（11,741 行）：所有核心逻辑（对话循环、工具调用、上下文管理、子 agent 派生）塞在一个文件中。可读性差，测试困难，修改一个功能可能影响其他功能。

2. **同步主循环**：核心不用 asyncio，并发完全靠 threading + Lock。对于 I/O 密集的 LLM agent 来说，这浪费了 Python 3.11+ 的异步性能改进。

3. **无沙箱隔离**：完全靠命令文本模式匹配拦截，没有执行环境隔离。攻击者如果能构造绕过正则的命令（如 Unicode 变体或间接执行），就能突破防线。

4. **记忆字符限制过低**：MEMORY.md ~2,200 字符、USER.md ~1,375 字符。对于复杂项目，这个上限严重不足。

5. **单外部记忆提供者限制**：同一时间只允许一个外部记忆插件。对于需要同时用向量检索和用户建模的场景是硬伤。

### OpenClaw

#### 最值得称道的设计决策

1. **结构化压缩质量审计**：压缩后的摘要必须包含 5 个标准章节（Decisions、Open TODOs、Constraints/Rules、Pending user asks、Exact identifiers），并有标识符提取和验证。这在长对话场景中防止信息丢失。

2. **ACP（Agent Control Plane）**：将会话管理抽象为独立的控制面，解耦了 agent 运行时和会话生命周期。支持 `run`（一次性）和 `session`（持久化）两种 spawn 模式。

3. **三级执行隔离**：`sandbox`、`gateway`、`node` 三种执行主机，提供物理级隔离。不是靠正则拦截命令，而是从执行环境层面限制能力。

4. **插件化压缩提供者**：`CompactionProvider` 接口允许第三方替换内置压缩策略。使用 `Symbol.for()` 实现跨模块单例，即使在 bundled chunks 中也能存活。

5. **TypeScript 类型安全**：所有核心数据结构都有严格的类型定义（discriminated unions、type guards），减少运行时错误。

#### 最明显的技术债务

1. **无 Agent 自主学习**：skill 必须人工安装，agent 无法自主创建。对于普通用户来说，"调教"门槛较高。

2. **代码量庞大**（67 万行源码）：虽然分层清晰，但规模本身就是负担。新贡献者上手困难，编译时间长。

3. **对 pi-agent-core 的深度依赖**：LCM 等核心功能建立在 `@mariozechner/pi-agent-core` 之上。如果该依赖出问题或方向变化，影响面巨大。

4. **无 LLM 辅助审批**：安全审批完全靠分类和 allowlist，没有类似 Hermes 的 smart 模式。对于大量误报的场景，用户体验不如 Hermes。

5. **无内建的记忆注入防护**：缺少类似 Hermes 的 prompt injection 正则扫描。虽然有结构化的压缩质量审计，但针对恶意内容注入的专门防线不够明确。

---

## 8. 总结表格

| 维度 | 胜负 | 说明 |
|------|------|------|
| **并发架构** | **OpenClaw 胜** | Node.js Event Loop 天生异步非阻塞，无 GIL 限制。Hermes 靠 threading + Lock，在 I/O 场景够用但上限低 |
| **记忆系统** | **平手** | Hermes 的冻结快照 + 安全扫描 vs OpenClaw 的 LCM + 标识符保留，各有所长 |
| **Skill 系统** | **Hermes 胜** | Agent 可自主创建 skill 是杀手级功能，OpenClaw 依赖人工安装 |
| **安全模型** | **OpenClaw 胜** | 三级沙箱隔离 > 正则模式匹配；但 Hermes 的 Smart Approval 是创新亮点 |
| **Context 压缩** | **OpenClaw 胜** | 结构化质量审计 + 标识符保留策略 + 插件化提供者，工程化程度更高 |
| **代码质量** | **OpenClaw 胜** | 分层清晰，单文件控制在合理范围；Hermes 的 11.7K 行上帝类是硬伤 |
| **亮点设计** | **平手** | Hermes 的 Smart Approval + 自主学习 vs OpenClaw 的 ACP + 质量审计，各有创新 |
| **技术债务** | **Hermes 更多** | 上帝类、无沙箱、记忆上限低；OpenClaw 的债务主要在规模和外部依赖 |

### 总比分：OpenClaw 4:1:3 Hermes（4 胜 1 负 3 平手）

---

## 终极结论（视频可用中文旁白）

> **「看完两个框架的全部源代码，我的结论是——Hermes 是一个有天赋的少年天才，OpenClaw 是一个经验丰富的工程老兵。」**
>
> **「Hermes 最让我服的是两个设计：agent 自动创建 skill，和用 LLM 帮你判断命令危不危险。这两个想法 OpenClaw 都没有，值得借鉴。」**
>
> **「但打开 Hermes 的核心文件 run_agent.py，一万两千行代码全塞在一个文件里——这不是架构，这是意大利面。OpenClaw 最大的单文件也就几百行，分层清晰得多。」**
>
> **「记忆系统上，Hermes 的冻结快照让 prompt cache 一直有效，省钱；OpenClaw 的标识符保留策略保证压缩不丢关键信息，靠谱。各有各的聪明。」**
>
> **「安全上差距最大——Hermes 靠 39 条正则拦你，OpenClaw 直接把执行环境隔离成沙箱。一个是保安查身份证，一个是进出刷门禁卡，哪个更靠谱不用我说。」**
>
> **「所以回到那个比喻：Hermes 是自动挡——帮你自动学习，省事，但底盘不够扎实。OpenClaw 是手动挡——需要调教，但工程质量好，能上赛道。真正要跑生产的，还是得选手动挡。」**

---

*分析完成于 2026-04-18，基于两个框架 GitHub 最新源码的逐文件阅读。*