夜雨聆风
OpenClaw 怎么了?(二)它学会了自我进化
OpenClaw 2026.6.1 最让技术圈兴奋的，不是 Windows 部署，不是安全沙盒，而是一个更根本的能力：Agent 学会了自己“长本事”。
不是“人类写更好的 Prompt”，不是“加更多工具”，不是“换更强的底层模型”。而是 Agent 在运行过程中，遇到失败自己调整策略，遇到不会的任务自己写代码造工具，跑偏了自己纠正回来——全程不需要人类介入。
这是怎么做到的？
答案藏在四个核心机制里：数字基因组、对抗评分、技能突变、双进程自纠偏。它们各自独立工作，又互相协同，共同构成了一套完整的自我进化引擎。
一、数字基因组：把 Prompt 变成可变异的行为树
1.1 从一段话到一棵树
传统 Agent 的“大脑”是一段 Prompt。人类把角色定义、行为规范、工具列表、执行流程全写在一段文字里，Agent 照着执行。想改 Agent 的行为？改 Prompt，重新部署。
OpenClaw 的做法彻底不同。Agent 的决策逻辑被参数化成一棵可序列化的行为树——这就是“数字基因组”。它不再是一段自然语言，而是一个结构化的数据结构，存储为 Protocol Buffers 格式：
protobuf
message BehaviorTree {
string agent_id = 1;
int64 version = 2;
repeated DecisionNode nodes = 3;
map<string, float> global_params = 4;
int64 parent_version = 5; // 追溯进化谱系
}
message DecisionNode {
string node_id = 1;
NodeType type = 2; // SELECTOR, SEQUENCE, CONDITION, ACTION
bool mutable = 3; // 是否允许变异
map<string, float> params = 4; // 可变参数
repeated string children = 5; // 子节点ID
}
这棵树的每个节点代表一个决策点。比如“选择哪个工具”，不是一个模糊的自然语言描述，而是一个带权重的列表：tool_rank: [search:0.6, calc:0.3, code_exec:0.1]。Agent 在运行时把这棵树编译成当前执行策略。当权重变化时，行为就会变化。
关键设计在于 mutable 字段。不是所有节点都能改——哪些能变、哪些锁死，由安全外骨骼预定义。非 mutable 节点在序列化时走只读通道，反序列化时遇到修改直接抛异常并回滚。
1.2 变异：不失败不改，改了必须验证
数字基因组的变异不是随机的。它遵循一个铁律：失败驱动。
触发条件三个门槛同时满足才启动变异：
python
def should_mutate(task_result: TaskResult) -> bool:
return (
task_result.success_rate < 0.6 and # 成功率低于60%
task_result.retry_count > 2 and # 已重试2次以上
not is_in_cooldown(task_result.agent_id) # 不在冷却期
)
满足条件后，系统依次尝试四种变异算子，按优先级排列：
python
class MutationOperator(Enum):
PARAM_PERTURB = 1 # 参数微扰：threshold += N(0, 0.1)
TOOL_REORDER = 2 # 工具优先级交换：把calc排到search前面
STEP_LIMIT_BOOST = 3 # 推理步数上限+5
FALLBACK_SWITCH = 4 # 兜底策略从”重试”改为”委派”
每种算子的改动幅度都很小。参数微扰只加一个均值为零的高斯噪声，工具重排只交换两个相邻工具的优先级。大跨度的跳跃式变异被刻意避免——进化不是赌博，是爬坡。
每个变异生成后，必须在沙盒里回放验证。系统取出任务快照（失败前的完整上下文），让变异后的 Agent 重新执行一遍。成功了才 commit 写入 DNA，失败则换下一个算子。全部算子都失败，标记为 hard case 上报人类。
1.3 Copy-on-Write：多个任务互不污染
生产环境中，同一个 Agent 可能同时处理多个任务。如果任务 A 触发了变异，但这个变异还在沙盒验证中，任务 B 用的 DNA 不能被污染。
解决方案是 Copy-on-Write：
python
class DNACopyOnWrite:
def mutate(self, agent_id: str, operator: MutationOperator) -> str:
# fork出新版本，不和当前版本冲突
new_version = self.version_manager.fork(agent_id)
tree = self.load_tree(new_version)
mutated = apply_mutation(tree, operator)
# 在沙盒里验证fork出的版本
if sandbox_validate(mutated, agent_id):
self.version_manager.commit(new_version)
return new_version
else:
self.version_manager.discard(new_version)
raise MutationRejected
fork 出的新版本有自己的版本号，父版本指向当前稳定版。验证通过则新版本成为当前版本，验证失败则直接丢弃。任务 A 的变异不会影响任务 B，任务 B 继续用原来的稳定版本。DNA 谱系链完整记录每次变异：v1.0 → v1.1 → v1.2，哪次成功哪次失败一目了然。
二、对抗评分：用算力替代人类标注
2.1 变异容易，评判难
变异引擎能生成成百上千个变异体，但怎么判断哪个是“进化”、哪个是“退化”？
传统做法是让人类标注——给每个变异体的输出打分，挑出好的。但这个方法有两个致命缺陷：一是慢，人类标注几百个变异体需要数天；二是贵，持续投入的人力成本远超算力成本。
OpenClaw 的做法是：让 Agent 互相审计。
2.2 互相审计的机制
系统同时生成 N 个变异体，两两配对，放入同一沙盒给完全相同的任务。每个变异体产出的完整推理链，交给对方评判：
python
def adversarial_evaluate(mutant_a: Trace, mutant_b: Trace, task: Task) -> ScorePair:
# 交换推理链，A审B，B审A
review_a_on_b = mutant_a.audit(mutant_b.reasoning_steps, task.ground_truth)
review_b_on_a = mutant_b.audit(mutant_a.reasoning_steps, task.ground_truth)
# 四个维度打分
dimensions = {
“logic_coherence”: 0.3, # 逻辑连贯性：是否存在逻辑跳跃
“step_efficiency”: 0.2, # 步骤冗余度：是否存在无效循环
“correctness”: 0.35, # 结果正确性：最终答案对不对
“tool_appropriateness”: 0.15 # 工具选择合理性
}
score_a = weighted_score(review_b_on_a, dimensions)
score_b = weighted_score(review_a_on_b, dimensions)
return ScorePair(score_a, score_b)
审计不是模糊的“你觉得好不好”，而是逐项检查：每一步推理是否存在逻辑跳跃？有没有明显的计算错误？工具选择是否合理？有没有无效的重复循环？每一项给出 0 到 10 分并附扣分原因。
这个设计的精妙之处在于：评判标准不是人类的偏好，而是逻辑一致性。 一个变异体很难通过“讨好评分模型”来刷分——它必须真正提升推理质量，才能在逻辑连贯性和结果正确性上拿高分。
2.3 ELO 排序：从两两对比到全局排名
N 个变异体两两对抗后，用 ELO 算法做全局排序：
python
def update_elo(winner_elo: float, loser_elo: float,
score_diff: float, generation: int) -> tuple[float, float]:
# K因子随代数衰减：早期大胆探索，后期精调
K = 32 * (0.8 ** (generation / 10))
K = max(K, 8)
expected_win = 1 / (1 + 10 ** ((loser_elo – winner_elo) / 400))
actual_win = 0.5 + 0.5 * min(score_diff / 10.0, 1.0)
delta = K * (actual_win – expected_win)
return winner_elo + delta, loser_elo – delta
K 因子随代数衰减的设计很关键。第一代 K=32，变异体的分数变动大，鼓励大胆探索。到了第十代 K≈8，分数变动小，系统进入精调模式。这样既能快速筛掉明显劣质的变异体，又不会在后期因为随机波动误淘汰优质个体。
Top-K 的变异体获得“基因写入权”——它们的参数差异被合并回主 DNA，成为下一轮进化的基线。
2.4 全异步流水线：从小时级到分钟级
关键工程决策是全异步化。变异生成、沙盒执行、对抗评分三个环节完全解耦，用 Redis Stream 串联：
text
Task Queue → Mutation Worker Pool (生成变异体)
→ Sandbox Pool (并行执行)
→ Pairing Queue (两两配对)
→ Audit Worker Pool (对抗评分)
→ ELO Ranking Service (排序)
→ Gene Writer (写回DNA)
“`
配对策略是瑞士制——首轮随机配对，后续轮次按当前 ELO 排名配对，排名相近的互相比赛。200 个变异体的种群，只需约 8 轮就能收敛到 Top-K。单个任务的完整进化周期从小时级压到了分钟级。
全程不需要人类标注一条数据。算力替代了人力，速度提升了两个数量级。
三、技能突变：不会干就自己发明工具
3.1 缺口检测：怎么知道“我不会”
进化引擎能让 Agent 调整已有工具的使用策略，但当现有工具根本解决不了问题的时候，调整策略是不够的。Agent 需要“长”出新工具。
触发条件是同时满足三个信号：
python
class SkillGapDetector:
def __init__(self, consecutive_fail_threshold=2, confidence_threshold=0.4):
self.threshold = consecutive_fail_threshold
self.confidence = confidence_threshold
def detect(self, action_history: list[Action]) -> GapSignal | None:
recent = action_history[-self.threshold:]
# 条件1：连续两次调用同一工具都失败
same_tool = all(a.tool_name == recent[0].tool_name for a in recent)
all_failed = all(a.status == “error” or a.result_quality < 0.3 for a in recent)
# 条件2：Agent对自己当前方向的信心持续下降
confidence_dropping = (
action_history[-1].self_confidence < self.confidence and
action_history[-1].self_confidence < action_history[-3].self_confidence
)
if same_tool and all_failed and confidence_dropping:
return GapSignal( missing_capability=self._infer_missing(recent),
context=self._gather_context(action_history)
)
return None
三个条件缺一不可。连续失败说明现有工具不够用，信心下降说明 Agent 意识到了这个缺口，不是盲目试错。只有当 Agent “知道自己不知道”的时候，才触发技能突变。
3.2 工具生成：严格约束下的代码创作
检测到缺口后，CodeGen 模块根据当前卡住的上下文生成一个 Python 函数。生成时的 Prompt 不是“写一个有用的工具”，而是一组硬约束：
· 函数签名必须符合 ToolInterface 协议（输入 schema、输出 schema、超时限制）
· 不能执行任何网络请求
· 输入输出必须 JSON 可序列化
· 超时 30 秒内必须返回
· 所有异常必须捕获并返回标准错误格式
生成后的代码要过三道验证：
python
def validate_tool(code: str) -> ValidationResult:
# 1. 静态检查：AST解析，禁止危险导入和动态执行
ast_tree = ast.parse(code)
static_pass = not contains_dangerous_import(ast_tree)
# 扫描 exec/eval/compile/getattr/__import__ 等动态执行函数
# 2. 沙盒测试：用预设的5组输入输出对验证
sandbox_pass = run_in_gvisor(code, test_cases)
# 3. 签名哈希去重：避免生成重复工具
tool_hash = sha256(code.encode()).hexdigest()[:16]
if tool_hash in global_tool_registry:
return ValidationResult(False, reason=“duplicate”)
return ValidationResult(True, hash=tool_hash, code=code)
三道验证——静态检查防危险代码、沙盒测试防逻辑错误、哈希去重防重复造轮子——全部通过后，新工具注入 Agent 的私有技能库。下次遇到同类问题，直接调用。
3.3 水平基因转移：好工具全群共享
一个 Agent 发明的好工具，不应该是私藏的。OpenClaw 实现了“水平基因转移”——Agent 之间可以共享技能：
python
# Agent A发现好工具后发布到共享频道
redis.publish(“skill:publish”, json.dumps({
“source_agent”: “agent_a”,
“tool_hash”: “abc123”,
“skill_tags”: [“math”, “optimization”],
“success_rate”: 0.92
}))
# Agent B订阅同类标签，收到后先在自己最近5个任务上试用
# 验证通过才正式采纳
这个机制的精妙之处在于“试用再采纳”。Agent B 不是盲从 Agent A——它在自己的沙盒里用最近 5 个任务测试新工具，通过了自己的验证标准才纳入技能库。这防止了“坏工具”在群体中扩散。
长期不用的工具会被 LRU 策略自动淘汰。技能库始终保持精干，不会无限膨胀。
四、双进程自纠偏：跑偏了有人拉回来
4.1 “钻牛角尖”是 Agent 的通病
多步推理时，Agent 容易陷入三种典型偏执：逻辑断裂（从 A 跳到 C 跳过了 B）、重复循环（同一个思路反复尝试）、条件遗漏（忽略了某个约束条件）。
传统方案无法解决——人类不可能实时盯着 Agent 的每一步推理。OpenClaw 的做法是双进程架构：
· 执行进程：正常一步步推理并调用工具
· 监察进程：异步运行，每隔 K 步（默认 3 步）对推理链做一次“一致性评分”
两个进程通过共享内存 Ring Buffer 通信，延迟低于 1 毫秒。监察不阻塞执行，只在检测到异常时才介入。
4.2 评分模型：专查跑偏的“小模型”
监察进程使用的评分模型不是通用大模型，而是一个专门微调的约 0.5B 参数小模型。训练数据专门构造：
· 正样本：连续正确推理步骤——每一步都基于前一步的结论，逻辑链条完整
· 负样本：人为插入的逻辑断裂、重复循环、条件遗漏——模拟 Agent 常见的偏执模式
python
def compute_coherence_score(steps: list[Step]) -> float:
if len(steps) < 2:
return 1.0
scores = []
for i in range(len(steps) – 1):
# 相邻两步打分
pair_score = coherence_model.predict(
context=steps[max(0,i-2):i],
step_a=steps[i],
step_b=steps[i+1]
)
scores.append(pair_score)
# 近期步骤加权更重（指数衰减权重）
weights = [0.5 ** (len(scores) – i) for i in range(len(scores))]
weights = [w / sum(weights) for w in weights]
return sum(s * w for s, w in zip(scores, weights))
近期步骤加权更重的设计，是因为 Agent 越到推理后期越容易跑偏——前期有清晰的任务目标引导，后期目标分解得细碎了，逻辑越容易断裂。
4.3 回溯：不是全部重来，是精准回滚
当一致性评分低于阈值，监察进程注入回溯信号，携带“可疑步骤索引”。执行进程的回溯不是全部推倒重来，而是精准回滚：
python
def backtrack(executor_state: ExecutorState, suspicious_step_index: int):
# 1. 回滚工作内存到快照点——只丢失可疑步之后的推理
executor_state.working_memory = executor_state.snapshots[suspicious_step_index]
# 2. 标记该步为“已尝试路径”——避免重走死胡同 executor_state.tried_branches[suspicious_step_index].append( executor_state.reasoning_branch[suspicious_step_index]
)
# 3. 注入偏执提示——告知Agent之前在这步卡住的原因
executor_state.inject_hint(
f”之前的推理路径在第{suspicious_step_index}步可能偏离，请尝试不同的方法。”
f”已尝试过的方法：{executor_state.tried_branches[suspicious_step_index]}“
)
# 4. 提高探索温度——鼓励换个思路
executor_state.temperature *= 1.5
同一个节点回溯超过 3 次，触发更高级别干预——降低整个任务的目标复杂度（允许分步求解），或降级为人工接管。
五、四个机制如何协同
这四个机制不是孤立运行的，它们构成了一套完整的自我进化闭环：
数字基因组是基础设施——它让 Agent 的决策逻辑变成了可读、可写、可版本管理的数据结构。没有它，变异就没有载体。
对抗评分是选拔机制——它解决了“怎么判断变异好坏”的问题，用算力替代了人力。没有它，变异引擎生成的变异体就是一堆没有排序的候选。
技能突变是能力扩展机制——它突破了“只能调整已有工具的使用策略”的限制，让 Agent 能创造新工具。没有它，Agent 的能力上限就是初始工具集。
双进程自纠偏是安全网——它在 Agent 推理过程中实时监控，防止跑偏。没有它，前三个机制再强，Agent 也可能在推理偏差中把好策略执行歪。
四者的协同关系可以这样理解：数字基因组存储“怎么想”，对抗评分判断“想得好不好”，技能突变扩展“能想什么”，自纠偏确保“别想歪了”。合在一起，就是 Agent 的自我进化能力。
六、一个真实的进化案例
某制造企业的排产 Agent 上线时只有一个基础工具：查询 ERP 产线排期表。任务是每天凌晨根据订单和产能生成次日排产计划。
第一周，Agent 的排产计划被人工修正了 30%。变异引擎捕捉到低成功率，触发参数微扰——它把“同类订单合并”的优先级从 0.5 调到了 0.7。修正率降到 22%。
第二周，又发现一个问题：急单插队时，Agent 不会考虑插队对后续订单的连锁影响。对抗评分系统中，一个变异体尝试把“急单优先”的权重从 0.8 降到 0.5，改为“急单评估——先判断是否真的必须插队，再决定优先级”。这个变异体的 ELO 排名第一，写入主 DNA。修正率降到 15%。
第三周，Agent 遇到了真正的能力缺口——有一批订单要求同一天交货，但产线产能不够。Agent 连续两次尝试调整排产顺序都失败，自信心持续下降。技能突变触发，CodeGen 生成了一个“外协产能查询”工具——自动查询合作厂商的可用产能，把溢出的订单分派出去。这个工具在沙盒里用历史数据验证通过后上线。修正率降到 5%。
三个月后，这个排产 Agent 的人工修正率稳定在 3% 以下。它进化出了 7 个新工具，其中 3 个通过水平基因转移被同集团另外两家工厂的排产 Agent 采纳。
整个过程，人类没有改过一次 Prompt，没有手动加过一个工具。Agent 自己完成了策略调整、工具发明和跨厂共享。
七、不是什么魔法，是扎实的工程
OpenClaw 的自我进化，本质上是一套受约束的自动参数搜索 + 对抗筛选 + 安全回滚系统。它没有改变模型权重，没有触及底层大模型的训练过程。它改变的是 Agent 如何使用模型——如何选择工具、如何组织推理步骤、如何应对失败。
这恰恰是它最务实的地方。不去赌模型能力的飞跃，而是把现有模型的能力榨干——通过工程化手段让 Agent 在实战中持续逼近当前模型的能力上限。
下一篇，将拆解另一个关键问题：OpenClaw 的三层安全外骨骼，怎么做到让 AI 又能写代码又绝对安全？
