OpenClaw vs Hermes Agent：记忆机制深度对比与架构设计启示

OpenClaw vs Hermes Agent：记忆机制深度对比与架构设计启示

“记忆是智能的基石。一个没有记忆的 Agent，就像一个永远无法从经验中学习的灵魂。”

引言：记忆为何如此重要？

在 AI Agent 的设计哲学中，记忆系统占据了核心地位。如果说模型（LLM）是 Agent 的”大脑”，那么记忆系统就是它的”长期存储”和”经验库”。没有记忆，Agent 每次对话都像第一次见面，无法记住用户的偏好、项目的细节、解决问题的方法。

本文将深入分析两个代表性 Agent 平台——OpenClaw 和 Hermes Agent——的记忆机制设计，对比它们的设计理念、实现方式和优劣，为 Agent 记忆系统的设计提供实践参考。

一、设计哲学的分歧：两种不同的记忆观

1.1 Hermes：结构化三元记忆模型

Hermes Agent 的记忆系统建立在一个清晰的三元模型之上：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
┌─────────────────────────────────────────────────────────────┐
│                    Hermes Memory System                     │
├─────────────────────────────────────────────────────────────┤
│  Procedural Memory (技能系统)                               │
│  ├── SKILL.md 文件                                   │
│  ├── 支持文件 (references/, templates/, scripts/)            │
│  └── 可执行的标准化流程                                     │
├─────────────────────────────────────────────────────────────┤
│  Episodic Memory (MEMORY.md)                                │
│  ├── 环境事实                                             │
│  ├── 项目约定                                              │
│  ├── 工具怪癖                                              │
│  └── 从经验中学到的知识                                     │
├─────────────────────────────────────────────────────────────┤
│  Semantic Memory (USER.md)                                  │
│  ├── 用户偏好                                              │
│  ├── 交流风格                                              │
│  ├── 工作习惯                                              │
│  └── 用户期望                                              │
└─────────────────────────────────────────────────────────────┘

核心设计理念：

  • 程序化记忆（Procedural）：如何做事情的流程和方法
  • 情节记忆（Episodic）：发生了什么，学到了什么事实
  • 语义记忆（Semantic）：用户是谁，有什么偏好

这种分类对应了认知心理学中的人类记忆类型，设计上更加系统化和理论化。

1.2 OpenClaw：实用主义文件系统记忆

OpenClaw 的记忆系统更加简单直接，采用项目级文件系统结构：

1
2
3
4
5
6
7
8
9
10
11
12
~/.openclaw/workspace/
├── SOUL.md              # 个性、价值观、行为准则
├── AGENTS.md            # Code Agent 调用规则
├── USER.md              # 用户信息、偏好、时区
├── MEMORY.md            # 长期记忆、项目信息、研究报告
├── TOOLS.md             # 本地工具笔记
├── HEARTBEAT.md         # 定时任务配置
└── skills/              # Agent 技能目录
    ├── feishu-doc/
    │   └── SKILL.md
    └── blog-publisher/
        └── SKILL.md

核心设计理念：

  • Markdown 为源：人类可读、Git 友好
  • 项目级隔离：每个 Agent 有独立 workspace
  • 技能即记忆：技能文件本身就是一种记忆形式
  • 简单即美：不强制区分记忆类型，实用为主

OpenClaw 的设计更加工程化，强调可维护性和灵活性，而非严格的理论框架。

二、记忆写入机制：如何保存知识？

2.1 Hermes：双重状态 + 自动审查

双重状态设计

Hermes 的记忆系统有一个精巧的双重状态设计：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class MemoryStore:
    def __init__(self):
        # 冻结快照：系统提示词注入使用，永不修改
        self._system_prompt_snapshot: Dict[str, str] = {
            "memory": "",
            "user": ""
        }

        # 活跃状态：实时更新
        self.memory_entries: List[str] = []
        self.user_entries: List[str] = []

    def load_from_disk(self):
        """从磁盘加载记忆"""
        # 加载后立即捕获冻结快照
        self._system_prompt_snapshot = {
            "memory": self._render_block("memory", self.memory_entries),
            "user": self._render_block("user", self.user_entries),
        }

设计亮点：

  1. 冻结快照：会话开始时注入一次，后续修改不影响系统提示词
  2. 保持缓存稳定：前缀缓存不会因为记忆更新而失效
  3. 实时更新：活跃状态在会话中持续更新，写入磁盘

后台审查机制

Hermes 最具创新性的设计是后台自动审查机制：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
def _spawn_background_review(
    self,
    messages_snapshot: List[Dict],
    review_memory: bool = False,
    review_skills: bool = False,
) -> None:
    """在后台线程中运行审查，不阻塞用户交互"""

    def _run_review():
        import contextlib, os as _os
        with open(_os.devnull, "w") as _devnull, \
             contextlib.redirect_stdout(_devnull), \
             contextlib.redirect_stderr(_devnull):

            # 创建审查代理（克隆当前配置）
            review_agent = AIAgent(
                model=self.model,
                max_iterations=8,
                quiet_mode=True,
            )

            # 共享记忆存储
            review_agent._memory_store = self._memory_store

            # 禁用审查触发器（避免无限递归）
            review_agent._memory_nudge_interval = 0

            # 运行审查
            review_agent.run_conversation(
                user_message=prompt,
                conversation_history=messages_snapshot,
            )

    # 启动守护线程
    t = threading.Thread(target=_run_review, daemon=True, name="bg-review")
    t.start()

审查触发条件：

  • 默认每 10 轮对话后触发
  • 可通过配置调整间隔
  • 在响应返回之后运行，不阻塞用户交互

审查提示词设计：

1
2
3
4
5
6
7
8
9
10
_MEMORY_REVIEW_PROMPT = (
    "Review the conversation above and consider saving to memory if appropriate.\n\n"
    "Focus on:\n"
    "1. Has the user revealed things about themselves — their persona, desires, "
    "preferences, or personal details worth remembering?\n"
    "2. Has the user expressed expectations about how you should behave, their work "
    "style, or ways they want you to operate?\n\n"
    "If something stands out, save it using the memory tool. "
    "If nothing is worth saving, just say 'Nothing to save.' and stop."
)

用户反馈：

1
2
3
4
5
6
7
8
9
10
11
# 扫描审查代理的消息，提取成功的工具操作
for msg in review_agent._session_messages:
    if msg.get("role") == "tool":
        data = json.loads(msg.get("content", "{}"))
        if data.get("success"):
            actions.append(data.get("message", ""))

# 向用户显示总结
if actions:
    summary = " · ".join(dict.fromkeys(actions))
    self._safe_print(f"  💾 {summary}")

输出示例：💾 Memory updated · Skill created

2.2 OpenClaw：手动写入 + 技能系统

OpenClaw 的记忆写入更加直接，主要由 Agent 决定何时更新记忆：

文件写入机制

OpenClaw 提供基础的文件操作工具，由 Agent 根据任务需求决定是否更新记忆：

1
2
3
4
5
6
7
8
9
10
11
12
13
# Agent 自主决定更新记忆
write(
  path: "~/.openclaw/workspace/MEMORY.md",
  content: """
## 项目信息

### MyClaw 项目
- **位置**: `/Users/daoyu/Documents/my-github/MyClaw`
- **描述**: 简化版 EasyClaw 实现
- **开始日期**: 2026-03-07
- **当前进度**: Phase 6-7 进行中
"""
)

技能系统作为记忆载体

OpenClaw 的技能系统也承担了部分记忆功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
---
name: feishu-doc
description: Feishu document read/write operations.
---

# Feishu Document Skill

## Workflow
1. Read document using `feishu_doc` tool
2. Analyze content
3. Write or append changes

## Common Pitfalls
- Always check document token before operations
- Use `action: "list_blocks"` to get block_id first

设计特点：

  • Agent 自主决定何时创建/更新技能
  • 技能文件本身就是一种程序化记忆
  • 技能自动加载到系统提示词中

定时任务记忆

OpenClaw 通过 HEARTBEAT.md 实现定时任务的记忆机制：

1
2
3
4
5
6
7
8
9
10
11
# HEARTBEAT.md

# 添加任务 below when you want the agent to check something periodically.

## 每日 11:00
- 运行每日开源项目研究脚本
- 输出博客文章并发布

## 每日 18:00
- 生成 Agent 前沿趋势洞察
- 发布到博客

2.3 写入机制对比

特性 Hermes OpenClaw
写入触发 后台自动审查 Agent 手动决定
写入时机 响应返回后异步 Agent 需要时同步
用户感知 简洁通知（💾） 无通知（透明）
递归防护 禁用审查代理的触发器 无递归问题
双重状态 冻结快照 + 活跃状态 单一状态
写入安全 安全扫描 + 原子写入 依赖文件系统

三、记忆检索机制：如何召回知识？

3.1 Hermes：FTS5 + 实体中心 + 预取

FTS5 全文搜索

Hermes 使用 SQLite FTS5（Full-Text Search）实现高效的全文搜索：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# SQLite FTS5 表结构
CREATE VIRTUAL TABLE memory_fts USING fts5(
    id,
    kind,           -- world|experience|opinion|observation
    timestamp,
    entities,       -- JSON array: ["Peter","warelay"]
    content,        -- narrative fact
    source          -- memory/2025-11-27.md#L12
);

# 搜索查询
SELECT * FROM memory_fts
WHERE memory_fts MATCH 'deploy container docker'
ORDER BY rank;

优势：

  • 极快的搜索速度（毫秒级）
  • 支持复杂的布尔查询
  • 轻量级（无需额外依赖）
  • 离线友好

实体中心检索（Entity-Centric Retrieval）

Hermes 支持基于实体的检索：

1
2
3
4
5
6
7
8
9
10
11
12
# 实体页面示例
# ~/.hermes/bank/entities/Peter.md

## Peter

### 基本信息
- 当前位置：Marrakech (Nov 27–Dec 1, 2025)
- 偏好：简洁回复（<1500 字符）

### 相关事实
- W @Peter: Currently in Marrakech for Andy's birthday.
- O(c=0.95) @Peter: Prefers concise replies on WhatsApp.

查询方式：

1
2
Agent: "Tell me about Peter"
→ 检索实体页面 + 实体关联的所有事实

时间感知查询（Temporal Queries）

1
2
3
4
# 查询特定时间范围内的记忆
SELECT * FROM memory_fts
WHERE timestamp BETWEEN '2025-11-01' AND '2025-11-30'
  AND memory_fts MATCH 'project deployment';

应用场景：

  • “11 月份我们做了什么？”
  • “从上次会议到现在有什么变化？”
  • “去年这个时候我们决定过什么？”

预取机制（Prefetching）

Hermes 实现了智能的预取机制：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def prefetch_all(self, query: str, *, session_id: str = "") -> str:
    """从所有提供者预取上下文"""
    parts = []
    for provider in self._providers:
        try:
            result = provider.prefetch(query, session_id=session_id)
            if result and result.strip():
                parts.append(result)
        except Exception as e:
            logger.debug("Prefetch failed for %s: %s", provider.name, e)
    return "\n\n".join(parts)

def queue_prefetch_all(self, query: str, *, session_id: str = "") -> None:
    """为下一轮对话预取上下文（后台执行）"""
    for provider in self._providers:
        try:
            provider.queue_prefetch(query, session_id=session_id)
        except Exception as e:
            logger.debug("Queue prefetch failed for %s: %s", provider.name, e)

调用时机：

  • 每轮对话开始前：prefetch_all()（同步）
  • 每轮对话结束后：queue_prefetch_all()（异步）

预取策略：

  • 基于当前查询预测下一轮可能需要的上下文
  • 后台异步执行，不阻塞响应
  • 缓存预取结果，加速后续查询

记忆提供者插件系统

Hermes 支持外部记忆提供者插件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class MemoryProvider(ABC):
    """记忆提供者抽象基类"""

    @abstractmethod
    def prefetch(self, query: str, session_id: str = "") -> str:
        """预取上下文"""
        ...

    @abstractmethod
    def get_tool_schemas(self) -> List[Dict]:
        """返回工具 schema"""
        ...

# 支持的提供者
- Honcho: 辩证用户建模
- Mem0: AI 原生记忆系统
- OpenViking: 嵌入式记忆存储
- RetainDB: 结构化数据库
- ByteRover: 文件检索

限制：

  • 最多 1 个外部记忆提供者
  • 内置提供者（file-based）始终可用

3.2 OpenClaw：Skills 自动加载 + 文件读取

Skills 自动加载

OpenClaw 的技能系统实现了记忆的自动加载：

1
2
3
4
5
6
7
8
9
10
// 技能自动加载逻辑
const skills = loadSkills(workspace);
const skillContext = skills.map(skill => `
<skill name="${skill.name}">
${skill.content}
</skill>
`).join('\n');

// 注入到系统提示词
systemPrompt += `\n\n## Available Skills\n\n<available_skills>\n${skillContext}\n</available_skills>`;

特点：

  • 每个会话开始时自动加载所有技能
  • 技能内容直接嵌入系统提示词
  • Agent 可以根据任务描述自动选择技能

文件读取工具

OpenClaw 提供基础的文件读取工具，由 Agent 决定何时读取记忆：

1
2
3
4
5
6
7
// Agent 调用读取工具
{
  "name": "read",
  "arguments": {
    "path": "~/.openclaw/workspace/MEMORY.md"
  }
}

特点：

  • 完全由 Agent 决定
  • 支持读取任何文件
  • 可以读取部分内容（offset/limit）

会话历史存储

OpenClaw 会话历史本身也是一种记忆形式：

1
2
3
4
~/.openclaw/agents/<agentId>/sessions/
├── <session-id-1>.jsonl
├── <session-id-2>.jsonl
└── sessions.json

特点：

  • JSONL 格式存储每条消息
  • 支持会话历史查询
  • 可用于后续分析

3.3 检索机制对比

特性 Hermes OpenClaw
检索方式 FTS5 全文搜索 文件读取 + Skills 自动加载
实体检索 ✅ 实体中心检索 ❌ 无实体概念
时间查询 ✅ 时间感知查询 ❌ 无时间过滤
预取机制 ✅ 同步 + 异步预取 ❌ 无预取
外部提供者 ✅ 插件系统（1 external） ❌ 无插件系统
语义搜索 ⚠️ 需外部提供者 ❌ 无语义搜索
会话历史 ✅ 可检索 ✅ 可查询

四、记忆管理与优化：如何保持记忆的高效？

4.1 Hermes：压缩 + 置信度 + 限制

上下文压缩

Hermes 实现了智能的上下文压缩机制：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class ContextCompressor:
    """使用辅助模型压缩对话历史"""

    def compress(self, messages: List[Dict]) -> str:
        """生成对话摘要"""
        # 通知记忆提供者
        pre_compress_notes = self._memory_manager.on_pre_compress(messages)

        # 构建压缩提示词
        prompt = self._build_compress_prompt(messages, pre_compress_notes)

        # 使用辅助模型（更便宜、更快）
        summary = self._auxiliary_client.chat.completions.create(
            model=self._aux_model,
            messages=[{"role": "user", "content": prompt}]
        )

        return summary.choices[0].message.content

压缩触发条件：

1
2
if remaining_tokens < self._context_compression_threshold:
    self._compress_context(messages)

优势：

  • 使用更便宜的辅助模型
  • 保留关键信息
  • 减少上下文占用

置信度机制

Hermes 为观点类记忆引入了置信度机制：

1
2
3
4
## Retain
- W @Peter: Currently in Marrakech (Nov 27–Dec 1, 2025) for Andy's birthday.
- B @warelay: I fixed the Baileys WS crash by wrapping connection.update handlers in try/catch.
- O(c=0.95) @Peter: Prefers concise replies (<1500 chars) on WhatsApp; long content goes into files.

置信度更新：

1
2
3
4
5
6
7
8
9
10
# 当新事实到达时更新置信度
def update_opinion_confidence(opinion: Opinion, new_fact: Fact):
    if opinion.entities & new_fact.entities:
        if new_fact.supports(opinion):
            opinion.confidence += 0.05
        elif new_fact.contradicts(opinion):
            opinion.confidence -= 0.1

    # 置信度保持在 [0, 1]
    opinion.confidence = max(0, min(1, opinion.confidence))

意义：

  • 区分事实（W/B）和观点（O）
  • 观点可以随证据演化
  • 支持冲突解决

字符限制

Hermes 对记忆文件实施严格的字符限制：

1
2
MEMORY_CHAR_LIMIT = 2200  # 约 800 tokens
USER_CHAR_LIMIT = 1375   # 约 500 tokens

原因：

  • 防止上下文膨胀
  • 保持检索效率
  • 强制质量过滤

4.2 OpenClaw：手动管理 + 维护工具

手动管理

OpenClaw 依赖 Agent 的自主决策来管理记忆：

1
2
3
4
Agent: "记忆中有很多旧信息，我需要整理一下"
→ 使用 read 工具读取 MEMORY.md
→ 使用 edit 工具删除过时信息
→ 保留重要信息

会话维护工具

OpenClaw 提供会话维护工具：

1
2
3
4
5
6
7
8
# 清理旧会话
openclaw sessions cleanup --dry-run

# 强制清理
openclaw sessions cleanup --enforce

# 查看清理统计
openclaw sessions cleanup --all-agents --json

输出示例：

1
2
3
4
5
6
7
8
9
10
11
{
  "allAgents": true,
  "stores": [
    {
      "agentId": "main",
      "beforeCount": 120,
      "afterCount": 80,
      "pruned": 40
    }
  ]
}

记忆索引（可选）

OpenClaw 支持可选的语义记忆索引：

1
2
3
4
5
6
7
8
# 查看记忆状态
openclaw memory status

# 重新索引
openclaw memory index

# 搜索记忆
openclaw memory search "release checklist"

特点：

  • 非必需功能（可禁用）
  • 需要外部记忆插件
  • 支持向量搜索

4.3 管理机制对比

特性 Hermes OpenClaw
上下文压缩 ✅ 辅助模型压缩 ❌ 无压缩
置信度机制 ✅ 观点置信度 ❌ 无置信度
字符限制 ✅ 严格限制（2200/1375） ❌ 无限制
自动清理 ✅ 后台审查过滤 ⚠️ 手动维护
记忆质量评估 ❌ 无 ❌ 无
索引维护 ✅ FTS5 索引 ⚠️ 可选插件

五、安全机制：如何保护记忆的完整性？

5.1 Hermes：多层安全扫描

记忆内容扫描

Hermes 实现了全面的安全扫描机制：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
_MEMORY_THREAT_PATTERNS = [
    # Prompt injection
    (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"),

    # Exfiltration
    (r'curl\s+[^\n]*\$\{?\w*(KEY|TOKEN|SECRET)', "exfil_curl"),
    (r'cat\s+[^\n]*(\.env|credentials|\.netrc)', "read_secrets"),

    # Persistence
    (r'authorized_keys', "ssh_backdoor"),
    (r'\$HOME/\.ssh', "ssh_access"),
]

def _scan_memory_content(content: str) -> Optional[str]:
    """扫描记忆内容，阻止注入/外泄"""
    # 检查不可见 Unicode 字符
    for char in _INVISIBLE_CHARS:
        if char in content:
            return f"Blocked: invisible unicode character U+{ord(char):04X}"

    # 检查威胁模式
    for pattern, pid in _MEMORY_THREAT_PATTERNS:
        if re.search(pattern, content, re.IGNORECASE):
            return f"Blocked: threat pattern '{pid}' detected"
    return None

扫描时机：

  • 记忆写入前
  • 技能创建前
  • 技能更新前

技能安全扫描

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def _security_scan_skill(skill_dir: Path) -> Optional[str]:
    """安全扫描技能目录，阻止恶意代码"""
    if not _GUARD_AVAILABLE:
        return None
    try:
        result = scan_skill(skill_dir, source="agent-created")
        allowed, reason = should_allow_install(result)

        if allowed is False:
            # 阻止安装：回滚更改
            return f"Security scan blocked this skill ({reason})..."
        if allowed is None:
            # "ask" 级别：允许但记录警告
            logger.warning("Agent-created skill has security findings: %s", reason)
            return None
    except Exception as e:
        logger.warning("Security scan failed for %s: %s", skill_dir, e)
    return None

原子性写入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def _atomic_write_text(file_path: Path, content: str, encoding: str = "utf-8") -> None:
    """原子性写入：使用临时文件 + os.replace"""
    file_path.parent.mkdir(parents=True, exist_ok=True)
    fd, temp_path = tempfile.mkstemp(
        dir=str(file_path.parent),
        prefix=f".{file_path.name}.tmp.",
        suffix="",
    )
    try:
        with os.fdopen(fd, "w", encoding=encoding) as f:
            f.write(content)
        os.replace(temp_path, file_path)  # 原子操作
    except Exception:
        # 失败时清理临时文件
        try:
            os.unlink(temp_path)
        except OSError:
            pass
        raise

优势：

  • 防止崩溃导致的数据损坏
  • 支持并发写入
  • 文件系统级别的原子性

文件锁保护

1
2
3
4
5
6
7
8
9
10
11
12
13
@staticmethod
@contextmanager
def _file_lock(path: Path):
    """获取独占文件锁，确保读写安全"""
    lock_path = path.with_suffix(path.suffix + ".lock")
    lock_path.parent.mkdir(parents=True, exist_ok=True)
    fd = open(lock_path, "w")
    try:
        fcntl.flock(fd, fcntl.LOCK_EX)  # 独占锁
        yield
    finally:
        fcntl.flock(fd, fcntl.LOCK_UN)
        fd.close()

5.2 OpenClaw：沙箱隔离 + 访问控制

多 Agent 隔离

OpenClaw 通过多 Agent 隔离保护记忆：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{
  "agents": {
    "list": [
      {
        "id": "main",
        "workspace": "~/.openclaw/workspace"
      },
      {
        "id": "work",
        "workspace": "~/.openclaw/workspace-work"
      }
    ]
  }
}

特点：

  • 每个 Agent 有独立 workspace
  • 完全隔离的记忆和技能
  • 防止跨 Agent 污染

沙箱支持

OpenClaw 支持 Docker 沙箱：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{
  "agents": {
    "list": [
      {
        "id": "family",
        "sandbox": {
          "mode": "all",
          "scope": "agent",
          "docker": {
            "setupCommand": "apt-get update && apt-get install -y git curl"
          }
        }
      }
    ]
  }
}

特点：

  • Agent 运行在隔离容器中
  • 无法访问宿主机文件
  • 可控的文件系统访问

工具限制

1
2
3
4
5
6
{
  "tools": {
    "allow": ["read"],
    "deny": ["exec", "write", "edit"]
  }
}

特点：

  • per-agent allow/deny 列表
  • 细粒度的工具控制
  • 防止危险操作

5.3 安全机制对比

安全维度 Hermes OpenClaw
内容扫描 ✅ 注入/外泄检测 ❌ 无自动扫描
技能扫描 ✅ 安全扫描 ❌ 无扫描
原子写入 ✅ 临时文件 + rename ⚠️ 依赖文件系统
文件锁 ✅ fcntl 文件锁 ❌ 无文件锁
沙箱隔离 ❌ 无 ✅ Docker 沙箱
多 Agent 隔离 ❌ 单 Agent ✅ 完全隔离
访问控制 ❌ 无 ✅ allow/deny 列表

六、架构设计启示：从对比中学到的经验

6.1 记忆模型的选择

Hermes 的启示：

  • 理论驱动的设计（三元记忆模型）有助于系统化思考
  • 区分不同类型的记忆可以提高检索效率
  • 置信度机制对于观点类记忆很有价值

OpenClaw 的启示：

  • 简单直接的设计更容易上手和维护
  • Markdown 作为源文件是人类友好的选择
  • 灵活性胜过严格分类

最佳实践建议：

  • 对于研究型 Agent：采用 Hermes 的结构化模型
  • 对于工程型 Agent：采用 OpenClaw 的实用主义
  • 考虑混合方案：基础分类 + 灵活扩展

6.2 自动化 vs 手动控制

Hermes 的自动化：

  • 后台审查减少了用户负担
  • 智能提取提高了记忆质量
  • 但可能产生噪音

OpenClaw 的手动控制：

  • Agent 自主决策更加灵活
  • 避免了不必要的记忆
  • 但需要 Agent 的良好判断

最佳实践建议：

  • 实现可配置的自动化级别
  • 提供手动覆盖机制
  • 让用户选择自动化程度

6.3 检索策略的设计

Hermes 的检索：

  • FTS5 提供了高效的全文搜索
  • 实体中心检索符合人类认知
  • 预取机制优化了性能

OpenClaw 的检索：

  • Skills 自动加载简单有效
  • 文件读取工具提供了灵活性
  • 但缺乏高级检索能力

最佳实践建议：

  • 实现 FTS5 或类似的全文搜索
  • 考虑实体和时间维度的检索
  • 实现预取机制减少延迟

6.4 安全性的重要性

Hermes 的安全：

  • 多层扫描防止了注入和外泄
  • 原子写入保证了数据完整性
  • 文件锁防止了并发冲突

OpenClaw 的安全：

  • 沙箱隔离提供了运行时保护
  • 多 Agent 隔离防止了污染
  • 工具限制减少了风险

最佳实践建议：

  • 同时实现内容扫描和沙箱隔离
  • 使用原子性写入保护关键数据
  • 实现多层安全防护

6.5 可扩展性的考量

Hermes 的扩展：

  • 记忆提供者插件系统允许外部集成
  • 但限制为 1 个外部提供者
  • 技能生态系统丰富

OpenClaw 的扩展：

  • 工具注册机制灵活
  • 通道插件支持
  • 但记忆系统缺乏扩展点

最佳实践建议：

  • 设计抽象接口支持插件
  • 不要过度限制插件数量
  • 提供清晰的插件文档

七、未来方向：记忆系统的演进

7.1 智能记忆管理

当前挑战：

  • 记忆可能过时或不相关
  • 低价值记忆占用空间
  • 难以评估记忆的质量

未来方向：

  • 记忆质量评估：基于使用频率和有效性计算记忆价值
  • 自动清理：定期清理低价值记忆
  • 记忆压缩：将相关记忆合并为摘要

实现思路：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def evaluate_memory_quality(memory: Memory) -> float:
    """评估记忆质量"""
    score = 0.0

    # 使用频率（最近 30 天）
    if memory.last_used_days_ago < 30:
        score += 0.3

    # 检索成功率
    if memory.retrieval_success_rate > 0.7:
        score += 0.3

    # 相关性（与其他记忆的关联）
    if memory.related_count > 3:
        score += 0.2

    # 新鲜度
    if memory.created_days_ago < 90:
        score += 0.2

    return score

# 清理低价值记忆
low_quality_memories = [
    m for m in all_memories
    if evaluate_memory_quality(m) < 0.3
]

7.2 语义记忆增强

当前挑战：

  • 关键词搜索难以捕捉语义
  • 缺乏概念关联和推理能力
  • 难以处理模糊查询

未来方向：

  • 向量嵌入：使用 embedding 模型为记忆生成向量
  • 语义搜索：基于向量相似度的检索
  • 知识图谱：构建记忆间的关联关系

实现思路：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
# 生成向量嵌入
def generate_embedding(memory: Memory) -> np.ndarray:
    """使用本地模型生成向量"""
    model = load_embedding_model("all-MiniLM-L6-v2")
    return model.encode(memory.content)

# 语义搜索
def semantic_search(query: str, top_k: int = 10) -> List[Memory]:
    """基于向量相似度的搜索"""
    query_embedding = generate_embedding(query)

    similarities = [
        (m, cosine_similarity(query_embedding, m.embedding))
        for m in all_memories
    ]

    return sorted(similarities, key=lambda x: x[1], reverse=True)[:top_k]

# 构建知识图谱
def build_knowledge_graph(memories: List[Memory]) -> nx.Graph:
    """构建记忆关联图"""
    G = nx.Graph()

    for m in memories:
        G.add_node(m.id, **m.to_dict())

    # 添加边（基于实体重叠）
    for m1, m2 in combinations(memories, 2):
        if m1.entities & m2.entities:
            G.add_edge(m1.id, m2.id, weight=len(m1.entities & m2.entities))

    return G

7.3 跨会话记忆共享

当前挑战：

  • 不同会话的记忆难以共享
  • Agent 间缺乏知识传递机制
  • 重复学习相同知识

未来方向：

  • 共享记忆库：多个 Agent 共享同一个记忆存储
  • 记忆同步：自动同步相关记忆到其他 Agent
  • 记忆版本控制：追踪记忆的演进历史

实现思路：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class SharedMemoryStore:
    """共享记忆存储"""

    def __init__(self):
        self.memories: Dict[str, Memory] = {}
        self.agent_subscriptions: Dict[str, Set[str]] = defaultdict(set)

    def add_memory(self, memory: Memory, agent_id: str):
        """添加记忆并通知订阅的 Agent"""
        self.memories[memory.id] = memory

        # 通知相关 Agent
        for sub_agent in self.agent_subscriptions[agent_id]:
            self._notify_agent(sub_agent, memory)

    def subscribe(self, agent_id: str, tags: Set[str]):
        """Agent 订阅特定标签的记忆"""
        self.agent_subscriptions[agent_id] = tags

    def _notify_agent(self, agent_id: str, memory: Memory):
        """通知 Agent 新记忆"""
        if memory.tags & self.agent_subscriptions[agent_id]:
            send_to_agent(agent_id, memory)

7.4 记忆解释性与可审计性

当前挑战：

  • 难以理解为什么检索到某条记忆
  • 记忆来源和更新历史不透明
  • 难以调试记忆系统

未来方向：

  • 检索解释：解释为什么检索到某条记忆
  • 记忆溯源：追踪记忆的创建和更新历史
  • 可视化界面：提供记忆系统的可视化监控

实现思路：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
class ExplainableMemoryRetrieval:
    """可解释的记忆检索"""

    def retrieve_with_explanation(self, query: str) -> Tuple[List[Memory], str]:
        """检索记忆并提供解释"""
        # 执行检索
        memories = self._retrieve(query)

        # 生成解释
        explanations = []
        for m in memories:
            reason = []
            if m.matches_keywords(query):
                reason.append("matched keywords")
            if m.similar_to_recent_queries(query):
                reason.append("similar to recent queries")
            if m.has_relevant_entities(query):
                reason.append("contains relevant entities")
            if m.was_retrieved_recently():
                reason.append("recently retrieved")

            explanations.append(f"{m.id}: {', '.join(reason)}")

        return memories, "\n".join(explanations)

# 记忆溯源
class MemoryAuditLog:
    """记忆审计日志"""

    def __init__(self):
        self.history: List[MemoryEvent] = []

    def log_creation(self, memory: Memory, agent_id: str):
        """记录记忆创建"""
        event = MemoryEvent(
            type="created",
            memory_id=memory.id,
            agent_id=agent_id,
            timestamp=datetime.now(),
            content_snapshot=memory.content
        )
        self.history.append(event)

    def get_history(self, memory_id: str) -> List[MemoryEvent]:
        """获取记忆的完整历史"""
        return [e for e in self.history if e.memory_id == memory_id]

八、结论：选择适合的记忆机制

8.1 什么时候选择 Hermes 的记忆机制？

适合场景：

  • 需要深度自我学习和经验沉淀
  • 长期维护复杂项目
  • 需要结构化的知识管理
  • 追求记忆系统的理论完整性

优势：

  • 自动知识提取减少用户负担
  • 结构化模型便于理解和扩展
  • 丰富的检索能力（实体、时间、语义）
  • 强大的安全机制

劣势：

  • 学习曲线较陡
  • 配置相对复杂
  • 单 Agent 限制

8.2 什么时候选择 OpenClaw 的记忆机制？

适合场景：

  • 快速原型开发
  • 多 Agent 协作环境
  • 需要简单直接的解决方案
  • 强调灵活性和可维护性

优势：

  • 简单易懂，上手快
  • Markdown 友好，易于编辑
  • 灵活的项目级隔离
  • 多 Agent 支持

劣势：

  • 缺乏自动化知识提取
  • 检索能力有限
  • 无高级记忆管理功能

8.3 融合方案：取长补短

理想的记忆系统应该结合两者的优势：

从 Hermes 学习：

  • 后台自动审查机制
  • 结构化的记忆分类
  • FTS5 全文搜索
  • 实体和时间维度的检索
  • 安全扫描机制

从 OpenClaw 学习：

  • Markdown 作为源文件
  • 灵活的项目级隔离
  • 技能系统的简洁设计
  • 多 Agent 支持

可能的融合架构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
┌─────────────────────────────────────────────────────────────┐
│                    Hybrid Memory System                     │
├─────────────────────────────────────────────────────────────┤
│  Storage Layer (Hermes + OpenClaw)                          │
│  ├── Markdown Source (human-readable, git-friendly)         │
│  ├── SQLite Index (FTS5 + embeddings)                      │
│  └── Atomic Writes (temp file + rename)                     │
├─────────────────────────────────────────────────────────────┤
│  Management Layer (Hermes-inspired)                         │
│  ├── Background Review (auto extract knowledge)             │
│  ├── Confidence Scoring (opinion evolution)                 │
│  ├── Quality Evaluation (auto cleanup)                      │
│  └── Security Scanning (injection/exfiltration)             │
├─────────────────────────────────────────────────────────────┤
│  Retrieval Layer (Hybrid)                                   │
│  ├── FTS5 Full-Text Search                                   │
│  ├── Semantic Search (embeddings)                            │
│  ├── Entity-Centric Retrieval                                │
│  ├── Temporal Queries                                        │
│  └── Skills Auto-Load                                        │
├─────────────────────────────────────────────────────────────┤
│  Agent Layer (OpenClaw-inspired)                            │
│  ├── Multi-Agent Isolation                                   │
│  ├── Sandbox Support                                         │
│  ├── Per-Agent Workspace                                    │
│  └── Flexible Tool Access Control                            │
└─────────────────────────────────────────────────────────────┘

九、总结与展望

记忆系统是 AI Agent 的灵魂，决定了 Agent 能否真正”记住”用户、学习经验、持续进化。

通过对比 OpenClaw 和 Hermes Agent 的记忆机制，我们看到了两种不同的设计哲学：

  • Hermes：理论驱动、自动化、结构化
  • OpenClaw：实用主义、简单直接、灵活

两者各有优劣，没有绝对的对错。选择哪种机制，取决于你的具体需求、使用场景和团队偏好。

未来的记忆系统可能会向以下方向发展：

  1. 更智能的记忆管理：自动评估记忆质量，清理低价值记忆
  2. 更强大的语义理解：向量嵌入、知识图谱、推理能力
  3. 更好的跨会话协作：共享记忆库、记忆同步、版本控制
  4. 更高的可解释性：检索解释、记忆溯源、可视化监控

无论选择哪种机制，最重要的是：让记忆真正服务于 Agent 的智能进化，而不是成为负担。

参考文献

  1. Hermes Agent

  2. OpenClaw

  3. 相关研究

    • Hindsight: “retain / recall / reflect” memory framework
    • Letta/MemGPT: core memory + archival memory
    • Mem0: AI-native memory system

文章字数: ~15,000 字
分析深度: 架构级 + 代码级对比
发布日期: 2026-05-08
作者: daoyu (来顺)

相关阅读：

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

程序员，关于技术我所知甚少，唯有探索，方得真知。