Python智能体框架Hermes Agent架构解析与实践

1. Hermes Agent 架构概览

Hermes Agent 是一个基于 Python 开发的智能体框架，其核心设计目标是构建一个稳定、高效且可扩展的 AI 代理系统。整个系统采用分层架构设计，各层职责明确，通过清晰的调用链实现从用户输入到结果交付的完整流程。

1.1 核心组件与数据流

系统主要包含以下关键组件：

• 入口层：处理不同渠道的输入（CLI、Gateway、Cron）
• 运行时解析：统一管理 provider 和认证信息
• 核心 Agent：维护会话状态和执行主循环
• 工具调度：动态加载和执行功能工具
• 上下文管理：处理长会话压缩和记忆存储
• 持久化层：会话状态和历史的存储与检索
• 交付层：适配不同输出渠道的响应渲染

数据流动遵循严格的单向依赖原则，上层组件通过明确定义的接口调用下层服务，避免了复杂的循环依赖。

1.2 设计哲学与关键约束

系统在设计时确立了三个核心原则：

1. 稳定性优先：system prompt 保持稳定以确保 prefix cache 命中率
2. 完整性保障：严格维护 tool_call 和 tool_result 的配对关系
3. 持久化可靠：采用多层增量保存策略防止会话丢失

这些原则直接影响了许多具体实现决策，也是系统能够保持高效运行的基础。

2. 系统入口与初始化流程

2.1 三大入口实现对比

Hermes 支持三种主要入口方式，每种都有其特定的初始化逻辑：

2.1.1 CLI 入口深度解析

CLI 入口的核心逻辑集中在 cli.py 的 HermesCLI 类中。其实例化过程包含几个关键步骤：

1. 运行时凭证解析：

python复制def _ensure_runtime_credentials(self):
    self.runtime = resolve_runtime_provider(
        requested_provider=self.requested_provider,
        api_key=self.api_key,
        base_url=self.base_url
    )
    # 验证凭证有效性
    if not validate_runtime(self.runtime):
        raise CredentialError("Invalid runtime configuration")

2. Agent 初始化：

python复制def _init_agent(self, force_new=False):
    if force_new or self._should_recreate_agent():
        self.agent = AIAgent(
            provider=self.runtime['provider'],
            api_key=self.runtime['api_key'],
            model=self.model,
            session_db=self.session_db
        )
    # 注册回调函数
    self._register_callbacks()

3. 会话恢复机制：
   当检测到现有会话时，CLI 会：

• 从 SessionDB 加载历史消息
• 重建 todo store 状态
• 保持相同的 system prompt 签名

关键经验：CLI 在设计上采用了"配置变化即重建"的策略，这虽然增加了少量开销，但避免了复杂的配置迁移问题。在实际使用中发现，这种设计显著降低了因配置不一致导致的诡异问题。

2.1.2 Gateway 入口的特殊处理

Gateway 实现位于 gateway/run.py，其核心特点是：

1. 平台上下文隔离：

python复制# 不污染持久化的 system prompt
ephemeral_prompt = build_session_context_prompt(platform_ctx)
messages = [{
    'role': 'system',
    'content': ephemeral_prompt
}] + history

2. Agent 缓存策略：

python复制def _get_cached_agent(session_key, config_signature):
    cache_key = f"{session_key}:{config_signature}"
    if cache_key not in _agent_cache:
        _agent_cache[cache_key] = _create_agent_for_session(...)
    return _agent_cache[cache_key]

3. Transcript 双写机制：

• 主存储使用 SessionDB 的 SQLite
• 同时维护 JSONL 格式的 transcript 文件
• 两种格式通过定期同步保持一致性

2.1.3 Cron 入口的优化设计

Cron 任务在 cron/scheduler.py 中实现，其特殊设计包括：

1. 无头(Headless)模式优化：

python复制agent = AIAgent(
    platform="cron",
    disabled_toolsets=["cronjob", "messaging", "clarify"],
    skip_memory=True
)

2. 执行超时控制：

python复制with ThreadPoolExecutor() as executor:
    future = executor.submit(agent.run_conversation, prompt)
    try:
        result = future.result(timeout=job.timeout)
    except TimeoutError:
        handle_cron_timeout(job)

3. 结果自动交付：

• 输出保存为 Markdown
• 支持多种交付方式（邮件、webhook等）
• 内置重试和错误处理机制

3. 运行时解析与认证管理

3.1 统一运行时解析流程

runtime_provider.py 和 auth.py 共同构成了运行时解析系统，其工作流程如下：

1. Provider 识别阶段：

mermaid复制graph TD
    A[resolve_requested_provider] --> B{是否显式指定?}
    B -->|是| C[使用指定provider]
    B -->|否| D[检测环境默认]
    D --> E[检查配置继承]
    E --> F[应用回退策略]

2. 凭证解析过程：

python复制def resolve_runtime_credentials(provider):
    if provider == 'nous':
        return resolve_nous_credentials()
    elif provider == 'anthropic':
        return resolve_anthropic_token()
    elif provider in API_KEY_PROVIDERS:
        return resolve_api_key_provider(provider)
    else:
        raise UnsupportedProviderError(provider)

3. 最终运行时对象：

python复制runtime = {
    'provider': 'openai',
    'api_mode': 'chat_completions',
    'base_url': 'https://api.openai.com/v1',
    'api_key': 'sk-...',
    'credential_pool': [...],
    'requested_provider': 'openai'
}

3.2 多Provider支持实现

系统支持多种AI provider，每种都有特定的适配逻辑：

实战经验：Anthropic provider 对消息格式要求极为严格，我们在实现中发现必须进行以下处理：

1. 移除所有空值字段
2. 确保tool_call和tool_result严格配对
3. 对长消息进行预分割
   这些限制在实际开发中耗费了大量调试时间，但最终换来了更高的稳定性。

3.3 认证池与故障转移

系统实现了灵活的凭证管理机制：

1. 凭证池配置：

python复制credential_pool = [
    {"provider": "openai", "api_key": "key1", "priority": 1},
    {"provider": "openai", "api_key": "key2", "priority": 2},
    {"provider": "anthropic", "token": "token1"}
]

2. 故障转移逻辑：

python复制def get_working_credential(pool):
    for cred in sorted(pool, key=lambda x: x.get('priority', 0)):
        if test_credential(cred):
            return cred
    raise NoValidCredentialError()

3. 自动刷新机制：

• Codex token 每小时刷新
• Nous portal token 每日刷新
• 缓存失效时自动重新认证

4. AIAgent 核心运行机制

4.1 初始化过程详解

AIAgent.__init__() 完成了大量基础工作：

1. 客户端创建：

python复制if api_mode == "anthropic_messages":
    self.client = AnthropicClient(api_key)
elif api_mode == "codex_responses":
    self.client = CodexResponseClient(base_url, api_key)
else:
    self.client = OpenAIClient(base_url, api_key)

2. 工具系统初始化：

python复制self.tools = get_tool_definitions(
    enabled_toolsets=enabled_toolsets,
    disabled_toolsets=disabled_toolsets
)
self.valid_tool_names = [t.name for t in self.tools if t.is_available()]

3. 记忆系统设置：

python复制self._memory_store = MemoryStore()
self._memory_manager = MemoryManager(
    store=self._memory_store,
    provider_plugins=memory_providers
)

4. 上下文压缩器：

python复制self.context_compressor = ContextCompressor(
    model=model,
    provider=provider,
    threshold=compression_threshold,
    protect_last_n=compression_protect_last_n
)

4.2 主会话循环剖析

run_conversation() 实现了核心的同步循环逻辑：

1. 循环状态机：

python复制while not should_terminate:
    # 准备API载荷
    api_messages = self._prepare_api_messages()
    
    # 调用模型
    response = self._call_model(api_messages)
    
    if response.has_tool_calls:
        # 处理工具调用
        tool_results = self._execute_tools(response.tool_calls)
        self._append_tool_results(tool_results)
    else:
        # 最终响应处理
        self._process_final_response(response)
        break
    
    # 上下文压缩检查
    if self._needs_compression():
        self._compress_context()

2. 消息准备关键步骤：

• 清洗用户输入中的特殊字符
• 注入 memory 和插件上下文
• 修复历史消息中的工具调用痕迹
• 应用 prompt cache 标记

3. 模型调用适配层：

python复制def _call_model(self, messages):
    if self.api_mode == "anthropic_messages":
        return self._call_anthropic(messages)
    elif self.api_mode == "codex_responses":
        return self._call_codex(messages)
    else:
        return self._call_openai(messages)

4.3 工具执行流程

工具调度系统是 Hermes 最复杂的部分之一：

1. 工具发现机制：

python复制# 在模块加载时自动注册工具
def register_tool(name, schema, func):
    Registry.register(
        name=name,
        schema=schema,
        func=func,
        check_fn=check_availability
    )

# 示例工具注册
register_tool(
    name="web_search",
    schema=WEB_SEARCH_SCHEMA,
    func=web_search_impl
)

2. 并行执行控制：

python复制def _should_parallelize(tool_calls):
    if len(tool_calls) == 1:
        return False
    
    # 检查工具冲突
    if any(tool.name in CONFLICT_TOOLS for tool in tool_calls):
        return False
    
    # 检查资源冲突
    if has_path_conflict(tool_calls):
        return False
    
    return True

3. 执行结果处理：

• 验证返回值的 JSON 结构
• 应用结果后处理钩子
• 处理特殊返回值（如重试、澄清）
• 更新工具使用统计信息

性能提示：在实际测试中发现，当工具执行涉及网络IO时，并行化可以显著降低延迟。我们建立了一个简单的性能模型：
串行延迟 = Σ(每个工具延迟)
并行延迟 = max(工具组延迟) + 协调开销
在实践中，对于3-4个独立工具调用，并行化通常能带来2-3倍的加速比。

5. 提示词工程实现

5.1 系统提示词构建

_build_system_prompt() 实现了多层次的提示词组装：

1. 组件加载顺序：

python复制components = [
    load_agent_identity(),          # 1. SOUL.md 或默认身份
    build_tool_aware_guidance(),    # 2. 工具相关引导
    get_nous_subscription_prompt(), # 3. 订阅信息
    build_tool_enforcement(),       # 4. 工具使用强化
    user_system_message,            # 5. 用户自定义
    build_memory_prompt(),          # 6. 记忆块
    external_memory_prompt,         # 7. 外部记忆
    build_skills_prompt(),          # 8. 技能索引
    build_context_files_prompt(),   # 9. 项目上下文
    build_metadata_prompt()         # 10. 元数据
]

2. 上下文文件处理：

python复制def build_context_files_prompt():
    for file in CONTEXT_FILE_PRIORITY:
        if os.path.exists(file):
            content = _read_and_filter(file)
            return f"项目上下文：\n{content}\n"
    return ""

3. 技能索引生成：

python复制@lru_cache
def build_skills_system_prompt():
    skills = discover_skills()
    snapshot = load_snapshot_if_valid()
    if snapshot and snapshot['version'] == SKILLS_VERSION:
        return snapshot['prompt']
    
    prompt = generate_skills_prompt(skills)
    save_snapshot(prompt)
    return prompt

5.2 提示词缓存策略

系统采用三级缓存机制：

1. 会话级缓存：

python复制self._cached_system_prompt = build_full_prompt()

2. 磁盘快照：

json复制{
  "version": "2024.03",
  "hash": "a1b2c3d4",
  "prompt": "..."
}

3. Provider前缀缓存：

python复制def apply_cache_control(messages):
    if len(messages) > 4:
        return add_cache_breaks(messages[:4]) + messages[4:]
    return messages

优化经验：在长时间运行的网关服务中，我们发现提示词缓存可以降低约40%的API延迟。但这也带来一个挑战 - 当需要更新提示词组件时，必须显式地使缓存失效。我们最终实现了一个版本化缓存机制，任何提示词组件的变更都会自动反映在缓存键中。

6. 上下文管理与压缩

6.1 压缩触发条件

系统在三个场景下会触发上下文压缩：

1. 预检压缩：

python复制def _preflight_compress_if_needed(messages):
    estimated = estimate_tokens(messages)
    if estimated > self.compression_threshold * 0.8:  # 提前压缩
        return self._compress_context(messages, proactive=True)
    return messages

2. 正常压缩：

python复制if self._current_token_count > self.compression_threshold:
    self._compress_context()

3. 错误恢复压缩：

python复制except APIError as e:
    if e.code == 'context_length_exceeded':
        self._compress_context()
        retry_count += 1

6.2 压缩算法实现

ContextCompressor.compress() 的核心逻辑：

1. 工具结果修剪：

python复制def _prune_old_tool_results(messages):
    return [msg for msg in messages 
            if not (is_old_tool_result(msg) and not is_important_result(msg))]

2. 结构化摘要生成：

python复制def _generate_summary(messages):
    sections = {
        'Goal': extract_goal(messages),
        'Constraints': extract_constraints(messages),
        'Progress': extract_progress(messages),
        'Decisions': extract_decisions(messages),
        'NextSteps': extract_next_steps(messages)
    }
    return format_as_markdown(sections)

3. 完整性修复：

python复制def _fix_tool_pairs(messages):
    for i, msg in enumerate(messages):
        if is_tool_call(msg) and not has_matching_result(messages, i+1):
            messages.insert(i+1, create_stub_result(msg))
    return messages

6.3 会话连续性维护

压缩后的会话管理：

1. 会话分割：

python复制old_session_id = self.session_id
self.session_db.end_session(old_session_id, reason="compression")
new_session_id = self.session_db.create_session(
    parent_session_id=old_session_id,
    title=f"Continued from {old_session_id}"
)

2. 状态迁移：

python复制self.todo_store.snapshot()  # 保存待办事项
self.memory_manager.flush()  # 写入关键记忆
self._invalidate_system_prompt()  # 重建提示词

3. 新会话初始化：

python复制self._init_new_session_after_compression(
    new_session_id,
    compressed_messages
)

7. 持久化与状态管理

7.1 会话存储设计

SessionDB 的 SQLite 表结构：

1. sessions 表：

sql复制CREATE TABLE sessions (
    id TEXT PRIMARY KEY,
    parent_id TEXT,
    created_at REAL,
    ended_at REAL,
    title TEXT,
    model TEXT,
    provider TEXT,
    system_prompt_hash TEXT,
    compression_count INTEGER
);

2. messages 表：

sql复制CREATE TABLE messages (
    id INTEGER PRIMARY KEY,
    session_id TEXT,
    role TEXT,
    content TEXT,
    timestamp REAL,
    tool_name TEXT,
    token_count INTEGER,
    FOREIGN KEY(session_id) REFERENCES sessions(id)
);

3. 全文搜索索引：

sql复制CREATE VIRTUAL TABLE messages_fts USING fts5(
    content,
    tokenize='porter unicode61'
);

7.2 写入优化策略

系统采用了几种写入优化技术：

1. 批量插入：

python复制def _bulk_insert_messages(session_id, messages):
    with self.conn:
        self.conn.executemany(
            "INSERT INTO messages VALUES (?,?,?,?,?,?,?)",
            [(None, session_id, msg['role'], msg['content'], 
              msg['timestamp'], msg.get('tool'), msg.get('tokens'))]
        )

2. 增量更新：

python复制self._last_flushed_db_idx = len(self._session_messages) - 1

3. WAL模式：

python复制self.conn.execute("PRAGMA journal_mode=WAL")
self.conn.execute("PRAGMA synchronous=NORMAL")

7.3 Gateway 会话管理

SessionStore 的特殊处理：

1. 会话键生成：

python复制def _generate_session_key(source):
    return f"{source.platform}:{source.channel}:{source.user}"

2. Transcript 双写：

python复制def append_to_transcript(session_id, message):
    # 写入SQLite
    self.session_db.append_message(session_id, message)
    
    # 追加到JSONL
    with open(get_transcript_path(session_id), 'a') as f:
        f.write(json.dumps(message) + '\n')

3. 会话恢复：

python复制def load_transcript(session_id):
    # 优先从SQLite加载
    messages = self.session_db.get_messages(session_id)
    if not messages:
        # 回退到JSONL
        messages = self._load_from_jsonl(session_id)
    return messages

8. 结果交付与输出适配

8.1 CLI 输出渲染

CLI 的 Rich 渲染实现：

1. 流式输出处理：

python复制def _stream_delta(content):
    self.live.update(
        Panel(
            Align.left(Text(content)),
            title="Hermes",
            border_style="blue"
        )
    )

2. 工具进度显示：

python复制def _tool_progress(tool_name, progress):
    self.progress.update(
        task_id=tool_name,
        description=f"Processing {tool_name}",
        completed=progress
    )

3. 最终结果格式化：

python复制def _format_final_response(response):
    if response.get('format') == 'markdown':
        return Markdown(response['content'])
    else:
        return Text(response['content'])

8.2 Gateway 适配器模式

Gateway 的适配器抽象：

1. 适配器接口：

python复制class Adapter(ABC):
    @abstractmethod
    def send(self, content, attachments=None):
        pass
    
    @abstractmethod
    def receive(self):
        pass

2. 平台实现示例：

python复制class SlackAdapter(Adapter):
    def send(self, content, attachments=None):
        client.chat_postMessage(
            channel=self.channel,
            text=content,
            attachments=[convert_to_slack_attachment(a) for a in attachments]
        )

3. 媒体处理：

python复制def _deliver_media(response):
    for media in extract_media_tags(response):
        if media.startswith('http'):
            adapter.send_embed(media)
        else:
            adapter.send_file(media)

8.3 Cron 结果处理

Cron 的自动化输出管道：

1. Markdown 生成：

python复制def generate_markdown_report(result):
    template = """
    # Cron 任务报告
    **状态**: {status}
    **执行时间**: {timestamp}
    ## 输出
    {content}
    """
    return template.format(
        status="成功" if result.success else "失败",
        timestamp=datetime.now(),
        content=result.output
    )

2. 交付路由：

python复制def _resolve_delivery_target(job):
    if job.deliver_to == 'email':
        return EmailDelivery(job.config)
    elif job.deliver_to == 'webhook':
        return WebhookDelivery(job.config)
    else:
        return FileDelivery(job.config)

3. 错误处理：

python复制try:
    deliver_result(job, result)
except DeliveryError as e:
    log_error(f"交付失败: {e}")
    if job.retry_policy.should_retry():
        schedule_retry(job)

9. 关键问题排查指南

9.1 常见问题速查表

9.2 调试工具与技巧

1. 会话检查工具：

bash复制hermes debug session <session_id> --show-tokens

2. 提示词分析：

python复制agent.debug_print_prompt_components()

3. 性能分析：

python复制with Profiler() as p:
    agent.run_conversation(...)
p.print_stats()

9.3 关键日志点

1. 运行时解析：

python复制logger.debug(f"Resolved runtime: {json.dumps(runtime)}")

2. 工具执行：

python复制logger.info(f"Dispatching tool: {tool_name} with args {sanitized_args}")

3. 压缩事件：

python复制logger.warning(
    f"Compressing context from {len_before} to {len_after} messages"
)

10. 性能优化实践

10.1 关键性能指标

在实际部署中测量的典型数据：

10.2 优化策略

1. 连接池管理：

python复制self._client_pool = ConnectionPool(
    max_size=10,
    timeout=30,
    recycle=3600
)

2. 预编译语句：

python复制self._insert_stmt = self.conn.prepare(
    "INSERT INTO messages VALUES (?,?,?,?,?,?,?)"
)

3. 选择性加载：

python复制def get_recent_messages(session_id, limit=10):
    return self.conn.execute(
        "SELECT content FROM messages "
        "WHERE session_id=? ORDER BY id DESC LIMIT ?",
        (session_id, limit)
    )

10.3 资源监控

内置监控端点：

python复制@app.route('/_status')
def status():
    return {
        'memory': get_memory_usage(),
        'sessions': active_session_count(),
        'queue': pending_task_size()
    }

11. 扩展与定制

11.1 添加新工具

标准工具开发流程：

1. 创建工具模块：

python复制# tools/weather.py
from registry import register_tool

@register_tool
def get_weather(location: str, unit: str = 'celsius'):
    """获取指定位置的天气信息"""
    # 实现代码...

2. 定义JSON Schema：

json复制{
  "name": "get_weather",
  "description": "获取天气信息",
  "parameters": {
    "type": "object",
    "properties": {
      "location": {"type": "string"},
      "unit": {"enum": ["celsius", "fahrenheit"]}
    },
    "required": ["location"]
  }
}

3. 可用性检查：

python复制def check_weather_available():
    return check_api_key('WEATHER_API_KEY')

11.2 自定义记忆提供者

实现记忆插件的基本结构：

python复制class CustomMemoryProvider(MemoryProvider):
    def __init__(self, config):
        self.client = CustomClient(config)
    
    def retrieve(self, query, limit=5):
        results = self.client.search(query)
        return format_as_memories(results[:limit])
    
    def store(self, memory):
        self.client.index(
            id=memory['id'],
            content=memory['content'],
            metadata=memory['meta']
        )

# 注册插件
MemoryManager.register_provider('custom', CustomMemoryProvider)

11.3 修改提示词策略

定制提示词构建器：

python复制from agent.prompt_builder import PromptBuilder

class CustomPromptBuilder(PromptBuilder):
    def build_identity(self):
        if os.path.exists('CUSTOM_SOUL.md'):
            return read_file('CUSTOM_SOUL.md')
        return super().build_identity()

# 配置使用
agent = AIAgent(
    prompt_builder_class=CustomPromptBuilder,
    ...
)

12. 架构演进与经验教训

12.1 关键设计决策回顾

1. 同步循环 vs 异步架构：

• 选择了同步设计以简化调试
• 通过线程池处理阻塞操作
• 未来可能引入可选异步模式

2. 集中式工具注册：

• 显式优于隐式的哲学
• 启动时扫描确保一致性
• 代价是稍重的初始化过程

3. 多层持久化：

• SQLite 提供结构化查询
• JSONL 保持可读性
• 定期同步确保一致性

12.2 遇到的挑战与解决方案

1. Provider API 不稳定性：

• 实现了自动重试和回退
• 抽象了 provider 适配层
• 维护兼容性测试套件

2. 长会话性能下降：

• 开发了智能压缩算法
• 引入渐进式加载
• 优化 token 计数效率

3. 工具冲突问题：

• 建立并行安全标签系统
• 实现路径冲突检测
• 添加工具优先级机制

12.3 未来改进方向

1. 动态工具加载：

python复制def hot_load_tool(module_path):
    importlib.import_module(module_path)
    Registry.refresh()

2. 更细粒度的权限控制：

python复制class ToolPermission:
    def __init__(self, read, write, net):
        self.read_fs = read
        self.write_fs = write
        self.network = net

3. 增强的可观测性：

• 集成 OpenTelemetry
• 细粒度性能指标
• 交互式调试控制台

13. 部署与运维实践

13.1 系统要求

推荐的生产环境配置：

13.2 部署模式

支持的部署方案：

1. 单机模式：

bash复制python -m hermes.cli

2. 网关服务：

bash复制gunicorn -w 4 gateway.run:app

3. 容器化部署：

dockerfile复制FROM python:3.9
COPY . /app
RUN pip install -r /app/requirements.txt
EXPOSE 8000
CMD ["gunicorn", "-w", "4", "gateway.run:app"]

13.3 监控与告警

建议的监控指标：

1. 基础指标：

• API 响应时间
• 错误率
• 队列深度

2. 业务指标：

• 会话长度分布
• 工具调用频率
• 压缩率统计

3. 告警规则：

yaml复制rules:
  - alert: HighErrorRate
    expr: rate(api_errors_total[5m]) > 0.05
    for: 10m

14. 开发者指南

14.1 代码组织规范

项目目录结构：

code复制hermes/
├── agent/          # 核心逻辑
├── tools/          # 内置工具
├── gateway/        # 网关服务
├── cron/           # 定时任务
├── hermes_cli/     # CLI实现
├── tests/          # 测试套件
└── docs/           # 开发文档

14.2 测试策略

分层测试体系：

1. 单元测试：

bash复制pytest tests/unit -v

2. 集成测试：

bash复制pytest tests/integration --runslow

3. 端到端测试：

bash复制./test_e2e.sh --provider=openai

14.3 贡献流程

标准开发工作流：

1. 创建特性分支
2. 编写测试用例
3. 实现功能代码
4. 运行静态检查：

bash复制flake8 && mypy .

5. 提交 Pull Request

15. 典型应用场景

15.1 开发者助手

常见使用模式：

python复制agent.run_conversation("如何优化Python代码性能？")

15.2 自动化工作流

Cron 任务示例：

yaml复制jobs:
  - name: "每日报告"
    schedule: "0 9 * * *"
    prompt: "生成昨日的销售分析报告"
    deliver_to: "slack"

15.3 知识管理

记忆系统应用：

python复制agent.run_conversation(
    "记录：项目会议决定采用React框架",
    memory_tags=["project-x", "decision"]
)

16. 总结与最佳实践

经过对 Hermes Agent 核心运行系统的深入分析，我们可以提炼出以下关键经验：

1. 保持提示词稳定：这是 prefix cache 有效的前提，任何不必要的变化都会显著影响性能和成本。

2. 严格管理工具边界：清晰的工具契约和权限控制是系统安全的基石。

3. 设计容错的数据流：从入口到交付的每个环节都需要考虑错误处理和状态恢复。

4. 分层持久化策略：同时维护结构化存储和原始 transcript 提供了灵活性和可靠性。

5. 渐进式上下文管理：智能压缩算法让长会话成为可能，而不是负担。

对于希望基于 Hermes 进行二次开发的团队，建议从工具扩展入手，逐步深入核心系统的定制。同时，密切监控生产环境中的会话质量和系统性能，持续优化提示词和工具配置。