AI Agent 的"记忆进化"：Skills 自进化框架如何让 Agent 越用越聪明？

引言

你有没有想过，一个 AI Agent 在帮你完成任务之后，能不能把"这次是怎么成功的"自动总结成一个可复用的技能，下次遇到类似问题时直接调用，而不是重头再想一遍？

这不是科幻。过去这个周末（5月30日至6月1日），arXiv 上密集涌现出一批关于 Skills 自进化（Self-Evolving Skills） 的论文，包括 SkillGrad、CODESKILL、SkillOS、Harness Evolution 等，其中微软相关团队的工作在一周内斩获 3.3k star。

这一批论文共同指向同一个问题：如何让 AI Agent 像人一样，从经验中积累可复用技能，并持续优化它们？

本文聚焦于这个核心技术方向，拆解其原理、架构和代码实现思路。

---

问题背景：为什么现在的 Agent 每次都像"新手上路"？

当前主流的 AI Agent（无论是基于 ReAct、Plan-and-Execute 还是 Function Calling 架构）存在一个共同的痛点：

每次执行任务，都是从零开始推理。

即使 Agent 上周刚解决过一个"爬取网页数据并清洗成 CSV"的任务，这周遇到类似任务，它仍然会重新经历"理解需求→规划步骤→调用工具→纠错→输出"的完整流程。之前的成功经验没有被结构化地保存下来。

这本质上是 "情节记忆（Episodic Memory）" 和 "程序性技能（Procedural Skill）" 之间的鸿沟：

• 情节记忆：我记得上次做过这件事
• 程序性技能：我知道"如何"做这件事，且可以泛化到新情境

人类在重复性任务中会自然形成"肌肉记忆"，而当前 Agent 缺乏这种能力，导致：

1. 效率低下：每次重复推理，Token 消耗大
2. 可靠性差：相同类型任务可能因随机性产生不同质量输出
3. 无法累积：多次运行之间没有知识传承

---

技术原理：Skills 自进化的核心架构

核心概念：什么是 Skill？

在这一批研究中，Skill（技能） 被统一定义为：

一段可执行的、参数化的代码函数或提示模板，能够在特定类型任务上复用，并附带元信息（适用场景描述、前置条件、期望输出格式）。

与传统的 RAG 检索不同，Skill 不是"检索文档片段"，而是"检索可执行逻辑"。

完整的自进化循环

Skills 自进化的核心是一个四阶段闭环：

┌─────────────────────────────────────────────────────────┐
│                   Skills 自进化循环                       │
│                                                         │
│   1. 执行  →   2. 提炼   →   3. 存储   →   4. 检索     │
│   (Execute)   (Distill)   (Store)      (Retrieve)      │
│      ↑                                      │           │
│      └──────── 新任务到来 ←─────────────────┘           │
│                                                         │
│   + 5. 进化 (Evolve)：定期对库中技能做质量评估与合并     │
└─────────────────────────────────────────────────────────┘

阶段 1：执行（Execute）

Agent 尝试完成任务，记录完整的执行轨迹（Trajectory），包括每一步的工具调用、中间结果和最终输出。

阶段 2：提炼（Distill）

成功的轨迹被 LLM 分析，提取其中的可复用逻辑，生成结构化的 Skill 描述：

{
  "skill_name": "web_scrape_to_csv",
  "description": "爬取指定URL的表格数据并清洗为CSV格式",
  "trigger_condition": "用户提到'爬取'+'保存为CSV'或'数据抓取'",
  "implementation": """
def skill_web_scrape_to_csv(url: str, output_path: str) -> str:
    import requests
    from bs4 import BeautifulSoup
    import pandas as pd
    response = requests.get(url, timeout=10)
    soup = BeautifulSoup(response.text, 'html.parser')
    tables = pd.read_html(str(soup.find('table')))
    tables[0].to_csv(output_path, index=False)
    return f"已保存至 {output_path}"
  """,
  "success_count": 1,
  "quality_score": 0.85
}

阶段 3：存储（Store）

技能以向量化的方式存入 Skill Repository（技能库），同时保留原始代码和元信息，支持语义检索。

阶段 4：检索（Retrieve）

面对新任务，Agent 先对任务描述做语义编码，从技能库中检索 Top-K 相关技能，直接注入上下文或作为执行候选。

阶段 5：进化（Evolve）

定期对技能库进行维护：合并功能相似的技能、淘汰低成功率技能、对高频技能做进一步泛化（即"元技能"抽象）。

SkillGrad 的创新：像梯度下降一样优化技能

本周最受关注的论文之一 SkillGrad（arXiv:2605.27760）提出了一个精妙的类比：把技能包看作模型参数，用类似梯度下降的机制来更新它们。

其核心思路：

• "动量积累"：用多次失败案例积累"诊断信号"，类似梯度的累积
• "参数更新"：用 LLM 根据积累的诊断信号生成技能补丁（Patch）
• "学习率衰减"：随着技能稳定性提升，更新幅度逐渐降低

这使得技能优化有了明确的方向性，而非随机突变。

---

代码示例：最简版 Skills 自进化 Agent

下面是一个简化的 Python 实现，展示 Skills 自进化的核心机制：

import json
import hashlib
from openai import OpenAI
from typing import Optional

client = OpenAI()

# ==================== Skill Repository ====================

class SkillRepository:
    """技能库：存储和检索可复用技能"""
    
    def __init__(self):
        self.skills: dict[str, dict] = {}
    
    def add_skill(self, skill: dict) -> str:
        """将新技能加入库"""
        skill_id = hashlib.md5(skill["skill_name"].encode()).hexdigest()[:8]
        if skill_id not in self.skills:
            self.skills[skill_id] = skill
            self.skills[skill_id]["success_count"] = 1
        else:
            self.skills[skill_id]["success_count"] += 1
        return skill_id
    
    def retrieve(self, task_description: str, top_k: int = 3) -> list[dict]:
        """简化版检索：基于关键词匹配（实际应用需向量检索）"""
        task_words = set(task_description.lower().split())
        scored = []
        for skill in self.skills.values():
            desc_words = set(skill["description"].lower().split())
            overlap = len(task_words & desc_words)
            scored.append((overlap, skill))
        scored.sort(key=lambda x: -x[0])
        return [s for _, s in scored[:top_k]]
    
    def evolve(self):
        """进化：淘汰低质量技能"""
        self.skills = {
            k: v for k, v in self.skills.items()
            if v.get("success_count", 0) >= 2  # 至少成功2次才保留
        }

# ==================== Skill Distiller ====================

def distill_skill_from_trajectory(task: str, trajectory: str) -> Optional[dict]:
    """从成功轨迹中提炼技能"""
    prompt = f"""
你是一个技能提炼专家。根据以下成功的任务执行轨迹，提炼出一个可复用的技能。

任务描述：{task}
执行轨迹：{trajectory}

请以JSON格式输出技能，包含字段：
- skill_name: 技能名称（英文下划线）
- description: 技能适用场景（中文，20字以内）
- trigger_keywords: 触发关键词列表
- pseudocode: 伪代码描述（5步以内）

只输出JSON，不要有其他内容。
"""
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"}
    )
    try:
        return json.loads(response.choices[0].message.content)
    except Exception:
        return None

# ==================== Self-Evolving Agent ====================

class SelfEvolvingAgent:
    """具备技能自进化能力的 Agent"""
    
    def __init__(self):
        self.repo = SkillRepository()
        self.task_history: list[dict] = []
    
    def run(self, task: str) -> str:
        # Step 1: 检索相关技能
        relevant_skills = self.repo.retrieve(task)
        skill_context = ""
        if relevant_skills:
            skill_context = "【可用技能库】\n" + "\n".join(
                f"- {s['skill_name']}: {s['description']}" 
                for s in relevant_skills
            )
        
        # Step 2: 执行任务（带技能提示）
        prompt = f"{skill_context}\n\n请完成以下任务：{task}\n\n详细描述你的执行过程。"
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}]
        )
        result = response.choices[0].message.content
        trajectory = result  # 实际应记录完整工具调用链
        
        # Step 3: 提炼技能并入库
        skill = distill_skill_from_trajectory(task, trajectory)
        if skill:
            skill_id = self.repo.add_skill(skill)
            print(f"[技能入库] {skill['skill_name']} (id={skill_id})")
        
        # Step 4: 记录历史
        self.task_history.append({"task": task, "result": result})
        
        # Step 5: 定期进化（每5次任务触发一次）
        if len(self.task_history) % 5 == 0:
            before = len(self.repo.skills)
            self.repo.evolve()
            after = len(self.repo.skills)
            print(f"[技能进化] 库容量: {before} → {after}")
        
        return result

# ==================== 使用示例 ====================

if __name__ == "__main__":
    agent = SelfEvolvingAgent()
    
    # 第一次执行：没有历史技能
    print("=== 任务1 ===")
    agent.run("帮我爬取 https://example.com 的标题并输出")
    print(f"当前技能库: {len(agent.repo.skills)} 个技能\n")
    
    # 第二次执行：同类任务，会检索到上次提炼的技能
    print("=== 任务2 ===")
    agent.run("抓取 https://news.example.com 页面的所有文章标题")
    print(f"当前技能库: {len(agent.repo.skills)} 个技能")

运行结果示意：

=== 任务1 ===
[技能入库] web_title_extract (id=a3f8d2c1)
当前技能库: 1 个技能

=== 任务2 ===
[技能入库] web_scrape_titles (id=b7e1f0a2)
当前技能库: 2 个技能

关键点：第二次任务时，Agent 收到的 prompt 中已包含"web_title_extract"技能的描述，它可以直接参考甚至复用，而不是重新推导网页爬取逻辑。随着任务增多，技能库不断丰富，Agent 的表现会持续提升。

---

个人观点

Skills 自进化方向让我想到《三体》中的"黑暗森林"思想实验：每个文明（Agent）在宇宙中独立演化，最终在信息隔绝的条件下会产生完全不同的知识结构。

但 Skills 自进化打破了这个隔离------技能库可以跨任务、跨 Agent 共享。这意味着：

1. 个体 Agent 的经验，可以成为群体的资产。 SkillForge 已经在企业云技术支持场景中验证：从历史工单中自动合成的技能，性能超越了人工专家手写的规则库。

2. 这是比 RAG 更深的知识组织形式。 RAG 检索的是"知道什么"，Skill 传递的是"知道怎么做"。前者是陈述性知识，后者是程序性知识，更接近人类的专业能力本质。

3. 遗忘问题（Catastrophic Forgetting）是真实存在的挑战。 CPE 论文（arXiv:2605.09315）发现，盲目进化会导致旧技能性能退化。这和人类学习新技能有时会干扰旧技能的现象一模一样。解决这个问题，或许需要借鉴神经科学中"互补学习系统"的思路。

4. 短期内最大的工程价值在"企业私有技能库"。 企业内部有大量重复性高价值任务（数据处理、报告生成、系统运维），让 Agent 在执行中自动积累领域技能，是一条比 Fine-tuning 更轻量、更可解释的路径。

目前这个方向还存在明显不足：Skill 的质量强依赖 LLM 的提炼能力，低质技能入库会形成"知识污染"；技能冲突（两个技能对同类任务有不同处理逻辑）的解决机制也还不成熟。但这些都是工程可以解决的问题，方向本身是对的。

---

总结

Skills 自进化框架的核心价值，是让 AI Agent 从"每次从头推理"升级为"持续积累可复用经验"，弥合了情节记忆和程序性技能之间的鸿沟。

这一周密集发布的 SkillGrad、CODESKILL、SkillOS 等论文，从不同角度（梯度类比优化、RL 训练、技能策展学习）探索了这个问题的解法。无论哪种路径，最终指向的都是同一个目标：Agent 的智能，应该随着使用而增长，而不是每次归零。

如果你在做 AI Agent 相关的产品或研究，Skills 自进化是值得现在就关注和动手实验的技术方向。