Metan分层自改进智能体：大模型自我进化的工程实践

最近在学习大模型 Agent 相关内容时，关注到一项很有意思的研究：来自明尼苏达大学与首尔大学联合团队提出的Metan 分层自改进智能体。它把“让 AI 自己优化自己”这件事拆成了清晰的层级结构，思路非常适合落地到实际项目中。本文会围绕 Metan 的核心思想展开，先用通俗方式讲清楚“分层”和“自改进”分别解决什么问题，再给出一个简化版 Python 实现框架，方便你理解它的工作流程，并顺便聊聊工程化落地时的坑和最佳实践。

1. 背景与核心概念：Metan 是什么

1.1 从“智能体”到“自改进智能体”

在大模型应用开发中，“智能体（Agent）”已经不是一个新词了。最简单理解：一个智能体就是让大模型结合工具、记忆、规划能力，去完成某个任务。比如让模型调用天气 API、操作数据库、写一份周报，这些都可以视为智能体应用。

但早期智能体普遍存在一个尴尬问题：提示词写死了，策略写死了，遇到没见过的任务就抓瞎。开发者只好不断地手动修提示词、调参数、加规则，维护成本极高。

Metan 这类“自改进智能体”想解决的问题就是：能不能让智能体自己发现自身不足，自己总结经验，自己调整策略，从而在下一次任务中表现更好？

它不是简单地用一个大模型去完成任务，而是在智能体之上再加一层“监控与反思”机制，让系统具备自我进化的能力。

1.2 Metan 的分层结构

Metan 最核心的关键词是“分层”（Layered）。它把智能体的能力拆成多个独立层，每层只关心一件事。常见的设计思路可以概括为：

• 感知层：接收任务，理解用户意图，收集上下文信息。
• 决策层：根据任务目标，制定执行计划，选择下一步动作。
• 执行层：调用具体工具、编写代码、查询数据，真正完成动作。
• 反思层：评估执行结果，对比预期，找出不足。
• 记忆层：存储每次任务的经验，形成可复用的“策略库”。

这种分层结构的好处在于：每一层都可以独立优化，不会因为改了一处行为导致整个系统崩盘。

1.3 “自改进”的闭环含义

Metan 的“自改进”不是指模型权重在推理时自动更新，而是指策略层面的迭代。具体来说，系统会把每次执行后的反思结论存入记忆层，下一次遇到类似任务时，决策层会基于之前积累的经验来调整计划。

这有点像人类的“复盘”：做完一件事，想一想哪里做得好、哪里做得不好，下次改进。Metan 就是把这种复盘的流程工程化。

2. 为什么需要分层，又为什么需要自改进

2.1 单体提示词方案的痛点

很多人刚开始做 Agent 时，习惯把“系统提示词 + 用户问题 + 工具描述”全部塞进一个大 Prompt 里，希望模型一步到位。这样做有几个问题：

• 提示词过长：超过模型上下文窗口后，关键信息容易被忽略。
• 职责耦合：规划、执行、反思混在一起，模型难以明确自己在哪个阶段。
• 难以迭代：想优化某一步行为，却没法精准定位到具体 Prompt 片段。
• 无法积累经验：每次执行都是“从零开始”，没有历史经验可以参考。

Metan 的分层思路，本质上是对这些痛点做了一次结构化拆解。

2.2 分层架构为什么更稳定

分层之后，每一层都可以看作一个独立模块。例如反思层只负责“评估结果并给出建议”，它不需要关心工具调用细节；执行层只负责“把动作做出来”，不需要关心整体战术。

这种做法的实际收益是：

• 可维护性高：哪一层出了问题，直接修哪一层。
• 可测试性高：每一层都能单独评估效果。
• 可扩展性强：新增工具、新增记忆存储方式，都不需要重写整条链路。

2.3 自改进机制解决“冷启动”问题

没有自改进的智能体，相当于一个“静态程序”。它必须依赖开发者预先把所有规则写全，但真实业务场景中，很难提前枚举所有情况。

自改进机制让智能体在运行中不断生成新的“策略经验”。冷启动时可以靠一套通用 Prompt，跑一段时间后，系统里沉淀了大量针对具体业务场景的成功经验，后续任务就能更精准。

3. 核心机制拆解：Metan 的分层自改进框架

3.1 整体流程

下面用一个简化流程来描述 Metan 的工作方式：

1. 用户提交任务。
2. 感知层解析任务，补充上下文。
3. 决策层结合记忆层中的历史经验，生成执行计划。
4. 执行层逐个执行计划步骤。
5. 反思层对结果打分、分析偏差、生成改进建议。
6. 记忆层保存本轮经验，更新策略版本。
7. 如果结果不达标，系统可以基于反思建议重新制定计划，进入下一轮迭代。

这是一个典型的“执行-反思-改进”闭环。

3.2 每一层的关键职责

感知层

感知层负责回答“用户到底需要什么”。它要做的是：

• 去除无关信息。
• 提取任务目标。
• 判断任务类型。
• 识别必要的约束条件。

决策层

决策层负责回答“用什么策略完成任务”。它会：

• 读取记忆层中的历史经验。
• 将任务分解成可执行的子步骤。
• 决定是否调用工具、调用什么工具。
• 设置预期验收标准。

执行层

执行层是“手和脚”。它会：

• 调用 API。
• 执行代码。
• 操作数据库。
• 获取实时数据。
• 生成最终输出。

反思层

反思层是“教练”。它负责：

• 检查结果是否达到预期。
• 对执行过程进行复盘。
• 定位失败原因。
• 生成下一步改进建议。

记忆层

记忆层是“经验库”。它负责：

• 保存任务类型、执行策略、结果评分。
• 供决策层在下次任务中检索复用。
• 定期清理无效经验，防止“坏经验”污染系统。

3.3 自我改进的触发条件

系统并不是每次都盲目改策略。常见的触发条件包括：

• 反思层评分低于阈值。
• 连续多次任务失败。
• 用户对结果给出负面反馈。
• 任务类型发生变化，旧策略不再适用。

只有满足条件时，系统才把反思建议写入记忆库并更新策略版本。这样能避免“频繁修改导致系统震荡”。

4. 简化版 Metan 框架实现

这一节我们基于 Metan 的设计思想，用 Python 实现一个简化版框架。你不需要它真正调用大模型，只要理解结构即可。我会把每一层写成一个独立模块，方便你对照上文的原理来看。

4.1 项目结构

建议你新建如下目录结构：

metan_mini/ ├── main.py ├── agent.py ├── layers/ │ ├── __init__.py │ ├── perception.py │ ├── decision.py │ ├── execution.py │ ├── reflection.py │ └── memory.py

如果你只是在学习阶段，也可以把所有代码先写在一个 Python 文件里。这里为了体现“分层”，我们按目录组织。

4.2 感知层实现

# 文件路径：metan_mini/layers/perception.py class PerceptionLayer: """ 感知层：负责解析任务，提取目标、约束和任务类型。 真实项目中，这里可以接入大模型做意图识别。 """ def __init__(self): # 简单的任务类型规则 self.task_keywords = { "query": ["查", "找", "问", "query", "search"], "write": ["写", "生成", "create", "write", "draft"], "analyze": ["分析", "统计", "对比", "analyze", "compare"], } def perceive(self, task: str) -> dict: """ 输入原始任务字符串，输出结构化任务描述。 """ task_type = "general" for ttype, keywords in self.task_keywords.items(): if any(kw in task.lower() for kw in keywords): task_type = ttype break return { "raw_task": task, "task_type": task_type, "goal": task.strip(), "constraints": [], }

在这个示例里，我们通过关键词给任务做了一次粗糙分类。真实项目中，感知层可以换成大模型调用，用结构化输出格式来提取任务要素。

4.3 记忆层实现

# 文件路径：metan_mini/layers/memory.py class MemoryLayer: """ 记忆层：存储历史任务的经验记录。 这里用列表存储，生产环境建议使用向量数据库。 """ def __init__(self): self.experiences = [] self.strategy_version = 1 def save_experience(self, experience: dict): """保存一条经验记录""" self.experiences.append(experience) print(f"[Memory] 已保存经验，当前经验数: {len(self.experiences)}") def recall(self, task_type: str) -> list: """ 召回与当前任务类型匹配的经验。 这里简单按 task_type 过滤，生产环境可以用向量检索。 """ related = [exp for exp in self.experiences if exp.get("task_type") == task_type] print(f"[Memory] 召回 {len(related)} 条相关经验") return related def update_strategy(self, suggestion: str): """更新策略版本，记录改进建议""" self.strategy_version += 1 print(f"[Memory] 策略版本升级为 v{self.strategy_version}") print(f"[Memory] 改进建议: {suggestion}")

记忆层在设计时需要关注两个点：写入和召回。决定一条经验是否值得写入，取决于反思层的评分；召回时需要考虑如何过滤掉低质量经验，避免对决策产生干扰。

4.4 决策层实现

# 文件路径：metan_mini/layers/decision.py class DecisionLayer: """ 决策层：基于任务信息与历史经验，生成执行计划。 """ def __init__(self): # 注册可以执行的工具 self.available_tools = ["search", "write_text", "calculate"] def decide(self, perception: dict, memories: list) -> dict: task_type = perception["task_type"] plan = [] if task_type == "query": plan = ["search", "summarize"] elif task_type == "write": plan = ["search", "write_text", "summarize"] elif task_type == "analyze": plan = ["search", "calculate", "summarize"] else: plan = ["search", "summarize"] # 如果历史经验中有更优策略，可以在这里覆盖默认计划 if memories: # 取最近一条成功经验 latest = memories[-1] if latest.get("score", 0) > 0.8 and latest.get("plan"): plan = latest["plan"] print("[Decision] 使用历史经验中的优化计划") return { "plan": plan, "expected_metrics": ["accuracy", "completeness"], }

决策层是把任务目标转换成“行动清单”的地方。在简化版本里，我们使用 if-else 来决定计划；在真实实现中，这里往往是大模型基于记忆内容进行推理和规划。

4.5 执行层实现

# 文件路径：metan_mini/layers/execution.py class ExecutionLayer: """ 执行层：模拟执行计划中的每个步骤。 """ def __init__(self): self.execution_log = [] def execute(self, plan: list, context: dict) -> dict: results = [] for step in plan: # 模拟执行不同步骤 if step == "search": result = "模拟搜索结果：找到了 3 条相关资料" elif step == "write_text": result = "模拟输出：生成一段文本内容" elif step == "calculate": result = "模拟计算：得到统计结果 42" elif step == "summarize": result = "模拟总结：已完成信息汇总" else: result = f"执行未知步骤: {step}" self.execution_log.append(step) results.append({ "step": step, "result": result, "status": "success", }) return { "output": results[-1]["result"] if results else "无输出", "steps": results, }

执行层是最容易扩展的部分。你可以在真实项目中把search替换为真实的搜索引擎 API，把calculate替换为调用数学库或外部计算服务。关键在于保持执行层不关心“为什么这么做”，只关心“怎么做”。

4.6 反思层实现

# 文件路径：metan_mini/layers/reflection.py class ReflectionLayer: """ 反思层：对执行结果进行评价，生成改进建议。 """ def __init__(self, threshold=0.7): self.threshold = threshold def reflect(self, result: dict, task_type: str) -> dict: # 模拟评估过程：这里可以根据真实结果做更复杂的评分 output = result.get("output", "") score = 1.0 if output and len(output) > 5 else 0.5 suggestion = None if score < self.threshold: suggestion = "建议增加一次搜索步骤，以获取更全面的上下文信息。" print(f"[Reflection] 任务评分: {score:.2f}") if suggestion: print(f"[Reflection] 反思建议: {suggestion}") return { "score": score, "is_pass": score >= self.threshold, "suggestion": suggestion, }

反思层的评分规则在真实项目中应该更严谨。比如：

• 用大模型对输出质量打分。
• 用用户点击率、采纳率等业务指标评估。
• 用自动化测试用例验证输出正确性。

这里用字符串长度做模拟评分，只是为了让你理解代码结构。

4.7 Agent 主类整合

# 文件路径：metan_mini/agent.py from layers.perception import PerceptionLayer from layers.decision import DecisionLayer from layers.execution import ExecutionLayer from layers.reflection import ReflectionLayer from layers.memory import MemoryLayer class MetaAgent: """ Metan 简化版：分层自改进智能体。 """ def __init__(self, max_iterations=3): self.perception = PerceptionLayer() self.decision = DecisionLayer() self.execution = ExecutionLayer() self.reflection = ReflectionLayer() self.memory = MemoryLayer() self.max_iterations = max_iterations def run(self, task: str) -> dict: # 第一步：感知任务 perception_result = self.perception.perceive(task) task_type = perception_result["task_type"] # 第二步：召回历史经验 memories = self.memory.recall(task_type) # 第三步：重复执行-反思循环 iteration = 1 final_result = None while iteration <= self.max_iterations: print(f"\n===== 第 {iteration} 轮迭代 =====") # 决策 decision = self.decision.decide(perception_result, memories) # 执行 execution_result = self.execution.execute(decision["plan"], perception_result) # 反思 reflection_result = self.reflection.reflect(execution_result, task_type) # 保存经验 self.memory.save_experience({ "task_type": task_type, "task": task, "plan": decision["plan"], "score": reflection_result["score"], "suggestion": reflection_result["suggestion"], }) # 如果反思有改进建议，把建议更新到记忆库 if reflection_result["suggestion"]: self.memory.update_strategy(reflection_result["suggestion"]) final_result = { "task": task, "output": execution_result["output"], "score": reflection_result["score"], "iterations": iteration, } if reflection_result["is_pass"]: print("[Agent] 本轮结果已达标，停止迭代。") break # 未达标：继续下一轮，模拟调整策略 print("[Agent] 结果未达标，进入下一轮迭代优化。") iteration += 1 return final_result

4.8 运行入口

# 文件路径：metan_mini/main.py from agent import MetaAgent if __name__ == "__main__": agent = MetaAgent(max_iterations=3) tasks = [ "查询本周的销售数据", "写一篇关于 AI Agent 的短文", "分析最近三个月的用户增长趋势", ] for task in tasks: print("\n==================== 新任务 ====================") print(f"任务: {task}") result = agent.run(task) print(f"最终输出: {result['output']}") print(f"任务评分: {result['score']}")

运行方式：

cd metan_mini python main.py

预期输出会展示每个任务经过若干轮迭代，感知、决策、执行、反思、记忆各层依次参与工作。你可以看到记忆层在第二个任务后已经积累了经验，决策层开始尝试使用历史优化计划。

5. 运行验证与结果分析

5.1 输出示例

上面代码运行后，你会看到类似下面的关键输出：

[Memory] 召回 0 条相关经验 [Memory] 已保存经验，当前经验数: 1 [Reflection] 任务评分: 1.00 [Agent] 本轮结果已达标，停止迭代。

当同一个任务类型第二次出现时：

[Memory] 召回 1 条相关经验 [Decision] 使用历史经验中的优化计划 [Memory] 已保存经验，当前经验数: 2

这说明自改进机制已经生效：决策层不再完全依赖默认规则，而是会参考历史经验。

5.2 如何验证自改进是否真的有效

在实际项目中，你需要一套更严谨的验证方案：

• 准备一组测试任务，记录初始准确率。
• 运行一定数量的任务，让系统积累经验。
• 再次跑同一组测试任务，对比准确率变化。
• 检查经验库中的策略是否被正确应用到新任务上。

如果改进后准确率没有提升，问题可能出在反思层的建议质量不高，或者记忆层的召回策略不准确。

5.3 把记忆接入向量数据库

上面的示例用列表存储经验，一旦任务量变多，检索效率会急剧下降。生产环境推荐使用向量数据库。基本思路是：

1. 把每次任务的经验文本用 Embedding 模型编码成向量。
2. 新任务到来时，对任务描述做同样的向量编码。
3. 在向量数据库中执行相似度检索，召回最相关的历史经验。

常见的可选方案包括 Chroma、Milvus、pgvector 等。选择时主要看团队技术栈和数据量。

6. 常见问题与排查思路

6.1 自改进导致性能反而下降

6.2 分层系统延迟过高

每增加一层调用，都会增加一次外部 LLM 接口调用，总延迟会成倍上升。对于在线服务，这是不可接受的。常用优化方式：

• 并行化：不互相依赖的层可以并行处理。
• 轻量模型：感知层和反思层使用小参数模型，决策和执行层使用强模型。
• 结果缓存：相同任务类型、相同输入时直接复用缓存结果。

6.3 系统死循环

如果反思层一直给出“继续优化”的建议，系统会陷入无限迭代。除了设置max_iterations上限之外，还应该监控每一轮评分变化。如果连续两轮评分没有提升，应当强制停止。

6.4 日志与可观测性

自改进智能体比普通程序更难调试，因为它会“自己变”。建议在每个关键节点都打日志：

• 感知层产出的结构化任务信息。
• 决策层选择策略的原因。
• 反思层的评分依据。
• 记忆层写入和召回的具体内容。

这样即使生产环境出了问题，也能通过日志还原系统当时的决策过程。

7. 工程落地最佳实践

7.1 分层接口要保持稳定

分层架构最大的优势是“独立演进”，但这要求层与层之间的接口足够稳定。例如感知层输出的字典结构，最好不要频繁改变字段。如果一定要改，最好先做一层适配转换，避免上游决策层、记忆层全部跟着改。

7.2 自改进必须有回滚机制

策略更新不是只能向前，不能后退。建议在记忆层中为每个策略版本编号，并记录版本对应的效果评分。一旦新版策略效果变差，可以一键回滚到上一版本。

回滚机制是自改进系统的安全底线。没有回滚，改进就伴随着不可控的退化风险。

7.3 用离线验证替代在线试错

不要在生产环境直接开启自动改进。更稳妥的做法是：

1. 在离线环境用历史数据回放新策略。
2. 验证新策略在历史数据集上的效果。
3. 确认没有明显退化后，再灰度上线。

对智能体来说，“灰度发布”同样适用：可以先让 10% 的流量使用新策略，观察一段时间再全量放开。

7.4 明确自改进的边界

自改进不是让 AI 随意改系统代码。建议把“改进范围”限定在策略层、提示词层、工具选择层，不要让系统自动修改核心业务逻辑或权限配置。对于涉及资金、安全、用户隐私的操作，必须经过人工审批。

7.5 控制上下文长度

在真实实现中，决策层需要把召回的历史经验拼接到 Prompt 中。如果召回经验太多，会占用大量上下文窗口。可以设置召回数量上限，并按相关度排序取 Top-K。比如默认只拼接最近 3 条高效经验。

8. 总结与后续学习建议

Metan 的核心价值在于把“智能体自我改进”这件听起来很玄的事情工程化。它不是靠一条魔法提示词实现的，而是通过感知、决策、执行、反思、记忆五层结构的协同配合，让系统能持续沉淀经验、优化策略。

如果你想把这一套真正落地，建议按下面的路线学习：

1. 先跑通本文的简化版框架，理解各层职责。
2. 把感知层和反思层替换成真实的大模型调用。
3. 接入真实工具，比如搜索 API、数据库查询、代码执行器。
4. 把记忆层从列表改造成向量数据库。
5. 设计离线验证集，构建策略评估体系。
6. 在保障回滚机制的前提下，逐步尝试策略自动更新。

实际项目中，自改进智能体最值得关注的风险是“失控”。一定要在设置阈值、回滚机制、日志可观测性上多花功夫，让系统既聪明又可控。

如果你也对这一类技术方向感兴趣，建议多关注智能体架构设计中的“评估-反思”闭环，它几乎是所有自改进系统的核心底座。把本文的 Python 代码复制到本地跑一遍，会有更直观的感受。后续我也会继续整理更多关于智能体工程化落地的内容，欢迎收藏备用。