【深度解析】Hermes Agent：用“提示反向传播”打造可自我进化的 AI 智能体

摘要

本文从工程视角解析开源智能体 Hermes Agent 的核心机制：通过类反向传播的 KEPA 系统对"提示与技能"进行自我更新，构建可持续进化的个人 AI Agent。文章将拆解其记忆体系、自动技能生成能力，并给出基于 OpenAI 兼容接口（以薛定猫 xuedingmao.com 为例）的 Python 实战示例，帮助你在自己的业务中落地"自学习智能体"。

一、背景介绍：从 ChatGPT 到"可成长的智能体"

多数开发者当前的使用路径是：

LLM（ChatGPT / Claude / Gemini） + 一点 prompt engineering + 若干工具调用。

问题在于：

模型不会"记住"之前任务中的具体踩坑与修复过程
每个项目都要重新写一套 prompt / workflow
工具调用逻辑难以复用为"技能"

Hermes Agent 试图解决的正是这一类"LLM 不会主动进化"的痛点：

开源智能体框架，可本地运行，支持多模型与多终端（本地模型、手机端、WhatsApp、Telegram、Slack 等）。
自我改进机制：每调用约 15 次工具就自动"回放"执行过程，分析失败原因并更新自身配置。
无需微调模型：不修改模型参数，而是动态优化提示（prompts）、工具调用策略和技能（skills）。
自动技能生成：任务解决后会被固化为可复用的技能，未来在类似场景中自动调用。

本质上，它更接近一个"持续学习的 AI 操作系统"，而非单一聊天工具。

二、核心原理：KEPA 提示反向传播 + 记忆与技能系统

2.1 KEPA：对"提示"做反向传播

视频中提到的 KEPA，可以理解为一种"针对提示与 Agent 配置的反向传播机制"：

传统深度学习：
- 前向：输入 → 模型 → 输出
- 反向：根据损失函数，更新模型权重
Hermes 的做法：
- 前向：用户意图 → Hermes（LLM + 工具）→ 执行序列（工具调用链、代码生成等）
- 反向：周期性回顾近期执行：
  - 检测失败点（工具调用失败、结果不符合预期、用户纠错等）
  - 生成"改进提示 / 改进 skill 定义"
  - 更新记忆库、技能库和内部工作流描述

关键差异：

不是更新"模型权重"，而是更新"如何使用模型"的策略------包括提示模板、调用工具的顺序和条件、技能拆解方式等。

这实际上是把 prompt engineering 和 workflow design 变成了一个自动化、闭环优化的过程。

2.2 记忆系统：从对话历史中抽象"可复用知识"

Hermes 的记忆系统主要有两类：

短期执行记忆（Execution Memory）
- 记录最近一次或若干次任务的执行轨迹：调用了哪些工具、参数如何、结果怎样。
- 被 KEPA 用来回放和分析失败原因。
长期语义记忆（Long-term Semantic Memory）
- 从对话中抽取结构化知识：
  - 用户偏好的技术栈（如大量使用 shadcn UI、TailwindCSS 等）
  - 常用工作流（例如：先爬文档 → 同步到 Obsidian → 生成前端 UI）
- 存入向量库 / 知识库，在后续任务中按相似度检索并提供上下文。

视频中的 Obsidian 示例非常典型：

用户让 Hermes 将 shadcn UI 文档同步为 Obsidian 知识图谱；
Hermes 在之后生成前端时，会主动检索这份知识库，引用最新组件文档；
这部分"使用 Obsidian + shadcn 的前端构建流程"被固化为记忆和技能。

2.3 技能系统：自动生成可复用的"Agent 函数"

与传统工具调用不同，Hermes 会把"成功的任务执行过程"抽象为可复用技能（Skills）：

技能包含：
- 输入 / 输出描述（类似函数签名）
- 调用的工具链（例如：浏览器 → 代码生成 → 测试 → 修复）
- 所需的上下文 / 知识库引用方式

例子：

"manim 技能"：把复杂技术概念转成动画视频；
"obsidian 知识图谱技能"：从指定文档源同步知识到 Obsidian，并维护链接关系；
"前端仪表盘生成技能"：基于 shadcn 文档+历史 UI 偏好构建金融仪表盘前端。

这意味着：

你不再需要手工设计所有 Agent Workflow，

Hermes 会在你使用的过程中，把频繁出现的工作流封装为技能，并在相似场景中重用。

三、实战演示：用 Python + 薛定猫 API 搭建一个可进化的小型 Agent

虽然 Hermes Agent 本身是一个独立的开源项目，但在日常开发中，我们可以借鉴它的思想，用通用 LLM API 实现一个"简化版自进化 Agent"。

下面示例使用 薛定猫 AI（xuedingmao.com） 作为 OpenAI 兼容接口，模型使用 claude-sonnet-4-6，实现：

基础对话 + 工具调用
简单的"经验回顾 + 提示优化"
把成功解决方案固化为本地技能（存 JSON）

3.1 环境准备

bash 复制代码

pip install openai

3.2 Python 代码示例（可直接运行）

python 复制代码

import os
import json
from typing import List, Dict, Any
from openai import OpenAI

# ========== 配置区 ==========
# 在环境变量中设置你的薛定猫 API Key
# export XUEDINGMAO_API_KEY="your_api_key"
XDM_API_KEY = os.getenv("XUEDINGMAO_API_KEY")
if not XDM_API_KEY:
    raise RuntimeError("请先在环境变量中设置 XUEDINGMAO_API_KEY")

# 薛定猫使用 OpenAI 兼容接口，只需要替换 base_url 即可
client = OpenAI(
    api_key=XDM_API_KEY,
    base_url="https://xuedingmao.com/v1"
)

MODEL_NAME = "claude-sonnet-4-6"

SKILL_STORE_PATH = "skills.json"
MEMORY_STORE_PATH = "memory.json"


# ========== 工具函数：本地"记忆"和"技能"存储 ==========

def load_json(path: str, default: Any):
    if not os.path.exists(path):
        return default
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)


def save_json(path: str, data: Any):
    with open(path, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)


def load_skills() -> Dict[str, Dict]:
    return load_json(SKILL_STORE_PATH, {})


def save_skills(skills: Dict[str, Dict]):
    save_json(SKILL_STORE_PATH, skills)


def load_memory() -> List[Dict]:
    return load_json(MEMORY_STORE_PATH, [])


def save_memory(mem: List[Dict]):
    save_json(MEMORY_STORE_PATH, mem)


# ========== 核心：调用 LLM + 上下文（记忆 & 技能） ==========

def build_system_prompt(skills: Dict[str, Dict]) -> str:
    """
    根据当前技能库构造系统提示，相当于 Hermes 中的"技能注入"。
    """
    if not skills:
        return (
            "你是一个会自我改进的 AI 助手。"
            "当你成功解决一个问题时，会尝试用自然语言总结可复用步骤，"
            "以便未来在类似任务中复用。"
        )

    skill_descs = []
    for name, meta in skills.items():
        skill_descs.append(
            f"- 技能名：{name}\n"
            f"  适用场景：{meta.get('description', '')}\n"
            f"  使用说明：{meta.get('usage_hint', '')}"
        )

    return (
        "你是一个会自我改进的 AI 助手，拥有以下已学习技能：\n\n"
        + "\n".join(skill_descs)
        + "\n\n当发现当前任务与某个技能的适用场景相似时，"
          "请优先按照技能总结的步骤来规划解决方案，并在必要时进行调整。"
    )


def call_llm(messages: List[Dict[str, str]]) -> str:
    """
    调用薛定猫 OpenAI 兼容接口的对话模型。
    """
    resp = client.chat.completions.create(
        model=MODEL_NAME,
        messages=messages,
        temperature=0.2,
    )
    return resp.choices[0].message.content


# ========== 简易 KEPA：基于对话回顾生成新技能 ==========

def reflect_and_learn(conversation: List[Dict[str, str]], success: bool):
    """
    对一次对话进行"反思"，如果成功，则让模型帮我们总结可复用技能。
    """
    if not success:
        # 简化处理：失败暂不学习，真实场景可生成 "反模式说明" 或修复策略
        return

    skills = load_skills()

    reflection_prompt = [
        {
            "role": "system",
            "content": (
                "你现在是一个 Agent 教练，需要从下面这段对话中，"
                "抽取一个可复用的技能（如果合适）。"
                "技能用于：未来当用户提出类似问题时，可以重复使用这套步骤。"
                "输出严格使用 JSON 格式：\n"
                "{\n"
                '  "should_create": true/false,\n'
                '  "name": "技能名称（简短）",\n'
                '  "description": "适用场景的描述",\n'
                '  "usage_hint": "详细步骤或使用说明（面向未来的模型）"\n'
                "}"
            )
        },
        {
            "role": "user",
            "content": json.dumps(conversation, ensure_ascii=False, indent=2)
        }
    ]

    result = call_llm(reflection_prompt)
    try:
        data = json.loads(result)
    except json.JSONDecodeError:
        # 如果模型输出不合法，直接忽略
        return

    if not data.get("should_create"):
        return

    name = data.get("name") or "unnamed_skill"
    # 若重名，加个简单后缀
    if name in skills:
        idx = 2
        while f"{name}_{idx}" in skills:
            idx += 1
        name = f"{name}_{idx}"

    skills[name] = {
        "description": data.get("description", ""),
        "usage_hint": data.get("usage_hint", "")
    }
    save_skills(skills)
    print(f"[Agent] 新技能已学习：{name}")


# ========== 一个简单的交互循环示例 ==========

def interactive_agent():
    """
    一个最小可用的可进化 Agent Demo：
    - 持续与用户对话
    - 用户输入 'exit' 退出
    - 用户输入 'ok' 代表当前问题解决，触发一次"反思学习"
    """
    print("自进化 Agent Demo（基于 xuedingmao.com + claude-sonnet-4-6）")
    print("输入自然语言提问，输入 'ok' 表示当前问题已解决，'exit' 退出。\n")

    conversation_history: List[Dict[str, str]] = []
    turn_counter = 0

    while True:
        user_input = input("你：").strip()
        if user_input.lower() == "exit":
            break

        if user_input.lower() == "ok":
            # 认为最近这段对话"成功"，触发一次学习
            if conversation_history:
                reflect_and_learn(conversation_history, success=True)
                # 清空当前轮对话，模拟 Hermes 中"分段回顾"
                conversation_history = []
            continue

        # 加载当前技能，构造系统提示
        skills = load_skills()
        system_prompt = build_system_prompt(skills)

        messages = [
            {"role": "system", "content": system_prompt},
            *conversation_history,  # 保留本轮对话的上下文
            {"role": "user", "content": user_input}
        ]

        assistant_reply = call_llm(messages)
        print(f"Agent：{assistant_reply}\n")

        # 写入当前轮对话历史
        conversation_history.append({"role": "user", "content": user_input})
        conversation_history.append({"role": "assistant", "content": assistant_reply})

        # 简单模拟：每 15 条消息可以触发一次自动学习（类似 Hermes）
        turn_counter += 1
        if turn_counter % 15 == 0:
            reflect_and_learn(conversation_history, success=True)
            conversation_history = []


if __name__ == "__main__":
    interactive_agent()

使用方式：

在薛定猫（xuedingmao.com）获取 API Key，并设置环境变量 XUEDINGMAO_API_KEY。
运行脚本，和 Agent 进行多轮对话；
当你觉得某个问题"解决得不错"时输入 ok，脚本会触发反思学习，把这段对话总结为技能存入 skills.json；
后续对话，Agent 会自动在 system prompt 中注入这些技能，从而在类似任务中复用解决思路。

这只是一个极简 Demo，但已经具备了 Hermes Agent 的三大核心特征：

对话分段回顾
从成功经验中抽取"技能"
通过系统提示"进化"自身行为

四、注意事项与工程实践建议

4.1 与本地模型结合：成本与性能权衡

视频中展示了 Hermes Agent 可以：

检测本地 GPU / CPU 能力
推荐合适的本地模型（如 Gemma）
在本地运行 Agent，免去云端 API 费用

实际工程中可采用混合策略：

高频、对隐私友好的任务 → 本地模型（如 Gemma / Llama 家族）
对推理质量要求高的场景 → 云端强模型（如 GPT-5.4 / Claude 4.6 / Gemini 3 Pro）

利用类似薛定猫这样聚合多模型、统一接口的平台，可以轻松根据场景切换后端模型，而无需改动业务代码。

4.2 记忆与技能的"污染"问题

持续学习意味着存在"自我污染"的风险：

用户偶然给出错误信息，被当作长期记忆；
某次错误示范被固化为技能，在未来持续放大负面影响。

建议：

为记忆与技能库增加"可视化审阅 + 清理接口"；
为技能添加元信息：创建时间、可信度、使用次数等，做"技能降权或废弃"；
对关键任务的技能更新添加人工审批流程。

4.3 与外部知识库的集成设计

像视频中那样将 Obsidian 作为知识图谱后端，是非常值得借鉴的实践模式：

Agent 通过爬文档 → 清洗 → 写入 Obsidian vault
利用 Obsidian 的图谱/反向链接增强知识结构化
在 Agent 中通过"技能"来使用这些知识（例如，生成前端时优先引用 shadcn 文档）

类似方法可以替换为：

Notion / Confluence / 自建 Markdown 仓库
向量库（Milvus、Weaviate、PGVector 等）+ Agent 技能封装

关键在于把"知识库更新"本身也做成一个技能，并纳入 Agent 的自我改进回路。

五、技术资源：如何更高效地玩转多模型 Agent

在开发类似 Hermes 的多模型智能体时，会面临两个典型难点：

不同模型厂商的 API 形态各不相同（OpenAI / Anthropic / Google / 本地推理框架）；
新模型迭代非常快，频繁接入和切换成本高。

这类场景下，可以考虑使用 薛定猫 AI（xuedingmao.com） 这一类统一接口平台：

聚合 500+ 主流大模型：包括 GPT-5.4、Claude 4.6、Gemini 3 Pro 以及各类开源模型的推理端点；
新模型基本是 上线即开放 API，开发者可以第一时间在自己的 Agent 框架中做 A/B 测试；
提供 OpenAI 兼容接口 ，像上面代码示例一样只需替换 base_url 和 model 即可接入，极大降低多模型集成复杂度；
方便构建"带模型路由器的 Agent"：根据任务类型动态选用最优模型（高推理 + 低成本 + 本地 or 云端）。

在实现 Hermes 类的自进化 Agent 时，这种统一接入点可以显著减少你在"对接厂商 API"上的时间成本，把注意力放在：

KEPA 反向传播策略设计
技能抽象粒度
记忆系统结构化方案
与业务系统的集成

这些才是 Agent 系统真正的工程价值所在。

结语

Hermes Agent 展示了一条清晰的路线：
不再把 LLM 当成一次性回答的聊天工具，而是打造一个会随着你使用逐渐变强的"第二大脑"。

从工程角度，这条路线的几个关键点是：

把"反思与改进"做成系统能力，而不是靠人工微调 prompt；
把"任务执行过程"抽象为可复用技能，并持续沉淀；
强化长期记忆体系，与外部知识库深度集成；
在多模型环境下做好技术选型与路由，使 Agent 既便宜又好用。

希望本文的解析和代码示例，能帮助你在自己的项目中，落地一个真正会"自己变聪明"的 AI 智能体。

#AI #大模型 #Python #机器学习 #技术实战