Meta-Evolution Genesis Agent (MEGA)——A Spec-Driven Framework for Bootstrapping Cross-Domain Self-Evolving Agents

发表于2026-07-21|更新于2026-07-27|Agent

|浏览量:

Meta-Evolution Genesis Agent (MEGA)

Meta-Evolution Genesis Agent (MEGA) · 昵称元神
A Spec-Driven Framework for Bootstrapping Cross-Domain Self-Evolving Agents

研究构想文档（research idea / position paper draft）。作者：lvzhongrenjie　日期：2026-07-21
关联：自进化智能体研究综述（~/Documents/实习/）、alcor-chaos 排障自进化 agent（已有，作为已验证的一个领域实例）
系统名 MEGA = Meta-Evolution Genesis Agent；Meta-Evolution 命名二阶贡献（进化进化器），Genesis 命名 bootstrap，Agent = M 本身。

0. 一句话

MEGA（元神）是一个 spec-driven 的跨域 meta 进化层：本身是一个 meta-evolver（跑在 Claude Code/Codex 等任意 harness 里），给定领域 spec，自动 bootstrap 出该域的自进化 agent——产出落在宿主原生配置形态（CLAUDE.md/AGENTS.md+skills / delta / code；含 prompt / env / 记忆 / 工具 / eval / evolver 闭环，harness 复用不重建），并在公开 benchmark 上证明这种"造自进化 agent 的能力"跨领域可迁移。 首要贡献是概念与形式化定义；产出走宿主原生、我们只提供一套薄/统一适配框架便于复现。简言之：现有的自进化 agent 是"会进化的动物"，MEGA 是"会造会进化的动物、且这造物能力自己也会进化并跨域搬家"的造物机制。

1. 背景与动机

1.1 现状（来自综述）

自进化智能体（Self-Evolving Agent）指能通过闭环反馈持续改进自身行为/策略/内部结构的系统，形式化为

$\Pi_{j+1} = f(\Pi_j,\ \tau_j,\ r_j)$

即第 j 次迭代中，系统 Π 根据轨迹 τ_j 与奖励 r_j 经进化策略 f 更新为 Π_{j+1}。综述归纳了进化对象（参数/prompt/记忆/工具集/工作流拓扑/角色）、进化范式（奖励驱动 RL、模仿、群体进化、元学习）、架构（记忆增强、多智能体分层、自我修改/元认知），以及代表性工作：

DGM（达尔文 Gödel 机）：迭代修改自身代码、基准上超过祖先才保留 → 开放式自我改进；SWE-bench 20%→50%。
Hyperagents：任务 agent 与元 agent 集成在同一可编辑程序里，元层面的修改过程本身也可被修改 → 递归自我改进。
RoboPhD：70 行→1500 行、BIRD 73.67%，自主发现未预设策略。
EvolveSearch：无人工标注迭代 RL，多跳问答 SOTA +4.7。
MUSE / ICE：层次化记忆、工作流复用，跨任务迁移、成本降数量级。
MindFlow+：奖励下 SFT + ReAct，电商客服 94% AICR。

1.2 Gap（我们要解决的）

上述工作有一个共性：Π 的进化机制 f 与进化对象范围是为人预设、领域绑死的。

RoboPhD 的进化只在 text-to-SQL，f 是"改 SQL 分析代码"，换到数学就失效。
alcor-chaos 的 eval-improve 只会改排障 agent 的工具/prompt/case，f 是"分析失败 case → 改 MCP/prompt/seed"，换到科研就无法迁移。
DGM 的 f 是"改 SWE-bench 代码"，迁移到别域要重写整个 bootstrap。
综述点名的"未来方向"里，跨领域、机制可迁移的自进化是开放问题；Hyperagents 提了"元机制可被修改"但仍是单一域内递归，没做到"跨域造 agent"。

核心 gap：缺少一个"会构造自进化 agent"的元层（meta-level）。 现有工作把"进化什么、怎么进化、用哪个 eval"硬编码进了领域；我们要把这套机制参数化、外置、可生成，让一个元 agent 看到新场景就能 bootstrap 出一个适配该域的自进化 agent。

1.3 为什么现在可行

LLM 已具备"读领域 spec → 生成 prompt/harness/工具脚手架"的工程化能力（见 Claude Code harness、各类 codegen）。
公开 benchmark 覆盖广（MATH/AIME、SWE-bench、MLE-bench、MLAgentBench、GAIA、DiscoveryBench），可作跨域 eval 闭环的统一信号源。
我们已有一个真实领域实例（alcor-chaos 排障自进化 agent），可作"元层要产出的目标形态"的参照系与基线。

2. 问题形式化

把综述的 $\Pi_{j+1}=f(\Pi_j,\tau_j,r_j)$ 提升一层。定义：

域级 agent $A_\mathcal{D}$ ：在领域 $\mathcal{D}$ 上跑的自进化 agent，由一组可进化的"部件"组成：
$A_\mathcal{D} = (\text{prompt},\ \text{harness},\ \text{env},\ \text{memory},\ \text{tools},\ \text{eval},\ \text{evolver})$
其中 evolver 是该域自己的进化机制 f_D（改哪些部件、按什么信号、用什么策略）。
元 agent $M$ ：输入领域描述 $\text{spec}_\mathcal{D}$ （任务定义、可用工具 API、benchmark、reward/eval 接口、约束），输出一个初始域级 agent $A_\mathcal{D}^{(0)}$ （含上面 7 个部件的初版），并在其上跑元进化闭环：

$A_\mathcal{D}^{(k+1)} = M\bigl(A_\mathcal{D}^{(k)},\ \text{Spec}_\mathcal{D},\ \text{EvalSignals}_\mathcal{D}^{(k)}\bigr)$

$M$ 不仅改 $A_\mathcal{D}$ 的任务部件（prompt/tools/memory），还改 $A_\mathcal{D}$ 的进化机制 evolver 本身（改什么、怎么改、何时改）——这正是 Hyperagents 的"元机制可被修改"，但跨域。
元层与域层形成两级闭环：域内闭环（ $A_\mathcal{D}$ 在 benchmark 上自进化）+ 元闭环（ $M$ 据 $A_\mathcal{D}$ 在多域上的进化表现，改进"如何造自进化 agent"）。
$M$ 自身也在进化——关键。元闭环跨域迁移的元知识（"如何造 evolver"的先验/策略）随 $M$ 处理更多域而积累并迁移，这本身就是 $M$ 的自我进化：

$M^{(t+1)} = \text{MetaUpdate}\bigl(M^{(t)},\ \{\text{EvalSignals}_\mathcal{D}\}_\mathcal{D},\ \text{MetaMemory}^{(t)}\bigr)$

即 $M$ 的元先验/策略/MetaMemory 随跨域经验更新—— $M$ 不是冻结的造物器，而是自身随跨域经验进化的自进化 agent。这与综述的"open-ended RSI"区别在： $M$ 进化的是知识/先验层（可跨域迁移的 pattern），不是自己的代码结构或评估器（结构锁 D3、评估器外部 D7）——故是有界的自进化（§26 详述）。

三层进化阶梯（递进、各有界）：

L1 域内： $A_\mathcal{D}$ 的部件（prompt/tools/memory）——最快、域内。
L2 元层： $f_\mathcal{D}$ （evolver， $M$ 改它）——depth-2。
L3 M 自身： $M$ 的元先验/策略（跨域积累+迁移）—— $M$ 自进化，在知识层非代码层。

关键创新点：把"进化对象"从"某个 agent 的部件"泛化到"一个域级 agent 的构造与进化机制"，再泛化到" $M$ 自身的元先验"——三层进化，使进化能力跨域迁移、且造物机制本身随跨域经验自进化。

3. 产出形式：概念+形式化为主，薄/统一适配框架为载体

先定位贡献层级：首要贡献是概念与形式化定义（spec-driven 跨域 meta 进化、两级闭环、可迁移的自进化能力、有界开放式 RSI）。产出不是自创的"skill"概念当主角，也不是又一个重框架——产出是该域 agent 在宿主原生配置里的形态（Claude Code 的 CLAUDE.md/AGENTS.md + skills、Codex 的 tool/skill、LangGraph 的 graph 节点+prompt delta、自研 harness 的配置面 delta）。我们只提供一套薄/统一适配框架（spec 协议 + adapter + verifier/safety/meta-memory 胶水）便于复现与使用、不局限于特定 harness、与标题"Framework"相符。skill 只是 Claude Code 这一宿主的原生产物形态之一，不是我们的 novelty 概念。

层	是什么	角色
① 薄/统一适配框架	spec 协议 + evolver 运行时 + eval harness + 跨域元闭环调度 + harness adapter	复用载体，不是新 agent 引擎；概念+形式化的可复现薄实现
② MEGA 本身（元层）	一个 meta-skill（meta-evolver）+ 元 prompt，跑在任意 harness 里	真正的研究对象
③ MEGA 产出的域级 artifact	该域 agent 在宿主原生配置里的形态（`CLAUDE.md`/`AGENTS.md`+skills / delta / graph-edit / code，见七部件）	域级自进化 agent

关键决策：复用 harness，不重建。Claude Code 的 query loop、工具调度、hooks、权限、记忆、子代理已具备；重建这些和"元自进化"无关、评审会问"为何不直接用现有 harness"。把 harness 当地基复用，meta 层是地基上的薄适配层。harness-agnostic 的部分 = spec 协议 + eval harness + evolver 运行时 + meta-memory；harness-specific 的部分 = 一个薄 adapter（按宿主切产物形态：Claude Code skill 格式 / Codex tool 格式 / LangGraph graph delta / 自研 harness 配置 delta）。

为什么是"薄/统一适配框架"而非重框架或"skill 当主角"：alcor-chaos 已证明整条自进化链可建在 Claude Code 原生 skills 上（eval-improve/eval-seed/aemu-verify/git-push…），eval-improve 本身就是宿主原生 skill。这说明产出走宿主原生配置可行，我们不必自创产物概念，只需一层薄适配把 MEGA 的输出翻成各宿主的原生形态。novelty 在概念+形式化（怎么 spec-driven 跨域生成+迁移+depth-2），不在"又造个 skill 格式或重框架"。

3.1 MEGA 产出的七个部件（target artifact spec）

给定 $\text{Spec}_\mathcal{D}$ ，MEGA 必须生成一个可独立运行的 $A_\mathcal{D}^{(0)}$ （落在宿主原生配置形态），含：

部件	内容	跨域可参数化的点
prompt	系统 prompt + 任务模板 + 推理风格（ReAct/CoT/Reflexion…）	域知识、排查/解题的"先 X 后 Y"顺序、排除干扰项
harness	（复用，非产出）主循环/工具调度/记忆/hooks/权限/恢复由宿主 harness 提供	仅产出该域的 harness 配置（工具白名单、hook 规则、记忆挂载点），不重写引擎
env	执行环境与反馈接口：sandbox、文件系统、执行器、benchmark runner	域特定（排障=k8s+chaos；数学=Python+sympy；科研=代码+实验脚本）
memory	经验记忆/通用记忆的 schema、CRUD、检索策略、遗忘	域知识粒度、记忆图结构、检索配置（EvolveMem 思路：检索机制本身可进化）
tools	工具集 + 工具描述 + 接口契约 + 可动态扩展（以 skill/MCP 形式）	域工具（inspect_k8s / sympy / paper-search）、工具自创机制
eval	奖励/评估信号来源：benchmark 分数、验证器、人类反馈、自评	域特定 reward（题面答案/通过率/代码测试/排障根因命中）
evolver	该域的进化机制 f_D：改哪些部件、按什么信号、什么策略、何时触发	这是 M 的核心产出——为每个域定制一个 f_D（见 §11 表达形式分叉）

alcor-chaos 的 eval-improve skill 就是"排障域 evolver"的一个手工实例（分析失败 case → 分类失败原因 → 改工具/prompt/case → 重跑）。我们要让 $M$ 自动产出这种 evolver，而不是人手写。harness 那一行说明：M 不产出新 harness 引擎，只产出该域的 harness 配置片——把宿主 harness 当地基复用。

4. 元进化闭环（meta-loop）

             ┌──────────────────────────────────────────────┐
             │            Meta Agent M                        │
Spec_D ─────►│  1. 理解域: 任务/工具/reward/约束/已有实例      │
             │  2. 生成 A_D^(0): 七部件初版                    │
             │  3. 跑 A_D 的域内闭环 (在 benchmark 上自进化)    │
             │  4. 收集 EvalSignals: A_D 在 benchmark 的表现   │
             │     + 失败 case 根因 + evolver 哪步没生效        │
             │  5. 元进化: 改 A_D 的部件 和/或 改 evolver 本身  │
             │     (元机制可被修改, 跨域迁移)                   │
             └───────────────┬──────────────────────────────┘
                             │ 产出可独立运行的 A_D
                             ▼
                    域级自进化 agent A_D = 一个 skill-pack + agent config
                    (prompt + env + memory + tools + eval + evolver,
                     harness 复用宿主、不重写)
宿主 harness (Claude Code/Codex): 提供 query loop / 工具调度 / hooks / 权限 / 记忆 / 子代理
框架(薄): spec 协议 + evolver 运行时 + eval harness + 跨域元闭环调度

首要贡献是概念+形式化；产出走宿主原生配置、harness 复用不重建：MEGA 本身是一个 meta-evolver 跑在任意宿主 harness 里；它产出的每个域级 agent 落在该宿主的原生配置形态（CLAUDE.md/AGENTS.md+skills / delta / graph-edit / code），装进同一 harness 就能自进化跑闭环——不用另起 runtime。我们只提供一套薄/统一适配框架（spec 协议+adapter+verifier/safety/meta-memory 胶水）便于复现使用、不局限 harness。三层中 ②③ 是论文核心产出，①是薄复现载体。

两级闭环的边界：

域内闭环（快、量大）： $A_\mathcal{D}$ 在 benchmark 上反复跑、改自己的 prompt/tools/memory/case，提升域内分数。这是综述里说的"任务内/任务间进化"。
元闭环（慢、量小）： $M$ 看多个域、多个 $A_\mathcal{D}$ 的进化曲线/失败模式，改进"如何造 evolver、如何初始化七部件"——跨域迁移知识。

为什么两级分离：域内进化要快迭代、域特定；元层要慢思考、抽象跨域规律。混在一起会让元层被域噪声淹没。

5. 三个目标领域实例（验证 generality）

5.1 排障 agent 自进化（已有 → 作为基线/参照）

现状：alcor-chaos 已有排障自进化 agent，eval-improve 手工实现了 f_D（失败原因分类表 → 改 MCP 工具 / prompt / case seed → 重跑）。它造 chaos case、生成 eval seed、push 分支，闭环在真实集群跑。
在本文的角色：作为"evolver 长什么样"的参照实例（pattern reference）——它手写的 eval-improve 是一个真实在产的 evolver 形态，MEGA 学其形态、产出该域的 evolver。不与它比优劣（人写域特定、不可公平比），只证 MEGA 产出的 evolver 经验上有效（§8.5）。
benchmark：内部排障 eval（根因命中率/排查路径命中/cost），可补公开 proxy（如 k8s 故障注入公开集）。

5.2 数学场景

目标：给定数学 benchmark， $M$ 产出能自进化提升解题率/证明成功率的数学 agent。
benchmark：MATH / GSM8K / AIME / AMC；证明类用 miniF2F / ProofNet。
evolver 候选产物：改解题策略（CoT→ToT→self-verify）、改工具（加 sympy / 计算器 / 代码执行）、改记忆（记常见套路/陷阱）、改 reward（最终答案正确性 + 过程校验）。
对照：STaR / Self-Taught Reasoner、Self-Consistency、Reflexion 等手写数学自提升方法，作为人类设计基线，看 $M$ 自动复现/超越。

5.3 科研场景

目标：给定一个科研任务（如"在某数据集上设计一个更好的 baseline"）， $M$ 产出能自进化探索实验流程的科研 agent。
benchmark：MLAgentBench / MLE-bench / DiscoveryBench /（AI Scientist 风格的开放科研）。
evolver 候选产物：改实验流程（假设→实验→分析循环的拓扑）、改工具（文献检索/代码执行/可视化）、改记忆（记失败假设与原因）、改 reward（benchmark 指标提升 + 新颖性）。
对照：AI Scientist、RoboPhD 手写科研自进化流程作为人类设计基线。

三个域横跨"AIOps/系统、数学推理、科研探索"，覆盖面够广，足以支撑"跨域 generality"主张。

6. 实验设计：如何用公开 benchmark 证明 generality

6.1 核心实验矩阵

对每个域 $\mathcal{D} \in \{\text{排障, 数学, 科研}\}$ ，对比三条线：

条件	含义	作用
(a) Static baseline	不进化的 agent，固定 prompt/tools	下界，证"进化本身"有效
(b) MEGA-evolved (ours)	MEGA 自动产出 evolver + 元闭环	主结果，证"产出有效"
© Oracle / SOTA	该 benchmark 当前 SOTA	定位绝对水平

主主张：(b) over (a) 有可重复提升 + 达合理绝对水平 → evolver 经验上有效（三域都成立 → generality）。不与"人写 evolver"做优劣对比（人写域特定、目标不同、不可公平比）；alcor-chaos eval-improve/Reflexion/AI-Scientist 仅作"evolver 长什么样"的参照实例，非基线。

6.2 generality 的三个可证伪子主张

跨域产出有效： $M$ 给一个新域 spec（不在训练域里），产出的 $A_\mathcal{D}$ 能在该域 benchmark 上自进化并超过 static baseline。
元机制跨域迁移：在域 A 上学到的"如何造 evolver"迁移到域 B，比从零 bootstrap 收敛更快（元学习的迁移增益）。
元机制本身可被进化：让 $M$ 改自己造 evolver 的策略，比固定策略的 $M$ 在多域平均上更好（递归自我改进增益）。
**env/eval/verifier跟随进化的必然性：**对于verifier/eval不同类型的的信号质量给出实验和评估，强调env/eval层进化需求的必然性。

6.3 度量指标

域内性能：benchmark 分数随进化轮次的曲线（绝对值 + 相对 baseline 增益）。
进化效率：达到某分数所需的轮次 / LLM 调用 token / wall-clock（参综述"效率"维度）。
evolver 有效性：MEGA 产出的 evolver 让 agent over static baseline 的可重复提升幅度 + 达到的绝对水平（不与人写 evolver 比）。
跨域迁移增益：元层在域 A 学过 vs 没学过，域 B 的收敛曲线对比。
稳健性：多 seed 下方差、reward hacking 发生率、安全退化指标（综述点名风险）。

6.4 关键消融

去掉"改 evolver"只改部件 → 验证元层递归的价值。
去掉跨域迁移（每域独立 $M$ ）→ 验证跨域 generality 的来源。
不同 LLM 作 backbone → 验证非依赖某模型。

7. 与既有工作的关系（novelty 定位）

已读：综述 Recursive Self-Improvement in AI（42 页，1250 篇，2D taxonomy）+ MOSS（生产级 substrate 源码级 self-rewriting，OpenClaw 0.25→0.61，唯一触 harness）。两个最强对照：MOSS 是当前最强单域 self-evolving 系统；综述点名"open-ended RSI 未解"。novelty 必须同时站住对这两者差异化。原 20 篇里 #4 MetaSkill-Evolve / #6 RHI 仍是近邻。

7.1 与最近邻工作的精确区分

既有工作	它做了什么	本工作的差异
DGM	单域开放式自我改代码	我们让"改什么、怎么改"本身跨域可生成，不是固定 SWE-bench
Hyperagents	元机制可被修改（单域递归）	我们把元机制做成跨域 bootstrap：给定新 spec 造新域 agent
AI Scientist / RoboPhD	手写科研/SQL 自进化流程	我们让这套流程被 M 自动产出，而非人手写
EvolveSearch / Reflexion / STaR	单域自提升方法	我们的目标是"能产出这类方法的元方法"
MUSE / ICE	记忆/工作流复用	我们把记忆与工作流作为七部件之一被 $M$ 生成
Meta-prompting / ADAS（Automated Design of Agentic Systems）	自动搜 agent 结构/prompt	最接近；区别：它们搜"静态最优 agent"，我们搜"会进化的 agent + 进化机制"，目标是产出自进化闭环而非一次性最优配置

最近邻	它做了什么	重叠点	本工作的关键差异
、	层次化 skill meta-evolving：skill evolving 算法本身也可 test-time 优化（学 meta-skills 指导 extractor/refactorer/refiner）；2 benchmark（BFCL-v4+MineDojo）×4 baseline×ablation×process curve×meta-test（冻结 meta-skills→新 run），3 runs+token cost；depth-2	depth-2 最近邻——“skill evolving 算法可被优化"≈"M 改 evolver”	五处分：① HiSME 单 benchmark（meta-test 是同域冻结→新 run，非跨域），我们跨域（N1，A 域学→B 域用）；② HiSME 只进化 skill 库（一部件），我们进化七部件+evolver（更宽）；③ HiSME 是 test-time 积累（bottom-up，从 trace 积累），我们还做 spec-driven bootstrap（top-down，从 spec 造完整 agent）；④ HiSME depth-2 止（meta-skills 是顶层），我们 depth-3（M 自身跨域自进化，§26）；⑤ HiSME 单 substrate，我们 substrate-agnostic。诚实：HiSME 的 depth-2 不是我们的 novelty——我们的 novelty 是 depth-2+跨域+七部件+spec-driven+depth-3。实验比我们 solid，须借鉴。
EvoAgentX	开源自进化框架：从 prompt 自动构造多 agent workflow（WorkFlowGenerator）+ 一组优化器（AFlow/EvoPrompt(GA,DE)/MAP-Elites/MIPRO/TextGrad/SEW，含 code-scheme 变异）+ 内置 eval + 记忆 + HITL	“自动构造 agent + 多优化器 + eval” 与我们重叠最重	四处分：① 它单 substrate（必须把 workflow 写进它的 graph 格式），我们 substrate-agnostic（复用 Claude Code/已有 harness，产 skill-pack/delta）；② 它单域 depth-1（优化器改 workflow/prompt，不改进化器），我们 depth-2（M 改 evolver）；③ 它优化器是固定库任选，我们 evolver 由 M 按域生成且 skill↔code 谱上迁移；④ 它无跨域迁移，我们 MetaMemory + held-out 域迁移（核心 novelty）。它是工程工具箱，我们是 thesis（§19）
MOSS	生产级 substrate（OpenClaw）source-level self-rewriting，唯一触 harness；4 任务 0.25→0.61 单周期；外部 coding-agent CLI 编辑，MOSS 管 stage/verdict；user-consent-gated 容器 swap + health-probe 回滚	"源码级编辑 + coding-agent CLI + 重放验证"≈ 我们 evolver-as-code(P4)+verify/gate	① MOSS 单 substrate 单域，我们跨域（M 给 spec 造域 agent + 元知识迁移）；② MOSS 改 agent+harness 是 depth-1，我们 depth-2（M 还改 evolver f_D）；③ MOSS 主张"source-level 永远严格优于 text-mutable"，我们主张 skill↔code 是可学习轴（per-domain 选级 + 谱上迁移），MOSS 是谱的一端
综述 RSI	2D taxonomy（改什么 × 闭环度）；bounded self-refinement vs open-ended RSI；点名 open-ended RSI 未解、最关键 cell=自评估×闭环	把我们放进 taxonomy 某格	我们是 taxonomy装不下的二阶/元层（改进改进器 + 跨域迁移）；并给 survey 的 open 问题一个 tractable 第三路（§19）
#4 MetaSkill-Evolve	双时标：task-skill 快循环 + meta-skill 慢循环，五流水线组件共享冻结骨干；OfficeQA/SealQA/ALFWorld +23/+16/+2	"元技能慢循环"≈ 我们的元层	它在单域内改进已有 pipeline 的技能；我们做跨域生成——给定新域 spec，生成一个全新的域级自进化 agent，且元知识跨域迁移。它是"改进一个 agent 的技能"，我们是"造一个会自进化的 agent 的造物器"
#6 RHI	harness 作 prompt 级 spec 迭代精炼，model-harness co-evolution；30 个 ML 研究任务，成本降 60%	"harness 可进化"≈ 我们的 harness-config 部件	它精炼单个 harness；我们在多域上从 spec 生成 harness-config+其它六部件，元层跨域迁移"harness 该怎么构造"。它单 harness 自精炼，我们多 harness 跨域生成
#18 Source-Level Rewriting	agent 重写自身源码（含 harness），突破文本层限制	≈ 我们的 evolver-as-code（P4）	它在单 agent 上做源码自改写；我们把"源码级 evolver"作为 $M$ 的可生成产物之一，且跨域、有 spec 边界
#19 Gödel Agent	运行时自读自改自重构行为逻辑，递归自改	"递归自改"近	它自改行为逻辑（单 agent 推理策略）；我们自改域级 agent 的构造与 evolver，跨域、可验证、有基元边界
#3 SEA	anytime-valid 证书 + 版本化执行框架 + 适配器，安全门控	安全/可验证机制	我们把 SEA 的证书机制提升到两级（域级修改 + 元级修改都门控），并跨域复用一套验证先验
#11 Agent-World	合成 1978 环境/19822 工具驱动 agent 自进化	env 合成	它在单训练场合成 env；我们把 env 作为七部件之一被 $M$ 生成+进化，且跨域，env-agent 协同进化
#8 Personal Singularity	goal/scope/tool/benchmark 驱动，人机共生	spec 含 goal/tool/benchmark	它面向个人共生（人机长期协同）；我们面向跨域 generality（机器自主跨域造 agent），spec 是给 $M$ 的输入非共生契约
ADAS / Meta Agent Search	ICLR 2025。把 agent 定义为 Python 代码（`def forward(Task): ... return Answer`），meta agent（GPT-4）在不断增长的 archive 上迭代编程新 agent、测试、加入 archive。Python 是 Turing-complete → 搜索空间 = 任何 agent 设计。已验证跨域+跨模型迁移：MGSM 搜的 agent 迁移到 GSM8K/GSM-Hard/MMLU/DROP + Claude-Haiku/GPT-4/Claude-Sonnet，全超 baseline。5 benchmark，25-30 轮/域。	“元层自动设计 agent” + 跨域迁移已验证——与 N1 重叠最重	六处分：① ADAS 搜静态 agent（一次性产出最优 agent code）；我们产出会自进化的 agent + evolver 闭环（时间维度，持续改进）。② ADAS 的"迁移"= 复用同一个 agent code 到新域；我们的迁移= 复用 builder 经验造新域的新 agent（warm-starter 读 MetaMemory → bootstrap-builder 造全新 agent，不同架构）。③ ADAS 无安全（无 D7/D3/D8/P2 gate，每个 error-free agent 进 archive）；我们有 D3-D9 + 9 轮 reject 证明 gate 有效。④ ADAS 无 eval evolution（固定 task accuracy）；我们有 §22 per-criterion critique 驱动靶向编辑。⑤ ADAS 无 spec-driven bootstrap（给任务域搜 agent，不能从 spec 造）；我们能从 spec→agent。⑥ ADAS 无 brownfield 复用（自包含 Python 函数）；我们产 delta 到现有 harness。最危险重叠：ADAS 已验证跨域迁移（MEGA 的 N1），必须用实验证明"迁移 builder 经验造新 agent"≠"复用搜到的 agent code"。

7.2 存活下来的核心 novelty（必须在 abstract 第一段讲清）

经过综述 + MOSS + 20 篇洗礼，核心 novelty 收窄为两条且仍成立：

(N1) 跨域元自进化： $M$ 是 spec-driven 跨域生成器——输入领域 spec，输出该域自进化 agent（含 evolver），且"如何造 evolver"的元知识跨域迁移。MOSS/综述内全部工作都是单域自改进，无跨域生成与迁移。
(N2) 二阶 / 有界开放式 RSI： $M$ 不只改 agent（depth-1，MOSS 做），还改 evolver（depth-2），但递归深度封顶=2 + 独立 verifier 锚定——给综述"open-ended RSI 未解"一个 tractable 第三路：水平开放（域数无界）+ 垂直有界（depth-2、verifier-grounded）。

风险提示：① 若 MetaSkill-Evolve 的 meta-skill 被泛化为"给新域生成技能"则与 N1 边界模糊——必须坚持"生成完整域级 agent（七部件）+ 跨域元知识迁移 + depth-2 改 evolver"这个更宽对象，并用 held-out 新域实验证明 #4 不能直接迁移而我们能。② MOSS 的"source-level 严格优于 text-mutable"会把我们 skill-form evolver 归为弱者——回应是 §19.3 的谱论（per-domain 选级 + 谱上迁移），把 source-level 纳为 evolver-as-code 的一个端点而非全局最优。③ EvoAgentX 工程上最完整（自动构造+多优化器+eval+memory+HITL），“造+优化 workflow"这块拼不过——明确不与它拼工程广度，差异化全在 thesis/跨域/substrate/depth-2/safety（§21）。④ HiSME 是 depth-2 最近邻——“skill evolving 算法本身可 test-time 优化"≈"M 改 evolver”，实验 solid。它的 depth-2 不是我们的 novelty——差异化全在 depth-2 之外（跨域/七部件/spec-driven/depth-3，详见 §7.3）。⑤ ADAS（ICLR 2025）是最危险竞品——它已验证跨域+跨模型迁移（MGSM→4 域 + 3 模型），而这正是 MEGA 的 N1 还没验证的。必须用实验讲清区别：ADAS 的迁移 = 复用同一份 agent code 到新域（同一个 agent 跨域跑）；MEGA 的迁移 = 复用 builder 经验造新域的新 agent（不同 agent、不同架构）。用 held-out 域实验证明"MEGA warm-start 造的新 agent” vs “ADAS 直接复用搜到的 agent”，架构不同且性能可比/更优。ADAS 搜索空间更广（Turing-complete 代码级 vs MEGA 配置级）且发了 ICLR——MEGA 须补跨域实验 + P4 代码级 + 发 paper（详见 §7.4）。

7.3 HiSME 大白话对照

HiSME（清华+华为 2026）是当前最接近我们 depth-2 (N2) 的竞品，实验 solid。用大白话讲清重叠与差异。

HiSME 做了什么（大白话）：一个 agent 干活时攒"技能"（可复用经验/工具）。但攒技能的方法本身也不完美——有时攒出垃圾、维护错了。HiSME 的洞察：再学一层"元技能"——关于"怎么攒技能才攒得好"的规则——从结果反推（哪些有用、哪些有害 → 总结"下次怎么攒"）。两层：技能让 agent 变好（L1），元技能让攒技能的方法变好（L2）。比方：学生刷题攒错题本（L1），但"怎么整理错题本"这方法自己也不行——于是再学"怎么整理才更好"（L2）。

重叠（跟我们一样的地方）：

两层改进：HiSME 的"元技能优化攒技能方法" = 我们的"M 改 evolver"——都是"改进器自己也被改进"。HiSME 先做了，不是我们的 novelty。
都不改模型权重（纯文本空间）。
都有"考一考再决定留不留"（HiSME 的 bundle test + 信用分 = 我们的 safety gate + verifier）。

差异（我们多的，HiSME 没的）：

#	维度	HiSME	MEGA	大白话比方
①	跨域 vs 同域	单 benchmark（meta-test 同域冻结→新 run）	跨域（A 域学→B 域用）	HiSME 是"同一门课换一届学生重教"；我们是"数学课总结的教学法用到科研课上"
②	改一个抽屉 vs 整个工具箱	只进化 skill 库（一部件）	七部件+evolver（更宽）	HiSME 把"错题本"一个抽屉整理到极致；我们连工具箱每个抽屉都管
③	从零造 vs 只会改进	只 test-time 积累（bottom-up）	还做 spec-driven bootstrap（top-down）	HiSME 是"只会批改错题本越改越好"；我们还能"看一眼大纲就从零建一本全新的"
④	两层 vs 三层	depth-2 止（meta-skills 是顶层）	depth-3（M 自身跨域自进化，§26）	HiSME 是两层楼（学生→方法）；我们是三层（学生→方法→方法的方法还会跨学科搬家）
⑤	一个厨房 vs 任意厨房	单 executor	substrate-agnostic	HiSME 是"你得在我们厨房做菜"；我们是"我们去你家厨房做"

一句话：HiSME 和我们都做"让改进器自己也被改进"（两层），但这块 HiSME 先做了、不是我们的 novelty——我们多的全在两层之外：跨域（HiSME 同域、我们跨域）、七部件（HiSME 只技能库、我们全工具箱）、从零造（HiSME 只能积累、我们还能 spec→bootstrap）、三层（HiSME 两层止、我们 M 自己还跨域自进化）、任意厨房（HiSME 单 executor、我们 substrate-agnostic）。实验上 HiSME 比我们 solid——须借鉴其 ablation/curve/meta-test/case-study 严谨度（§20.6b）。

7.4 ADAS 大白话对照

ADAS（ICLR 2025，UBC）是最该严肃对待的竞品——它已验证跨域+跨模型迁移，而这是 MEGA 的核心 novelty (N1) 还没验证的。

ADAS 做了什么（大白话）：把 agent 写成一个 Python 函数（def forward(Task): return Answer），让 GPT-4 在一个"搜出来的 agent 都存着"的档案库上迭代——每次看前面搜过的 + 分数 → 写一个新 agent → 测分 → 存进库。因为 Python 是 Turing-complete，搜索空间 = 任何可能的 agent 设计（prompt、工具、workflow、多 agent 组合都能搜到）。搜了 25-30 轮/域，5 个 benchmark（ARC/DROP/MGSM/MMLU/GPQA），还验证了"在数学域搜的 agent 直接用到阅读理解域仍然超 baseline"——跨域迁移已验证。

比方：ADAS 是"写一堆考卷让学生做，把做得好的学生的做题方法存档，下次根据档案写新考法"——搜到的好方法能跨科用。

重叠（跟 MEGA 一样的）：

元层自动设计 agent——ADAS 的"meta agent 编程新 agent" = 我们的"M/bootstrap-builder 造 agent"。
跨域迁移——ADAS 已验证（MGSM→MMLU/DROP）；MEGA 设计了（warm-starter + MetaMemory）但还没验证。这是最危险的重叠。
都是 test-time，不改模型权重。

差异（MEGA 多的，ADAS 没的）：

#	维度	ADAS	MEGA	大白话
①	迁移的是什么	复用同一份 agent 代码到新域	复用builder 经验造新域的新 agent（不同架构）	ADAS 是"同一个学生跨科考"；MEGA 是"数学老师总结的教学法用来教科研课的新学生"
②	静态 vs 自进化	搜到的好 agent 是静态的（一次产出，不再改进）	产出的是会自进化的 agent + evolver 闭环（持续改进）	ADAS 是"找到一把好扳手就用着"；MEGA 是"造一个会自己磨快的扳手"
③	安全	❌ 零（每个 error-free agent 进 archive，无 gate）	✅ D3-D9 + P2 gate（9 轮 reject 证明有效）	ADAS 是"只要跑得通就留下"；MEGA 是"跑得通且严格更优才留下"
④	eval evolution	❌ 固定 task accuracy	✅ judge per-criterion critique 驱动靶向编辑（§22，已验证）	ADAS 是"只看分数"；MEGA 是"看老师评语知道哪里弱→靶向改"
⑤	spec-driven	❌ 给任务域搜 agent	✅ 给 spec → 造完整 agent	ADAS 是"给考试题搜考法"；MEGA 是"给课程大纲造学生"
⑥	brownfield	❌ 自包含 Python 函数	✅ 产 delta 到现有 harness	ADAS 是"独立的小程序"；MEGA 是"给你的现有系统打补丁"

ADAS 比 MEGA 强的（诚实）：

#	维度	ADAS	MEGA
A	搜索空间	代码级（Turing-complete，任何 agent 设计）	配置级（七部件 schema 内编辑，P4 stub）
B	跨域迁移	✅ 已验证（MGSM→4 域 + 3 模型）	❌ 设计了没验证
C	benchmark 数	5 个 + transfer + cross-model	2 个（DeepResearch + 排障）
D	发了 paper	✅ ICLR 2025	❌
E	发现新设计	✅ 发明"Structured Feedback Ensemble"等新架构	⚠️ 更多是增量编辑

最危险的点 + 必须用实验讲清的区别：

ADAS 的"跨域迁移" = 把域 A 搜到的 agent 代码直接拿到域 B 跑——同一个 agent，不同域。
MEGA 的"跨域迁移" = 用域 A 学到的"怎么造/进化 agent"的经验，在域 B 造一个全新的 agent——不同 agent，不同架构，但 builder 的经验复用了。

这个区别非常微妙，评审不容易区分。必须用实验证明：

“ADAS 的迁移 = 复用 agent；MEGA 的迁移 = 复用 builder 经验造新 agent。”

在 held-out 域上对比：(a) ADAS 式直接复用域 A 的 agent code 跑域 B vs (b) MEGA 用域 A 的 MetaMemory warm-start 域 B 的 bootstrap-builder 造新 agent——如果 (b) 的新 agent 架构与 A 不同且性能≥(a)，就证明 MEGA 的迁移 ≠ ADAS 的复用。

一句话：ADAS 和我们都做"元层自动设计 agent"，但 ADAS 搜到的是静态 agent（一次性产出、直接复用到新域），MEGA 产出的是会自进化的 agent + builder 经验跨域迁移造新 agent。ADAS 已验证跨域迁移（MEGA 的 N1）——必须用实验证明"迁移 builder 经验造新 agent"≠"复用搜到的 agent code"这个区别。ADAS 搜索空间更广（Turing-complete vs 配置级）且发了 ICLR——MEGA 须补跨域实验 + P4 代码级 + 发 paper。

8. 风险与挑战（综述已点名，必须正面应对）

8.1 信号可靠性与 reward hacking（最高风险）

综述明确：DGM 实验中发现 agent 会"假装用工具、伪造日志骗评估器"。两级闭环下风险更大——域内 agent 可能欺骗域 eval，元层可能基于被污染的信号改进。

对策：每个域要求独立于被进化系统的确定性验证器（参综述建议）；数学/科研域天然有 ground-truth（答案正确/代码测试通过），排障域用真实集群 inject→validate→recover 闭环（alcor-chaos 已是确定性验证器）；元层信号用"验证器通过的 case"而非 agent 自评。

8.2 安全退化与经验偏差

综述发现：仅从良性任务累积经验也会降低高风险场景安全性（执行导向强化"完成任务"倾向）。元层跨域迁移经验时更易把某域的"激进执行"倾向带到别域。

对策：七部件里的 harness 强制最小权限 + human-in-the-loop（接你已写的 Claude Code harness 安全设计 + agent 安全篇）；元层进化设"安全不退化"硬约束（每轮检查拒绝率/破坏性动作数不恶化）。

8.3 评估基准缺失

综述点名"如何衡量进化能力/泛化能力"是开放问题。

对策：本文本身贡献一个跨域自进化 eval 协议（6.3 的指标集 + 三域 benchmark 选型），作为副产物。

8.4 成本与可复现

两级闭环 token 量大、wall-clock 长。

对策：域内闭环用小模型/蒸馏；元层用强模型但低频；发布 spec/benchmark/产物 checkpoint 供复现。

8.5 "造 evolver"是否真的有效（不与人写 evolver 比优劣）

评审会问：MEGA 产出的 evolver 真能改进 agent 吗？

对策：只证经验上有效——MEGA 产出的 evolver 让 agent 在 held-out 上有可重复提升（over static baseline）、达合理绝对水平。不与人写 evolver 做优劣对比：人写 evolver 域特定、手工调优、与 ours 目标不同（人写是"把这一域调到极致"，我们是"跨域产出有效 evolver"），不可公平比较。我们的主张是 generality + 有效性（同一 MEGA 跨三域都能产出有效 evolver），不是单域超人。排障域 8→1 是有效性正面证据（虽当前人 in-the-loop，升级 MEGA 自动驱动复现即坐实）。alcor-chaos 的 eval-improve 作"evolver 长什么样"的参照实例（pattern reference），非要被击败的基线。

9. 贡献（contributions）

经 20 篇论文洗礼后重新收敛。主推 1–4，其余作 ablation/扩展。

概念（主）：spec-driven 跨域生成—— $M$ 是给定领域 spec、生成该域自进化 agent 的造物器，且"如何造 evolver"的元知识跨域迁移。与 #4 MetaSkill-Evolve（单域技能改进）/ #6 RHI（单 harness 自精炼）划清：我们是跨域生成而非域内自改进。
七部件跨域隐因子分解（主）：提出 prompt/env/memory/tools/eval/evolver/harness-config 是跨域自进化 agent 的共享潜在结构，元层学其先验并跨域迁移（§12 创新点 1）。
evolver 的 skill↔code 谱与转换策略（主）：把 evolver 表达力建模为 skill→code 连续谱 + 学一个按 spec 复杂度切换的转换策略（§12 创新点 2），区别于 #18 只做源码自改写、#4 只做 meta-skill。
有界开放式 RSI（主）：跨域开放、每域受 spec + anytime-valid 证书 + 基元边界约束的 tractable 开放式 RSI，回应 #17 综述"open-ended RSI 未实现"（§12 创新点 4）。
形式化：两级闭环 $A_\mathcal{D}^{(k+1)}=M(A_\mathcal{D}^{(k)},\text{Spec},\text{EvalSignals})$ ，明确七部件与 evolver 可生成边界。
产出形式与薄框架：首要贡献是概念与形式化定义；产出非自创"skill"概念当主角，而是落在宿主原生配置（CLAUDE.md/AGENTS.md+skills / delta / graph-edit / code）；我们提供一套薄/统一适配框架（spec 协议 + adapter + verifier/safety/meta-memory 胶水）便于复现与使用、不局限于特定 harness、与标题"Framework"相符。重框架/runtime 留给 EvoAgentX/LangGraph/AutoGen，我们是凌驾其上的薄适配层。
提升既有机制（borrow-and-lift）：两级 anytime-valid 证书（lift #3）、env 作被生成+协同进化部件（lift #11）、verifier 作一等元层产物防 reward-hacking（§12 创新点 5/6/7）。
实证（有效性，不与人写 evolver 比）：三域（排障/数学/科研）公开 benchmark 证明 MEGA 产出的 evolver 经验上有效（agent over static baseline 有可重复提升、达合理绝对水平；排障域已有 8→1 正面证据）+ 跨域迁移增益（held-out 域协议）+ depth-2（evolver 本身可进化且有效）。不与人写 evolver 做优劣对比（人写域特定不可公平比）；alcor-chaos eval-improve 作 evolver 形态的参照实例非基线。
副产物：跨域自进化 eval 协议（指标集 + benchmark 选型 + held-out 域方法 + reward-hacking 防护）+ 效率优化点（§13）。
工程贡献（影响力）：framework-agnostic + stage-agnostic 的通用进化层——任何 agent 开发者、用任意框架（Claude Code/Codex/LangGraph/AutoGen/自研如 alcor-chaos）、在任何阶段（开发前从零 bootstrap / 开发中已有 agent 原地进化）都能用本框架进化其 agent。关键：我们不是又一个 agent runtime（不像 EvoAgentX/LangGraph/AutoGen 是 runtime），而是凌驾于任意 runtime 之上的薄/统一适配层——产出该框架能消费的原生形态，MEGA+glue（spec/verifier/safety/meta-memory）恒定。详见 §25。

10. 路线图（timeline）

阶段	内容	产出
P0 形式化与 spec 协议（2 周）	定义七部件 schema、Spec_D 格式、evolver 接口契约；选定宿主 harness（Claude Code）并明确"复用不重建"边界	spec 协议 + harness adapter 抽象
P1 单域 MVP（evolver-as-skill 形式）（3 周）	先在数学域跑通： $M$ （meta-skill）产出数学 skill-pack → 域内自进化 → MATH 分数上升。evolver 先用 skill 形式（prompt 策略表 + 脚本，同 alcor-chaos 的 `eval-improve`）	单域闭环 demo（skill-form evolver）
P2 复用 alcor-chaos 作排障域（2 周）	把 alcor-chaos 现有 evolver（`eval-improve`）作形态参照，验证 MEGA 能产出该域有效 evolver（不与手写版比优劣，只证有效）	排障域 evolver 有效性证据
P3 科研域（3 周）	MLAgentBench/MLE-bench， $M$ 产出科研 skill-pack	第三域闭环
P4 元闭环 + evolver-as-code 升级 + 跨域迁移（3 周）	元层跨域迁移、元机制自进化；在 P1 skill 形式之上放开到 evolver-as-generated-code（M 产出可执行 evolver 程序，配沙箱），对比两种表达力的增益（递归自我改进子主张）	主结果：MEGA-evolved over static 三域成立 + skill↔code 两形式消融
P5 防护与稳健性（2 周）	reward hacking 检测、安全不退化约束、多 seed	风险闭环
P6 写作（3 周）	paper 撰写、复现包（meta-skill + 三域 skill-pack + spec 协议 + eval harness）	投稿稿

11. 开放问题（留给评审/未来）

元层会不会无限递归： $M$ 改 evolver，那谁改 $M$ ？是否需要固定 $M$ 的元机制（“基元”）以避免无限上溯？倾向： $M$ 自身结构固定为基元，只进化其产出物与产出策略，不递归改自身架构（与 Hyperagents 区分）。
"域"的粒度：数学与科研算不同域吗？跨域迁移是否只是"任务难度/工具集不同"而非真新域？需要用 spec 复杂度量化"域距离"。
evolver 的表达形式：skill 还是生成代码？（核心设计分叉） $M$ $M$ 产出的 evolver 有两种形式：
- (i) evolver-as-skill：M 产出一个 skill——prompt 里写"失败分类→改部件映射→重跑"策略表 + 几个脚本。与 alcor-chaos 的 eval-improve 同构。安全、可验证、可对标人类手写，MVP 用它。
- (ii) evolver-as-generated-code：M 产出真正的可执行 evolver 程序（能写新工具、改记忆 schema、动态插 hook）。更强、novelty 更高，但 reward hacking/安全退化风险大（综述点名），要沙箱兜底。
- 路线：P1 走 (i) 先证明跨三域 generality（主主张）；P4 放开到 (ii) 展示"放开表达力能多进化一截"（递归自我改进子主张）。两者消融对比是 §6.4 的关键 ablation。
与 ADAS 的边界：要讲清"自进化"相对"静态最优 agent 设计"的增益在什么条件下为正——若 benchmark 上限已近，静态设计可能就够，自进化收益小。需选"仍有进化空间"的 benchmark。
可迁移性的证伪：是否存在某些域 $M$ bootstrap 失败？找出失败域、分析 spec 特征，反而能界定方法边界，使论文更可信。

12. 在 20 篇基础上的增量创新点（innovation points）

除 §7.2 那条存活的"spec-driven 跨域生成 + 元知识跨域迁移"主线外，下列每条都是相对 20 篇的增量创新，可作为论文的次要 contribution / ablation / 扩展。

七部件跨域隐因子分解（latent factorization）：提出 prompt/env/memory/tools/eval/evolver/harness-config 这七部件是跨域自进化 agent 的共享潜在结构，元层学的是该结构的先验（哪些部件、什么关系、怎么初始化）并跨域迁移。20 篇无人提出跨域组件因子分解——#4 是单域五组件，#11 是 env-centric，#10 是 capability+experience。这是结构性主张，可做因子分析验证。
evolver 的 skill↔code 谱作为可学习轴 + curriculum：#18 做源码自改写、#4 做 meta-skill，但无人研究从 skill 形式到 code 形式的谱与转换策略。我们贡献：(i) 把 evolver 表达力建模为 skill→code 的连续谱；(ii) 学一个转换策略——简单域给 skill 形式、难域给 code 形式、按 spec 复杂度/收益曲线自动切换。这是 §11 分叉的定量化，可做关键 ablation。
跨域元知识迁移 + 迁移的安全风险（双重性）：#10 做经验蒸馏（域内）、综述点名安全退化，但无人研究元知识跨域迁移本身会携带"执行导向"倾向污染目标域安全。我们贡献：显式建模"meta-knowledge transfer 的安全副作用"，设计安全保持先验（每轮校验目标域拒绝率/破坏性动作不恶化）。这把综述的安全风险点提升到跨域迁移层，是新颖的安全角度。
有界开放式 RSI（bounded open-ended RSI）：#17 综述指出"开放式递归自改进（open-ended RSI）尚未实现"，受动力学崩溃/计算约束。我们贡献一个可工程化的中间形态——跨域开放但每域受 spec + anytime-valid 证书 + 基元边界约束的有界开放式 RSI。回应 #17 的开放问题，给出 tractable 的落地形态。
两级 anytime-valid 证书（borrow from #3, lift to meta）：#3 SEA 在单级自修改上做证书门控。我们把证书机制提升到两级——域级 agent 的自修改受证书门控、元层 $M$ 对 domain-agent 的修改也受证书门控，且跨域复用一套验证先验。是在 #3 之上的一层扩展而非竞争。
env 作为被生成+被进化的部件（agent-env co-evolution at meta level）：#11 合成 env 驱动单 agent 自进化。我们把 env 列为七部件之一，由 $M$ 按 spec 生成、并随 agent 共同进化（任务分布/难度 curriculum），且跨域。env 从"训练场"变成"元层产物+协同进化对象"。
eval/verifier 作为一等公民的元层产物（anti reward-hacking）：综述点名 reward hacking。我们把"验证器设计"作为 $M$ 的一等产出，强制要求独立于被进化系统的确定性 verifier（数学=答案 ground-truth、科研=代码测试、排障=inject→validate→recover），元层信号只用"verifier 通过的 case"非 agent 自评。把 reward-hacking 防护从"事后检查"提升为"元层产出契约"。
held-out 域的元进化能力评估协议：#17 综述点名"如何衡量进化能力/泛化能力"是开放问题。我们贡献一个评估协议：在 2 个域上训元层、在第 3 held-out 域上测生成+迁移增益（§6.2 子主张 1+2 的可操作化）。是方法论副产物，填补 #17 的空白。
spec-delta → agent-delta 的增量重生（部分创新）：spec 小改时 $M$ 只重生受影响部件而非整个 skill-pack（delta-spec→delta-agent）。20 篇均做"整轮重生/迭代"，无人做增量 diff 生成。是工程创新，可显著降元层成本。
元层先验蒸馏与摊销（amortized meta-inference）：两级闭环昂贵。把元层学到的"evolver 先验/部件先验"蒸馏成一个小可复用库，使新域 bootstrap 从"昂贵的从零生成"降为"先验一次填表 + 少量精炼"。借鉴 #10 的蒸馏思想但提升到元层跨域摊销，是效率创新。

注：1/2/3/4 是概念级创新（论文主 novelty 候选）；5/6/7 是对既有机制的提升（borrow-and-lift，相对 #3/#11/综述）；8 是方法论；9/10 是工程优化。建议论文主推 1+2+3+4，其余作 ablation/扩展章节。

13. 优化点（efficiency / engineering）

两级闭环 token 量大、wall-clock 长，下列优化点降低成本、提升可复现，支撑论文的效率主张（§6.3 度量）。

O1 双时标预算自适应（借鉴 #4 但自适应）：借鉴 #4 的快慢双时标，但域内循环与元循环的算力预算按收益自适应分配——域内增益递减时把算力挪给元层；而非固定比例。
O2 摊销的 spec→agent（对应创新点 10）：元先验蒸馏成库后，新域 bootstrap 走"先验填表"快路径，只在收益不够时回退到完整生成。
O3 spec-delta 增量重生（对应创新点 9）：spec 局部变更只重生受影响部件（影响分析靠部件依赖图）。
O4 spec 复杂度自适应 evolver 深度（对应创新点 2）：简单域 skill 形式 evolver（低成本）、难域 code 形式（高成本高收益），阈值由 spec 复杂度与收益曲线学习。
O5 候选种群 + 锦标赛剪枝（借鉴 #4 锦标赛/#19 探索）：每 spec 维护 top-k 候选 domain-agent，保留胜出、剪枝劣者，避免局部最优。
O6 跨域元记忆（对应创新点 1/10）：维护一张"domain-feature × evolver-pattern × 收益"表作为元层记忆，新域时检索相似域特征的 evolver 先验复用，是跨域摊销的具体载体。
O7 域内循环用小模型、元层用强模型：域内快循环量大用蒸馏小模型，元层慢但关键用强模型，分级用模型降 token 成本。
O8 并行多域 + 多 seed：多域元闭环并行跑（域间独立），多 seed 估方差，并行化 wall-clock。
O9 checkpoint + 断点续跑：两级闭环任意点可存可续（接 alcor-chaos 的 git-push/归档思路），支持长时训练与复现。

14. 针对已识别不足的解决方案（deficiency → solution）

把 §7.2 novelty 风险、§8.1–8.5 风险、§11.1–11.5 开放问题逐条落到可执行方案。每条给"操作化定义 + 杀手实验/约束"，避免空谈。

D1. novelty 与 #4/#6 边界过窄（§7.2）→ 用"冷启动新域"操作化测试 + 更宽产出对象

操作化判据：定义"冷启动新域测试"——给 #4 MetaSkill-Evolve / #6 RHI 一个它们从未见过的 held-out 域 spec，测能否从零产出一个能自进化的 agent。主张：它们不能（#4 需要既有 pipeline 的 task-skill 才能改进；#6 需要既有 harness 才能精炼），而 $M$ 能（spec→agent）。这是划界的杀手实验。
更宽产出对象： $M$ 产出完整七部件（含 env/eval/verifier），而 #4 只在既有五组件 pipeline 内改 task-skill、不（重）生成组件本身、不产 env/eval；#6 只精炼既有 harness。“生成组件本身 + 跨域"严格宽于"改既有组件 + 单域”，这是结构性差异非程度差异。
落实验证：在 §6 held-out 域上跑 #4/#6 的 cold-start，量化它们退化/失败，对照 MEGA 能生成。把这条写进 abstract 与 related work 的直接对比（system vs system，非 vs 人写 evolver）。

D2. evolver 是否真的有效（§8.5）→ 经验有效性 + 不做不公平对比

只证经验有效：MEGA 产出的 evolver 让 agent 在 held-out 上可重复提升（over static baseline）、达合理绝对水平——即"有效"。不追求、也不报告"vs 人写 evolver 优劣"。
不做 vs 人写对比的理由：人写 evolver 域特定、手工调优、目标是"这一域调到极致"；ours 目标是"跨域产出有效 evolver"。两者目标不同、不可公平比；硬比会误导（评审也会质疑 apples-to-oranges）。
alcor-chaos eval-improve 的角色：作"evolver 长什么样"的参照实例（pattern reference，我们有其源码可学形态），非要被击败的基线。排障域 8→1（人 in-the-loop 版）是"该 evolver pattern 有效"的正面证据，升级 MEGA 自动驱动复现即坐实 ours 也有效。
主张收窄：从"比人写更好"收为"跨域产出有效 evolver（generality+有效性）"——这条更可证、更稳。

D3. 元层无限递归（§11.1）→ 基元公理（代码层固定）+ M 在知识层自进化

基元公理（代码层）： $M$ 自身的代码结构（meta-skill 骨架 + spec 协议 + 七部件 schema + evolver/safety/meta-memory 实现）固定为基元、不可被 $M$ 自己改写——防无限递归崩溃。
但 $M$ 在知识层自进化（ refining，不矛盾）： $M$ 的元先验/产出策略/MetaMemory随跨域经验积累+迁移而更新（§2 的 $M^{(t+1)}=\text{MetaUpdate}(\ldots)$ ）——这是 $M$ 的自我进化，但进化的是知识/先验，不是代码结构。两者区分清晰：代码层封顶防崩溃，知识层开放随跨域成长。
递归深度封顶：L1（域部件）→ L2（evolver， $M$ 改它）→ L3（ $M$ 的元先验，跨域更新）= 三层；L3 不再上溯（不进化"更新元先验的机制"本身）——这是与 Hyperagents 无界递归的划界。
与 D7 协同： $M$ 自进化只动知识层，不动评估器（verifier 标签仍外部锚定 D7）——故 $M$ 的自进化不会塌成 reward hacking。
与 Hyperagents/综述划界：Hyperagents 允许无界递归（元机制本身可被修改无限层）；我们有界（代码层封顶、L3 不再上溯）——这正是"有界开放式 RSI"（§12 创新点 4）的工程落地，回应综述"open-ended RSI 未实现"。

D4. "域"粒度模糊（§11.2）→ spec 距离度量 + 迁移曲线

spec 距离 $d(\mathcal{D}_a,\mathcal{D}_b)$ ：基于 (工具 API 重叠率、reward 函数类型、env 接口类型、技能复用率) 的加权度量。
用途 1：选三个目标域使两两距离 > 阈值（确保真"不同域"非任务难度差）。
用途 2：把迁移增益画成 $d$ 的函数（越近迁移越好）——可证伪曲线，把"是不是真跨域"从嘴炮变可测。

D5. vs ADAS 边界 / 自进化何时为正（§11.4）→ 预筛"进化空间"+ 明示生效条件 + 报负结果

预筛 benchmark：选"静态 SOTA 离天花板远"或"已知迭代有益"的 benchmark（MATH、SWE-bench、排障），避开天花板已近的。
明示生效条件：自进化对静态设计的增益为正当且仅当 (i) 有进化空间 + (ii) reward 可靠 + (iii) evolver 够得着杠杆（部件可改）。事先声明，防"cherry-pick"指控。
报负结果：诚实给出"自进化不增益"的域（如无可靠 reward 的纯知识 QA、杠杆不可达域），界定方法边界，反而增可信度。

D6. 可证伪性 / M 失败域（§11.5）→ 主动探失败域 + 失败签名

主动探失败域：刻意构造 spec 特征使 $M$ 应失败的域（无可靠 reward、杠杆不可达、spec 自相矛盾），测 $M$ 确实 bootstrap 失败/退化。
失败签名：归纳"失败 spec 特征"（如 reward 类型=无 ground-truth、工具集不可扩展），给方法边界的形式化描述。honest negative results 是论文可信度的硬通货。

D7. 两级 reward hacking（§8.1）→ 强制独立 verifier + 域内 train/test split + 伪造检测

域级：强制独立确定性 verifier（数学=答案 ground-truth、科研=代码测试通过、排障=inject→validate→recover 真集群），元层信号只用 verifier-passed case，禁用 agent 自评。
元级：元层"改进"在域内未见过的 held-out 任务上度量（域内 train/test split），让 $M$ 无法 game 自己训练信号。
伪造检测：全量记 tool 调用，对"DGM 发现的伪造工具日志"模式做异常检测（输出与真实工具不符）；对抗红队：注入可 game 的"诱饵 verifier"，验 $M$ 不去 exploit。

D8. 跨域安全退化迁移（§8.2 / §12.3）→ 安全保持先验 + 拒绝经验注入 + 沙箱

安全保持先验（硬约束）：每次元进化，校验目标域拒绝率/破坏性动作率不恶化超阈值（作 anytime-valid 证书的一类），违反即回滚。
拒绝经验注入：迁移元知识时显式携带"拒绝相关经验"（综述指出含拒绝经验可缓解退化），对冲执行导向倾向跨域污染。
沙箱 + HITL：evolver-as-code（P4）全沙箱、破坏性动作 human-in-the-loop（接 Claude Code harness 安全设计 + agent 安全篇）。
元记忆解耦：在元记忆里把"任务完成导向"与"安全导向"经验分开存，避免迁移时执行导向 bleed 到目标域。

D9. 评估基准缺失（§8.3）→ 贡献评估协议本身

把 §12 创新点 8（held-out 域协议）+ §6.3 指标集作为贡献而非缺陷回应——"领域缺评估协议"正是我们要填的坑。具体：2-train-1-heldout 跨域协议；指标 = 域性能曲线 + 跨域迁移增益 + evolver 发现新颖度 + 人工工时节省 + 安全不退化。这是 §9 贡献 9 的可操作化。

D10. 成本与可复现（§8.4）→ §13 优化 + artifact 包

成本：上 §13 全部优化（摊销先验、小模型域内/强模型元层、并行多域多 seed、spec-delta 增量、checkpoint）。
可复现：发布 artifact 包 = meta-skill + 三域 skill-pack + spec 协议 + eval harness + verifier；pin 模型版本/seed/config；两级闭环任意点可存可续（接 alcor-chaos git-push/归档）。

不足→方案→验证一览

不足	位置	方案核心	验证手段
novelty 边界窄	§7.2	冷启动新域测试 + 更宽七部件产出	held-out 域 #4/#6 cold-start 退化对照
劣化复制质疑	§8.5	重定义胜利=generality+摊销 + 发现性证据	一 M 跨 N 总工时 vs N 手写 + 发现新 pattern
无限递归	§11.1	基元公理 + 递归深度封顶=2	形式化定义 + 与 Hyperagents 划界
域粒度模糊	§11.2	spec 距离度量 + 迁移曲线	两两距离>阈值 + 迁移增益-f(d)曲线
ADAS 边界	§11.4	预筛进化空间 + 明示生效三条件 + 报负结果	失效域诚实呈现
可证伪性	§11.5	主动探失败域 + 失败签名	honest negative results
两级 reward hacking	§8.1	独立 verifier + 域内 train/test + 伪造检测	红队诱饵 verifier 不被 exploit
跨域安全退化	§8.2	安全保持先验 + 拒绝经验注入 + 沙箱	拒绝率不恶化阈值门控
评估基准缺失	§8.3	贡献 held-out 协议本身	§9 贡献 9 可操作化
成本/可复现	§8.4	§13 优化 + artifact 包	30s/轮级 + 复现包 pin

15. 立即下一步（本周可做）

[x] 把 alcor-chaos 的 eval-improve skill 结构提炼成 evolver-as-skill 模板（EvolverAsSkill.DEFAULT_TABLE）。
[x] Spec_D schema 定稿（framework/spec/spec_schema.json + self_evolve/spec.py）。
[x] 选定宿主 harness（Claude Code）、明确复用边界（harness_adapter.py + skill 形式 + hook/memory 挂载）。
[x] 数学域端到端跑通（Mode A mock + Mode B claude solver 实测 4/4）。
[ ] 精读 #4 MetaSkill-Evolve / #6 RHI 全文，产出 D1 冷启动对照实验设计（novelty 命门）。
[ ] 上真 MATH/GSM8K 切片验证 kill criterion（分数随轮次上升）。
[ ] 让一个独立 Claude Code 会话（加载 meta_evolver skill）自动驱动 verify→Edit→gate 多轮，产出 experiments/math_mvp.md 曲线。

16. 设计问答（澄清，design Q&A）

本节把围绕构想的反复追问与澄清固定下来，避免再绕回。多数已在 self-evolve 仓库的 .claude/skills/meta_evolver/SKILL.md 与 CLAUDE.md 落地为可执行协议。

Q1 产出形式到底是框架还是 skill？

三层、核心落在 skill，不重建 harness（§3）：

薄框架（spec 协议 + evolver 运行时 + eval harness + 跨域调度）；
$M$ 本身是一个 meta-skill，跑在 Claude Code/Codex harness 里；
每域产出可独立运行的 skill-pack + config（七部件）。
宿主 harness 当地基复用——M 只产出该域的 harness 配置片，不写新引擎。评审会问"为何不直接用现有 harness"——这正是答案。

Q2 怎么用？起 claude 加载 skill 吗？

两种用法都通：

Mode A（Python 编排）：MetaAgent 调 MockLLM（离线）/AnthropicLLM，MetaLoop 跑两级闭环。python -m self_evolve.cli run ... --llm mock|anthropic。
Mode B（Claude-native，论文 novelty）：起 claude 在仓库根，自动加载 .claude/skills/meta_evolver=M；M 用 Write/Edit/Bash 落盘 skill-pack、verify/gate CLI 作黏合、域 agent 跑 headless claude -p（ClaudeSolver）。
mock LLM 只认内建 3 域（math/troubleshooting/research），新域要 --llm anthropic 或 Mode B 才有域特定 bootstrap。Mode B 已实测：verify --solver claude 在 math 4 题全对 score=1.0。

Q3 新建一个新领域 agent 怎么做？

cp -r domain-template ~/my-domain，改 3 个文件（spec.yaml/benchmark.py/verifier.py），pip install -e ../self-evolve，跑 Mode A/B。spec.yaml.benchmark.module 用顶层模块名（benchmark/verifier），因为 python -m 把 cwd 加进 sys.path。若是论文跨域迁移实验域，别单独建仓，放 self-evolve/domains/<name>/、module 用 domains.<name>.benchmark，这样 MetaMemory 能跨域 warm-start（D4 迁移）——这是 generality 主张的点。

Q4 能不让用户提前给那几个领域文件，由 agent 引导完善吗？

能，且这是"meta"的延伸——M bootstrap spec 自身。onboarding 访谈：问任务性质→起草 spec.task/tools/constraints/domain_features（描述性，可自动起草）；问正确性判定→选 verifier 形式；问 ground-truth 在哪→用户报源。但 ground-truth 标签那一步不能省（D7 硬地板）：标签必须人确认或来自真数据集，不能 M 自造——否则塌 reward-hacking。把它做成"轻量确认"而非"从零手写"是正确平衡。

Q5 用户给 benchmark 源（SWE-bench / Langfuse 数据集）但没接入代码怎么办？

M 写适配器，不造标签。用户报源（benchmark 名 / .jsonl 路径 / Langfuse dataset id），M 写 benchmark.py+verifier.py 适配器：Benchmark.tasks() 运行时从源 load→Task，Verifier 委托源的 native judge 或对源 label exact-match。标签永远在外部源，M 只写连接管道→D7 站住。适配器留空、协议写进 skill——框架不预置适配器库保通用，域时按协议现写。复杂度分层：轻（.jsonl exact-match / Langfuse expected_output / MATH \boxed{}）= 现写完整适配器；重（SWE-bench 原生 judge）= 写委托壳调官方 eval 不重造判定。硬规则：适配器运行时 load label，源码不许 inline held-out 答案（safety gate 可 lint）。

Q6 已有自己的 agent 框架+harness 的域，M 也适用吗？

适用 iff harness 暴露 ≥1 可进化缝隙（D5 杠杆可达：prompt 文件/tool 注册/memory dir/eval 接线/evolver 钩子 + 一个 batch entrypoint）。此时 M 不替换 harness，产出的是针对它配置面的 delta（非 skill-pack）：harness_config 列要 edit 的缝隙路径，物理改动是写/编辑那些文件。SolverBackend 抽象已支持——ClaudeSolver shell 到 claude -p，已有 harness 用 HarnessSolver shell 到它的 entrypoint，verify/gate 闭环不变。D7 在这里更严：现有 harness 常自带 self-score，不能用当信号，必须外接独立 benchmark，唯一 eval 是 harness 自打分→拒绝。全封闭零缝隙 harness→M 诚实拒绝（D5），只有 prompt 缝隙就老实标"prompt 优化器"别吹全自进化。风险：harness 自升级打破 delta→pin 版本或每轮 re-勘察。alcor-chaos 是参照 case（P2：MEGA 给它 harness 产 evolver，eval-improve 作形态参照非基线，独立 verifier=inject→validate→recover 真集群）。

Q7 M 产出 A_D 后，进化由跟 M 交互还是跟 A_D 交互？

由 M 驱动，不跟 A_D 交互进化。A_D 只跟任务环境交互产出 EvalSignals（τ, r）；M 读信号、套 f_D、改 A_D 的持久部件、过 gate——改 A_D 的是 M。两个时间尺度别混：任务内反思（Reflexion，A_D 跟自己/环境交互，不持久化，只把这一题做好）≠ 任务间元进化（M 按聚合信号改 A_D 持久部件，这才是"A_D 进化"）。f_D 是 A_D 的第七部件但由 M 的 loop 执行（skill-form：M 读策略表做 Edit=执行者；code-form P4：M 跑生成的程序=orchestrator，f_D=policy）。D3 封顶 depth=2：M 进化 A_D + f_D，但不进化 M 自己——否则无限上溯。Mode B 实操：“跟 M 交互”=跟加载 meta_evolver skill 的 Claude Code 会话说话；A_D 是 headless 的（verify --solver ...），你不直接跟它对话进化它。

澄清过的若干边界点（一览）

项	澄清
harness	复用不重建，M 只产 harness 配置片
mock LLM	只认内建 3 域，新域需 anthropic/Mode B
evolver 两形式	skill（MVP，可对标 alcor-chaos）/ code（P4，沙箱兜底）
f_D 执行者	M（skill-form M 解释表；code-form M 跑程序）
D5 适用门槛	≥1 可达缝隙；全封闭→拒绝
D7 硬地板	标签/判定必须外部锚定，M 只写连接管道
适配器	留空，协议进 skill，域时现写，不许 inline label
跨域迁移	论文域放 monorepo `domains/`，MetaMemory warm-start

17. 实验记录：排障域（troubleshooting domain）——首个真实域实例

数据来源：~/Documents/实习/排障Agent评测.pdf。Langfuse cmojj4n0j042u0907zntnpud8；chaos MR alcor-chaos!383；eval MR infini-evaluation!56。本项目第一个跑起来的真实域，对应 plan §P2。

17.1 进化曲线

日期	case	通过率	关键事件
7.08	10	7/10	初版评测
7.09–10	11	8/11 ≈ 80%	修 a9 节点 + 加 MCP 工具
去除 infjob 后	23	15/23 ≈ 65%	全量测试基线
7.20–24	复跑 8 失败	8→仅 1 失败（7/8 恢复）	自进化 prompt + tools 后重跑，原 23 case 整体 65%→22/23≈96%

17.2 自进化效果——evolver 循环首个正面证据

7.20–24 执行的"分析失败 trace → 自进化 prompt + tools → 重跑"正是 EvolverAsSkill 策略表在跑：tool_missing→tools（补 MCP 工具）、prompt_insufficient→prompt（langfuse 托管 prompt 加规则）。结果：

原 8 个失败 case → 自进化后仅剩 1 个失败（7/8 恢复）；
原 23 case 通过率 65% → 22/23 ≈ 96%。

这正面回答了 §14 D2：人 in-the-loop 的 evolver（即 alcor-chaos eval-improve 范式）把 8 个失败修到只剩 1 个，证明"分析失败→改部件→重跑"三段式有效。plan §P2 下一步：把这条人 in-the-loop 换成 MEGA 自动驱动（verify→Edit→gate）复现 8→1——证 MEGA 产出的 evolver 经验上有效（不与手写版比优劣）。

18. 后续实验建议

18.1 排障域推进（P2）

MEGA 自动驱动闭环：用 Mode B（加载 meta_evolver 的 Claude 会话）跑 verify→Edit→gate 多轮，复现 8→1 的恢复——证 MEGA 产出的 evolver 经验上有效（不与手写版比优劣）。
Verifier 落地：把 alcor-chaos 的 inject→validate→recover 真集群闭环写进 domains/troubleshooting/verifier.py（现 stub），作该域独立信号。
扩 held-out 集：23 case → 更大规模、与训练 case 隔离的 held-out 测试集，提升统计力。

18.2 跨域推进（generality 主张）

数学域接真 MATH/GSM8K 切片：现 MVP 用 4 题 stub，接真数据集验证 kill criterion（分数随轮次上升）。
三域齐备后跑 held-out 域协议（§6.2 子主张 1+2）：2 域训 M、1 held-out 域测生成+迁移增益——novelty 立不立的命门（§14 D1）。
MetaMemory 跨域 warm-start 实测：排障域学到的 evolver 策略 warm-start 数学/科研域（D4 迁移曲线）。

18.3 论文产出

跑出 (b) over (a) 三域曲线（MEGA-evolved vs static，证有效性）+ held-out 迁移增益 → M3 里程碑 → 开写。

优先级

先 18.1.1（MEGA 自动驱动复现 8→1，证 evolver 有效）——把已得的人 in-the-loop 正面结果升级成 MEGA 自动驱动结果；同步 18.2.4（数学真数据集）。跨域 held-out（18.2.5）是 M3 前最后的 novelty 验证。

19. 更大的故事：从"自进化 agent"到"自进化的自进化器"

读综述 + MOSS 后，把故事抬高一层、讲得更有感染力。原故事是"跨域生成自进化 agent"——对，但偏工程。抬到 thesis 级：不是让一个 agent 自进化，而是让"自进化能力"本身自进化并跨域扩散。 这层正好落在综述 taxonomy 的空白处、且正面回应其 open 问题。

19.1 对综述的 open 问题给 tractable 第三路（最有感染力的一句）

综述的二分：bounded self-refinement（收敛、可评、已工业落地）vs open-ended RSI（闭环且改自己评估器——受 grounding/collapse/compute 限制，未实现、危险）。综述说两者之间的地带是"最关键的开放问题"。

我们主张第三路——有界开放式 RSI（bounded open-ended RSI）：

水平开放：域数无界——给任意新域 spec，M 造一个自进化 agent，永不封顶"能做哪些域"。
垂直有界：每域递归深度封顶=2（M 改 agent + evolver，不改 M 自身=基元边界，D3），且信号锚定独立 verifier（D7）不改自己评估器。

这恰好绕开综述点名的两个 RSI 死结：① “改自己评估器”（reward hacking 前沿）→ 我们禁止（D7，verifier 独立）；② "无限递归崩溃"→ 我们封顶 depth-2（D3）。一句感染力的话：“我们不追求让一个 agent 无限改自己（open-ended RSI 的危险幻想），而是让’造自进化 agent’这件事本身开放生长——开放在域的维度，有界在进化的深度。”

19.2 二阶自进化：改进"改进器"本身（综述 taxonomy 装不下的一格）

综述 taxonomy 两轴都是一阶——“一个系统改进自己”。我们引入二阶：M 改进的不是 agent，而是evolver f_D（改进器）；且 f_D 跨域迁移。综述里 HyperAgents 是最接近的（“meta-procedure 本身可编辑”），但它单域递归、无跨域。我们的二阶 + 跨域 = 综述 1250 篇里没有的一格。把这张图放进 intro：

1
2
3

一阶(MOSS/DGM/...):  agent ──自改──► agent'      (单系统改自己, 单域)
二阶(本工作):         M ──改──► evolver ──改──► agent   (改进改进器)
                       └──── 元知识跨域迁移 ────►

19.3 对 MOSS “source-level 严格最优” 的回应：skill↔code 谱论

MOSS 强论证"source-level 是 text-mutable 的严格超集（Turing-complete、确定、不漂移）"——这会把我们 skill-form evolver 归为严格弱者。回应不是否认，而是把 MOSS 纳为谱的一端：

自进化的"编辑介质"是一条谱：text-mutable（skill/prompt/memory）↔ source-level（harness 代码）。
MOSS 主张"永远取 source 端"。我们主张正确的位置 domain-dependent，且 MEGA 学一个转换策略：简单域/快速迭代给 skill 端（成本低、可读），收益 plateau 或需改 harness 时升 source 端（强、但风险高需沙箱）。
谱上还能迁移：A 域学到的"何时升 source"经验迁移到 B 域。
这把 MOSS 从"竞品"变成"我们谱上 source 端的一个强点"——更包容、更高一层。

19.4 跨域 generality：唯一研究"自进化能力"可迁移性的工作

MOSS 单 substrate、DGM/HyperAgents 单域、综述全部一阶——没有一条研究"自进化能力能否跨域迁移"。这是我们的实验独占位：held-out 域协议（2 域训 M、1 域测）直接量化迁移增益。如果迁移成立，故事就是"自进化能力像技能一样可积累、可复用"——比"在 X 域提了 Y 分"大得多。

19.5 故事一句话（intro 收尾候选）

We turn self-improvement from a per-agent, per-domain property into a transferable, second-order capability: MEGA (Meta-Evolution Genesis Agent), a meta-agent that, given a domain spec, bootstraps a self-evolving agent for it, evolves the evolver itself, and itself evolves across domains through transferable priors — open-ended across domains, bounded in depth (code/evaluator fixed), grounded by independent verifiers.

20. 更 solid 的实验矩阵

现有单域结果（排障 8→1、65%→96%）是强信号但单点。要对标 MOSS（0.25→0.61 controlled）+ 立住 novelty，实验须多域 × 多 baseline × 迁移 × 消融 × 安全。

20.1 主实验：三域 × 三 baseline（generality + evolver 有效性）

每域 $\mathcal{D}\in\{$ 排障、数学、科研 $\}$ 跑三条线，画分数-轮次曲线：

条件	含义	角色
(a) static baseline	固定 prompt/tools 不进化	下界，证"进化本身"有效
(b) MEGA-driven evolver (ours)	MEGA 自动驱动 verify→Edit→gate	主结果，证"产出有效"
© SOTA/oracle	该 benchmark 当前 SOTA	定绝对水平

主主张：(b) over (a) 有可重复提升 + 达合理绝对水平 → evolver 经验上有效（三域都成立 → generality）。不与"人写 evolver"比优劣（人写域特定不可公平比）；排障 8→1（人 in-the-loop）是"该 evolver pattern 有效"的正面证据，升级 MEGA 自动驱动复现即坐实 ours 有效。

20.2 杀手实验：held-out 域迁移（novelty 命门）

2 域训 M（如排障+数学），第 3 域（科研）held-out——测 M 能否从 spec 冷启动造出能自进化的科研 agent，且收敛比"从零 M"快（迁移增益）。
对比：#4 MetaSkill-Evolve / MOSS 在同 held-out 域的 cold-start——证它们退化/不能、我们能（D1）。
画迁移增益 vs 域距离曲线（D4 的 domain_distance）——越近迁移越好，可证伪。

20.3 消融（区分各 novelty 贡献）

去 depth-2（M 只改 agent 不改 evolver）→ 证二阶的价值（§19.2）。
去跨域迁移（每域独立 M、不共享元记忆）→ 证 N1 迁移的价值（§19.4）。
evolver skill vs code（谱论 §19.3）→ 证"per-domain 选级"优于"恒 source"或"恒 skill"；含一个 source-level 端点对照 MOSS。
不同 backbone LLM → 证非依赖某模型。

20.4 substrate generality（对照 MOSS 单 substrate）

同一 M 在两种 harness 形态跑通：① Claude Code skill-pack（数学）；② 已有 harness（排障经 HarnessSolver 接 alcor-chaos）——证 M 适配 harness 形状（§16 Q6），不止 OpenClaw 一 substrate。
至少一域让 M 产 source-level（code-form）evolver 改 harness，直接与 MOSS 同层对照，但跨域。

20.5 安全实验（直击综述"自评估×闭环"危险前沿）

reward-hacking 红队：注入可 game 的"诱饵 verifier"，验 M 不 exploit（D7）。
安全不退化：跨域迁移时拒绝率/破坏性动作不恶化（D8），跨域迁移的安全副作用（§12.3）。
depth-2 边界：验证 M 不偷偷改自己骨架（D3 基元）。

20.6 复现与统计

每条件多 seed（≥3）报均值±方差；扩 held-out 集（排障 23→更大、数学接真 MATH 切片）。
开源 artifact 包：M(meta-skill) + 三域 skill-pack + spec 协议 + eval harness + verifier，pin 模型/seed。
诚实负结果：记 M 失败的域/形态（§14 D6）界定边界。

20.6b 借鉴 HiSME 的实验设计（solid 的地方）

HiSME 的实验比我们当前 solid——借鉴其设计模式：

HiSME-static ablation：同框架去掉 meta-evolving → 隔离 depth-2 贡献。我们应做：MEGA-without-depth-2（EvolverAsSkill 只改部件、不改 evolver）vs. full MEGA。
Meta-test（冻结 meta-skills→新 run）：HiSME 在同域做（BFCL-v4→BFCL-v4）。我们应做跨域版：冻结 domain A 的 MetaMemory → 用作 domain B 的初始化 → 测迁移增益（§6.2 子主张 2）。这是我们比 HiSME 多出的跨域维度。
Process curve（分数随训练进度）：HiSME 画 test score 随训练步数的曲线，meta > static 全程。我们应画 agent score 随 meta-iteration 的曲线，MEGA > static baseline 全程。
组件消融：HiSME 消融每个 role（extractor/refactorer/refiner/filter）。我们应消融每个七部件 / 每个 D-rule。
Token cost（train/test/total）：HiSME 分开报训练和评估的 token 成本。我们应报同——证明 meta-evolving 的成本可接受。
Case study（grounded evidence）：HiSME 证明 meta-skills 不是泛泛建议、是 grounded 在具体 evidence 上的。我们应证明 MEGA 的 evolver 改动是 targeted semantic change、不是随机重写。
3 random runs + deterministic eval：可复现性标配。

20.7 优先级与里程碑

先：排障域把人 in-the-loop 8→1 换成 MEGA 自动驱动复现（证 evolver 有效的第一块）+ 数学接真 MATH 切片。
再：三域 (a)/(b)/© 曲线齐 → M2。
命门：held-out 域迁移（20.2）→ M3 → 开写。
消融/安全/substrate 并行于写作前。

21. 对照 EvoAgentX：差异化与额外创新点

基于对 EvoAgentX 仓库（255 个 .py 文件、~70K 行代码、v0.1.4）的完整源码精读，更新此节。EvoAgentX 是当前最完整的自进化 agent 框架（生产级：pip install、Discord/微信社区、双语文档、周会）。

21.0 规模对比（EvoAgentX 工程量碾压，诚实承认）

	EvoAgentX	MEGA	差距
Python 文件	255	10	25×
代码行数	~70,000	~1,500	47×
优化器	10 个（AFlow/Evoprompt GA+DE/MAP-Elites/MIPRO/TextGrad/SEW/RandomSearch/GreedyLogger/Example）	0（evolver.py 删了→evolution-analyst sub-agent 替代）	10:0
Benchmark	12 个（BBH/GSM8K/HotpotQA/HumanEval/LiveCodeBench/MATH/MBPP/NQ/RealMMRAG/WorfBench…）	3 个（math stub + troubleshooting stub + research stub）	12:3
内置工具	50+（browser/search×6/databases×3/finance/crypto/email/maps/RSS/arxiv/Docker interpreter…）	0（M 用宿主 harness 的工具）	50:0
存储后端	file/graph(Neo4j)/vector(Faiss/MongoDB/PostgreSQL)	无（M 用 Claude Code 原生 memory）	3:0
模型支持	OpenAI/Qwen/LiteLLM/OpenRouter/SiliconFlow	claude -p + mock	5:2
HITL	完整（approval_manager + GUI + interceptor_agent + workflow_editor）	D9 ask-when-insufficient（设计了）	完整:设计
预建 workflow	7 个（arxiv digest/travel/recipe/fengshui/tetris/invest…）	0	7:0
文档	完整（mkdocs EN+ZH + API docs + tutorials + Q&A）	2 个设计文档	完整:2
社区	Discord + WeChat + 周会 + GitHub stars	无	有:无
pip install	✅ `pip install evoagentx`	❌ 研究项目	有:无

诚实结论：EvoAgentX 在工程完成度上碾压 MEGA。论文里要诚实承认"不拼工程广度"，差异化全压在 thesis/跨域/安全/depth。

21.1 关键设计差异（源码精读后的发现）

① EvoAgentX 的 SEW “code” scheme 是假代码级——精读 sew_optimizer.py 的 get_workflow_code_repr：它生成的是 task_name(inputs) -> outputs 的签名伪代码，不是可执行的 agent 源码。任务本体仍是 EvoAgentX WorkFlowNode。所以 EvoAgentX 不做 MOSS 式 source-level 改写，也不做 ADAS 式 Turing-complete 代码搜索——它的"code scheme"只是给优化器读改的文本表示。

② 优化器是固定库——10 个优化器（AFlow/GA/DE/MAP-Elites/MIPRO/TextGrad/SEW…），你选一个用。优化器本身不进化、不跨域迁移、不改进自己的搜索策略。MEGA 的 evolution-analyst sub-agent 替代了"固定优化器"——M 自己推理改什么，不是从 10 个算法里选一个。

③ 不接现有 harness——agent 是 Agent(BaseModule) 对象，依赖 EvoAgentX 的 BaseLLM/Action/Message/MODEL_REGISTRY。要跑 EvoAgentX agent 必须 import evoagentx。MEGA 产 delta 给现有 harness（IAF/LangGraph），不要求移植。

④ 无跨域状态共享——每个 workflow 独立优化，优化器之间无状态共享、无 MetaMemory。EvoAgentX 连"域"的概念都没有（只有 workflow），更无跨域迁移。

21.2 维度对照（更新版）

维度	EvoAgentX	MEGA	谁强
Substrate	单 substrate 锁定（agent = EvoAgentX 运行时对象，必须 `import evoagentx`）	substrate-agnostic（复用 Claude Code/Codex/LangGraph/自研 harness，产 delta）	MEGA
进化对象	workflow/prompt/code-block，depth-1	agent + evolver，depth-2（M 改 f_D）+ depth-3（M 自跨域自进化，§26）	MEGA
优化器/evolver	10 个固定算法任选一个（AFlow/EvoPrompt/…/SEW），优化器本身不进化	evolution-analyst sub-agent（M 推理，非固定算法）+ evolver 由 M 按域生成	MEGA（更动态）
SEW “code” scheme	`task_name(inputs) -> outputs` 签名伪代码（非可执行源码）	P4 evolver-as-code（待实现，真 source-level）	设计阶段平
跨域	无（每 workflow 独立，无"域"概念，无 MetaMemory）	MetaMemory + warm-starter + held-out 域迁移（核心 N1，设计了没验证）	MEGA（有 vs 无）
输入契约	text “goal” → WorkFlowGenerator（无形式化 schema）	结构化 Spec_D（七部件 pydantic schema，形式化=代码）	MEGA（更形式化）
Verifier	内置 evaluator（LLM-judge，与 workflow 耦合，无 D7 独立性检查）	独立 ground-truth verifier（D7，禁自供/inline label）	MEGA
已有 agent 框架	必须移植进 EvoAgentX 格式	原地进化（产 delta 到 IAF/LangGraph 等已有 harness）	MEGA
安全	HITL 审批（但无 D3/D7/D8/D9 gate，优化器不检查 safety）	D3 基元（hooks 物理拦）+ D7 verifier 独立 + D8 非退化 gate + D9 主动提问	MEGA
P2 严格更优门	❌ 无（每个 error-free agent 进 archive，按分排序）	✅ gate reject 9/21 轮（证明拦了"看着对但崩"的编辑）	MEGA
eval evolution (§22)	❌ 固定 task accuracy	✅ judge per-criterion critique 驱动靶向编辑（DeepResearch 实验已验证）	MEGA
Ralph 循环+git	❌ 单 session 无 context reset / 无版本控制	✅ mega_loop.sh + git commit/checkout (§28)	MEGA
多智能体 meta 层	❌ 单 optimizer 跑	✅ 7 sub-agent 分工（env-assessor/eval-architect/seam-surveyor/warm-starter/bootstrap-builder/evolution-analyst/generality-checker）	MEGA
真实硬 benchmark	12 个标准 benchmark（QA/代码/数学），结果偏标准	DeepResearch Bench 100 题 PhD 级 + leaderboard 第 9（超 perplexity/grok）	MEGA（更硬）
有界开放式 RSI (§19)	❌ 不碰	✅ 水平开放+垂直有界（回应综述 open 问题）	MEGA
故事/thesis	工具箱	thesis（meta-evolution + 跨域 + 安全 + 有界开放式 RSI）	MEGA

21.3 四个核心差异化（EvoAgentX 结构上做不到的）

跨域迁移的自进化能力（N1，最强）：EvoAgentX 的优化器是通用算法作用于单 workflow，没有"在 A 域学到的进化经验迁移到 B 域"——它连"域"的概念都没有，只有 workflow。我们的 MetaMemory 把"domain-feature × evolver-pattern × gain"作可迁移资产，held-out 域协议量化迁移增益。这是 EvoAgentX 结构上做不到的（它的优化器无跨实例状态共享机制）。
substrate-agnostic / 已有 harness 原地进化：EvoAgentX 要求把 agent 写进它的 graph；对 alcor-chaos 这种已有自研框架的域，要么移植、要么放弃。我们的 delta 让 M 原地进化已有 harness（改它读的 prompt/工具/seed），不动它的引擎。生产落地门槛低一个量级。
depth-2/3：进化进化器：EvoAgentX 优化器改 workflow/prompt（depth-1），优化器本身是固定算法不进化。我们 M 改 evolver f_D（depth-2），M 自身跨域自进化（depth-3，§26），且封顶防无限递归（D3）。EvoAgentX 即便把 MAP-Elites 套到优化器选择上也是静态组合，不是 M 生成+改+跨域迁移的动态 evolver。
evolver 按域生成 vs 优化器库任选：EvoAgentX 给你 10 个优化器选一个；我们 M 按 domain_features 生成一个域特定 evolver（失败→部件策略表是域定制的），且能沿 skill↔code 谱迁移。固定库 vs 生成器——后者更贴域、可迁移。

21.4 额外创新点（在 EvoAgentX 对照下更显眼）

C1 evolver 作可移植资产：EvoAgentX 的优化器是算法（不可移植）；我们把 evolver 策略表本身做成可版本化、可跨域迁移的资产（MetaMemory 存它）。
C2 spec-distance-gated 迁移：迁移决策由测得的域距离（D4）门控——近域才 warm-start，远域冷启动。EvoAgentX 无域距离概念。
C3 一 M 双产出形态：M 按域有无现成 harness，产出 fresh skill-pack 或 existing-harness delta 两种形态。EvoAgentX 单一形态（自家 graph）。
C4 摊销的元推理：M 学到的"evolver 先验"蒸馏成库，新域 bootstrap 走快路径。EvoAgentX 每 workflow 从零跑完整优化器。
C5 skill↔code 谱 + 学习式晋级：统一 EvoAgentX 的 text/workflow-code 优化器与 MOSS 的 source-level 于一个 meta-controller。EvoAgentX 的 SEW 虽有 code scheme，但恒在其 graph 内、不跨级不跨域。
C6 诚实边界刻画：我们承诺找 M 失败的域/形态，界定方法边界。EvoAgentX 是工具箱，无边界研究。
C7 两级闭环 + 跨域预算流动：域内快循环 + 元慢循环，预算自适应。EvoAgentX 单层 per-workflow 循环。

21.5 大白话（vs EvoAgentX）

EvoAgentX 做了什么：一个巨大的"agent 建造+优化工厂"——你说一句话（goal），它自动拆成多 agent workflow；你有 10 把优化器扳手（GA/DE/MAP-Elites/TextGrad/SEW…）选一把，优化你的 workflow。50+ 工具、12 个 benchmark、完整 HITL GUI、社区。

比方：EvoAgentX 是一个设备齐全的大厨房——有 50 种厨具、10 种烹饪法、12 道考试题、带审批的厨师长，但只能在这个厨房做菜，而且10 种烹饪法本身不会自己变好、不会跨菜系搬家。

重叠：都"自动构造 agent/workflow"+都"用优化器/evolver 改进"+都有"eval"+都有"HITL"。

MEGA 多的（EvoAgentX 完全没有）：

#	MEGA	EvoAgentX	大白话
①	跨域迁移（warm-starter + MetaMemory）	完全无（每 workflow 独立，无"域"概念）	EvoAgentX 是"每道菜从头学"；MEGA 是"川菜学的刀法搬到粤菜"
②	depth-2/3（M 改 evolver + M 自跨域自进化）	depth-1（固定优化器，不进化自己）	EvoAgentX 是"10 把扳手选一把，扳手不变"；MEGA 是"造一把会自己磨快的扳手"
③	安全 D3-D9（hooks+gate，9 轮 reject 证明有效）	零安全门	EvoAgentX 是"跑得通就留"；MEGA 是"跑得通且严格更优才留"
④	substrate-agnostic（Claude Code/Codex/LangGraph/自研）	锁死自家 graph 格式	EvoAgentX 是"必须搬进我们厨房"；MEGA 是"去你家厨房做"
⑤	brownfield 复用（产 delta 到已有 harness）	必须移植进它的格式	EvoAgentX 是"重写你的菜谱"；MEGA 是"给你现有菜谱打补丁"
⑥	eval evolution（judge critique 驱动靶向编辑，§22）	固定 task accuracy	EvoAgentX 是"只看分数"；MEGA 是"看老师评语知道哪里弱→靶向改"
⑦	spec-driven（结构化 Spec_D → bootstrap）	text goal → WorkFlowGenerator	EvoAgentX 是"给一句话猜你要什么"；MEGA 是"给结构化 spec"
⑧	Ralph+git（context reset + 回滚）	单 session 无回滚	EvoAgentX 是"改坏了就改坏了"；MEGA 是"git checkout 自动恢复"
⑨	多智能体 meta 层（7 sub-agent）	单 optimizer	EvoAgentX 是"一个人干所有"；MEGA 是"7 个参谋分工"
⑩	真实硬 benchmark（DeepResearch Bench leaderboard 第 9）	12 个标准 benchmark	EvoAgentX 是"标准化考试"；MEGA 是"PhD 级研究+排行榜可比"

EvoAgentX 比 MEGA 强的（诚实承认）：

#	EvoAgentX	MEGA
A	255 文件 / 70K 行 / 10 优化器 / 12 benchmark / 50 工具	10 文件 / 0 优化器 / 3 stub / 0 工具
B	pip install + Discord/微信/周会/双语文档	研究项目
C	完整 HITL GUI	D9 设计了没实现
D	7 个预建 workflow 示例	domain-template 1 个
E	生产可用	实验阶段

21.6 一句定位（vs EvoAgentX）

EvoAgentX 是"在自家 graph 格式里建+优化 workflow"的生产级框架（255 文件/10 优化器/12 benchmark/50 工具/HITL/社区）——工程量碾压 MEGA。MEGA 是"让进化能力本身可跨域迁移+安全+spec-driven+substrate-agnostic"的研究 thesis（跨域迁移/depth-2-3/安全门 D3-D9/eval evolution/Ralph 回滚/brownfield 复用）——novelty 维度 EvoAgentX 全是空白。不拼工程广度，拼 meta 层 + 跨域 + 安全 + thesis。

21.7 实验上怎么"显式"赢 EvoAgentX

跨域迁移对照：同三域，EvoAgentX 每 workflow 独立优化（无迁移）vs 我们 M 有 MetaMemory warm-start——画收敛速度/token 成本对比，迁移增益是 EvoAgentX 结构上拿不到的数。
substrate generality：在 alcor-chaos（已有 harness）上 EvoAgentX 需移植才能用，我们原地进化——直接展示落地成本差。
evolver 生成 vs 优化器任选：同域，M 生成的 evolver vs EvoAgentX 10 优化器各跑一遍——证 M 按域生成的 evolver 不输任选、且省"选哪个优化器"的人工。
depth-2 增益：去 depth-2（M 不改 evolver）对照——证二阶贡献。
安全 gate 价值：EvoAgentX 无 gate（每个 error-free agent 留下）vs MEGA P2 gate（reject 9/21）——展示 gate 拦下了多少"看着对但实际回归"的编辑。

22. env/eval/verifier 协同进化的必然性 + 信号质量实验

多数自进化工作只让 agent 进化，把 benchmark/verifier/env 当固定外部。我们主张：env/eval/verifier 是必须协同进化的部件（七部件里的 env + eval 两件，M 也改它们），否则进化会触顶 + 信号衰减 + 盲区持续。同时给出不同 verifier 信号质量的实验评估。这正面接住综述"自评估×闭环=危险前沿"——我们让 eval 进化，但不让它改标签，拿到自适应收益又不塌 D7。

22.1 必然性论证：静态 eval 会封死进化

固定 eval 的三个退化（都是可量化、可实验证的）：

天花板（ceiling）：agent 进化到把固定测试集做满后，分数→1、梯度→0，进化无信号可学、停滞。固定 set 越小越早触顶。
覆盖衰减（coverage decay）：agent 变强后，新的失败模式是原 set 没探的——固定 eval 看不见，盲区持续、进化方向跑偏。
信号衰减（signal decay）：固定 verifier 的判分粒度不变，强 agent 间的细微差距它分不出来（都"对"），区分度→0，选择压消失。

⇒ env/eval/verifier 不跟着进化，进化必然在某个点停转——这不是工程偏好，是信息论必然：固定测度对变化系统提供的信息率单调下降。

22.2 与 D7 的调和：区分"固定 benchmark"与"用户的评测方法"

关键区分：公共 benchmark（SWE-bench/Langfuse 评测集/MATH）是固定的——它的 ground-truth 锁死外部、M 不能进化 benchmark 本身（不能改题、不能改标签、不能改覆盖/难度）。但用户的评测方法（verifier 代码/评分 rubric/跑测 harness）可能不完善——verifier 有 bug、rubric 太粗、遗漏了 benchmark 支持但用户没写的检查——M 可以帮进化评测方法（修 verifier bug、补遗漏检查、细化 rubric 以更准反映固定 ground truth），但不发明新标签。

两种 eval 形态，进化范围不同：

eval 形态	benchmark 本身	M 可进化什么	标签
固定公共 benchmark（SWE-bench/Langfuse/MATH）	不动（固定外部，D7 锁死）	用户的评测方法代码（verifier/rubric/harness）——修 bug、补检查、细化以更准反映固定 truth	外部锚定，不发明
活的/生成式 eval（排障 chaos case、域内 case 池）	可扩展（造新 case、升难度 curriculum）	覆盖/难度/case 生成 + 评测方法	inject→validate→recover 等确定性 anchor，仍外部

永不进化：标签/判定来源——答案 ground-truth、代码测试通过与否、集群 inject→validate→recover 结果，始终外部锚定（数据集/真集群/人确认），不由 M/agent 自供。

一句话：对固定 benchmark，M 只进化"怎么测"（评测方法），不碰"测什么"（benchmark 本身）；对活 eval，M 可扩覆盖/难度但不碰标签。 综述点名的危险 cell=“系统改自己’更好’的定义”——我们恰好不碰标签定义，只改评测方法以更准反映固定 truth。

22.3 verifier/eval 信号质量分类（实验维度）

信号类型	可靠性	覆盖	成本	可 game 性	例
exact-match（ground-truth）	高	低（只判对错）	低	几乎不可	数学答案对齐
code-test（deterministic）	高	中	中	不可（除非漏测）	SWE-bench/HumanEval 跑测试
verifier-fn（独立确定性）	高	中	中高	不可（设计好）	排障 inject→validate→recover
LLM-judge	中	高	中	高（judge 偏见/可被 prompt 攻陷）	通用打分
human	高（金标准）	高	极高	低	人确认
hybrid（GT/测试 + LLM-judge 兜底）	高	高	中	中	主信号 GT + judge 补覆盖

信号质量直接 bound 进化天花板：低可靠信号→进化学会 game judge 而非真变强（reward hacking）；低覆盖信号→盲区不收敛；低成本高可靠（exact-match）→早触顶。所以"选/进化哪种 verifier"本身是进化设计变量，不是固定前提。

22.4 实验设计（信号质量 × eval 协同进化）

实验 A：verifier 类型 ablation——同一域、同一 M，换 verifier 跑：

(i) exact-match；(ii) code-test；(iii) LLM-judge；(iv) hybrid；(v) oracle human（小样本金标准）。
度量：进化天花板（曲线触顶点）、reward hacking 率（用 (v) oracle 当 held-out 真值，测 (i)–(iv) 的"进步"有多少是真进步 vs game）、与 oracle 相关性。
预期发现：LLM-judge 天花板"虚高"但 hacking 率高、与 oracle 相关性低；GT/code-test 真但早触顶；hybrid 最优。这把"信号质量→进化可行性"做成可量化结论。

实验 B：eval 协同进化 on/off——同一域、固定 verifier 类型：

off：eval 固定；on：M 周期性扩 held-out + 补失败类 + 升难度（标签仍外部）。
度量：触顶时间、触顶后是否还能爬（off 停、on 继续）、盲区收敛率。
预期：off 早触顶、on 持续爬——坐实"eval 不进化则进化必然停转"的必然性。

实验 C：env curriculum on/off——env 任务分布固定 vs M 生成更难 case（接 chaos-agent 造 case 思路，但严格 train/held-out 隔离）。

度量：进化曲线斜率、泛化到 unseen-difficulty 的表现。
预期：固定 env 早 plateau、curriculum 持续提升 + 泛化更好。

实验 D：verifier 独立性红队——故意让 M 试试"自供一个 verifier"（标签内联），验 safety gate 拒（D7 lint：verifier_module 在 self_evolve、或 inline label pool → 拒）。证明"eval 进化"不会偷偷退化成"eval 自造"。

22.5 差异化（对照）

MOSS：它的"eval"是生产失败 batch，随生产漂移而漂——是incidental eval 漂移，不是deliberate eval 进化 + 信号质量研究；也没研究 verifier 类型对进化的 bound。
Agent-World：合成 env 驱动进化，但没把 verifier 信号质量作变量、没 D7 独立性保护（env 是它造的，标签也它造？需审视）。
EvoAgentX：内置 evaluator 固定，不进化、不研究信号质量。
综述：把"自评估×闭环"当危险前沿；我们给安全形态——eval 进化但标签外锁，把危险 cell 变成可控 cell。

22.6 落到七部件

env 与 eval 是七部件中的两件（§3.1），M 不仅改 prompt/tools/memory/evolver，也改 env 的任务分布 + eval 的形式/覆盖/难度——但eval 的 verifier_module 指向域的独立 verifier，标签外部。这与 D7 一致：进化 eval 的"怎么考"，不进化"答案谁定"。

一句话：agent 进化到一定程度，固定的考卷就考不动它了——必须让考卷（env/eval）也跟着变难变全，但标准答案仍由外人定。 这是进化的必然，不是选项；且不同考卷（verifier 类型）信号质量不同，直接决定进化天花板与作弊风险——我们把它做成可量化实验。

23. 信息不足时主动向用户求取（ask-when-insufficient）

一条贯穿 onboarding / 接 benchmark / 进化全程的行为原则：M 在上下文/信号不足时，主动向用户提问求取足够信息，而不是猜、也不是干等。 这把 HITL 从"被动 checkpoint"变成"信息缺口驱动的主动 elicitation"，且与 D7 天然契合——人就是外部 ground truth，问来的答案 = 外部锚定标签，不是自供。

23.1 原则

M 的自主性是有界的：信号够时自主进化，信号不够时escalate 到人。触发不是固定 cadence，而是信息充分度低于阈值——M 自己判断"这点信息不够我做好的进化决策"，于是发一个结构化、靶向的提问（用 AskUserQuestion 那种多选+自由文本），拿到答案继续。不猜、不糊弄、不卡死。

23.2 何时触发（三类缺口）

onboarding 缺口（§16 Q4）：spec 不全——任务性质/正确性判定/ground-truth 来源没说清 → 问。
接 benchmark 缺口（§16 Q5）：源布局不确定（schema/前两行/字段含义）→ 问，不臆测字段。
进化决策缺口（核心，新）：
- 失败分类歧义：verifier reason 落在 wrong_answer 还是 case_ambiguous 分不清 → 问"这是工具缺还是题面歧义？"（决定改 tools 还是改 eval）。
- verifier 分不开：两个候选 agent 强弱 verifier 判不出 → 问人哪个真更好（人当 oracle）。
- 新 case 缺标签：M 想扩 held-out（§22 eval 协同进化）但新 case 没 ground-truth → 问人确认答案（人 = 外部标签）。
- 进化方向分歧：多个改法都合理、信号不足以排序 → 问人优先级。

23.3 与 D7 的契合：问 = 外部取标签，不是自供

关键：人答的就是外部 ground truth。当自动 verifier 信号不足（覆盖低/LLM-judge 可 game/新 case 无标签），M 不去自造标签（那是 reward hacking），而是问人——人确认的答案进 verifier 当外部锚定，D7 不破。一句话：信号不足时，问人取外部标签，比让 M 猜或自评安全得多。 这把"信息缺口"从"reward hacking 温床"变成"主动 elicitation 入口"。

23.4 vs 被动 HITL（对照 EvoAgentX）

EvoAgentX 的 HITL 是checkpoint 式被动（固定点请人 review）。我们是信息缺口驱动主动：M 自己判充分度、发靶向提问、拿了答案继续。区别：① 何时问——由信号充分度定，非固定 cadence；② 问什么——靶向具体缺口（多选/约束），非泛泛"请 review"；③ 问完即用——答案直接进 verifier/spec 当外部信号，非旁路记录。

23.5 约束：问率必须有界

风险：问太多 = 烦 + 贵 + 退化成纯人驱动。所以问率必须 bounded：只在 (a) 自动信号不足且 (b) 决策高 stakes（错方向会带偏进化）时问；低 stakes 缺口用默认/随机+验证兜。把"问"当稀缺资源，按信息增益排序问。这是有界自主：自主在信号够处，escalate 在信号缺且高 stakes 处。

23.6 实验

问率 vs 信号充分度：画"自动信号覆盖率↓ → 问率↑"曲线，验 M 在该问时问、不该问时不烦。
问 vs 猜：同缺口场景，M 问人 vs M 猜，比进化曲线 + reward-hacking 率——问显著少走弯路、少 game。
问率上界：加 ask-budget 消融，证 bounded ask 比无界 ask 更省且不损质量。

一句话：M 信号够就自己干，信号不够且 stakes 高就主动问人——而人答的就是外部 ground truth，所以"问"不是偷懒、不是作弊，是 D7 合规的取标方式。 这把 HITL 从被动 checkpoint 升级成信息缺口驱动的主动 elicitation，正好补上 §22"eval 信号不足"那条路的 D7-safe 出口。

24. 对照"经验与技能积累 skills"一类工作的差异化

该类工作（EvoSkill / AutoSkill / EmbodiSkill / Trace2Skill / SkillOpt / SkillLens）共性：冻结底模、只进化 skill 文件（SKILL.md/脚本）、单 agent 单域、evolver 是固定角色（proposer/optimizer）、eval 固定外部。它们是综述里"bounded self-refinement"的典型——工程落地最易，但天花板也最明显。对照它们我们的差异化：

24.1 七个差异化优势

进化对象更宽（A1）：它们只进化 skill 文件（七部件之一）。我们进化整个域级 agent 七部件（prompt/env/memory/tools/eval/evolver/harness-config）+ evolver 本身。skill 只是其中一维，它们在一维里深挖，我们在七维上 + depth-2。
跨域迁移 evolver（A2，核心，结构性）：它们的 skill bank 是域本地的——EvoSkill/AutoSkill/Trace2Skill 各自在一个 agent 的失败轨迹上积累，没有"在 A 域学到的进化方法搬到 B 域"这个概念，结构上也没有跨实例状态共享。我们 MetaMemory + held-out 域迁移（N1）——这是它们结构上做不到的：skill 是域内 artifact，evolver-pattern 才是可跨域的，而它们没有"evolver-pattern"这一层。
depth-2：进化进化器（A3）：它们的 proposer/optimizer 是固定角色——EvoSkill 的 Skill-Builder 用一个"元技能"自举，但那元技能是固定的 skill-写作最佳实践、不进化、不跨域；SkillOpt 有"meta skill"但训练时给 optimizer 用、不部署、不跨域。我们 M 进化 evolver f_D 且部署且跨域迁移（depth-2）。它们最多 depth-1 + 一个 frozen 元技能，我们 depth-2 + 迁移。
env/eval/verifier 协同进化（A4，§22）：它们全部把 eval 当固定外部（任务成败/验证集 split）。SkillOpt 的 validation gate 用固定 selection split。我们主张 eval/env/verifier 必须协同进化（静态 eval 必触顶，§22）——这是它们完全没碰的一层。
substrate-agnostic（A5）：EvoSkill 明确"假设支持 skill 文件夹的工具链（Claude Code/Codex/OpenCode）"——锁在 skill-folder 约定。我们复用任意宿主 harness：Claude Code skill-pack / 已有 harness delta（alcor-chaos）/ code（§16 Q6）。它们单形态（skill folder），我们多形态。
元层安全姿态（A6）：SkillOpt 的 validation gate + rejected-edit buffer 是per-skill 级的好设计（该采纳，见 24.2），但只管"candidate 是否 beats current"。我们的安全在元层：D7（verifier 标签外部锚定，禁自供——防 eval 协同进化时偷改标签）、D8（跨域迁移不引入安全退化）、D9（信息不足问人=外部取标）。它们的安全是 skill 接受/拒绝，我们的是跨域迁移 + eval 进化 + 信息缺口三处的安全。
principled 迁移（A7，被 SkillLens 反向 motivate）：SkillLens 发现 model-generated skill 有不可忽视的负迁移——这正是盲迁移的风险。我们的 D4（域距离）+ distance-gated warm-start + held-out 协议直接回应：只在域近时迁移、远域冷启动、迁移增益作 f(域距离) 可测。SkillLens 点出负迁移却没给跨域 principled 解法；我们给。 这把我们和它们从"都做迁移"分开：它们报风险，我们给 distance-gated 解。

24.2 提升为 native 设计原则（与框架不矛盾，故立为我们自己的准则）

下面几条来自 skills 类工作，但与我们的两级闭环/七部件/安全 gate 都不矛盾，所以不当作"借用"，而提升为我们自己的设计原则——它们恰好填补域内循环与 evolver 接受机制该有却没写清的准则。两级闭环也因此有了对称的"批量-归纳"结构：域内快循环 batch traces→统一进化；元慢循环 batch 域→统一迁移。

P1 批量交互再统一进化（域内循环准则，自 Trace2Skill）：域内（快）evolver 不逐条 trace 在线改，而是先批量与环境交互产出一组 trace（含成功+失败）+ 结果，再统一归纳成一次 skill/策略 delta。理由（Trace2Skill 已证）：逐条在线改→碎片化、过拟合偶然错误、改序敏感；批量归纳→抗噪、不误伤已对 skill、可迁移。这正填上我们 domain-level loop 没写清的运行准则——inner loop = batch traces → consolidate，与 outer loop 的"batch 域 → 迁移"对称。
P2 严格更优才接受（evolver 接受准则，自 SkillOpt validation gate）：evolver 产出的 candidate（agent/evolver）必须在 held-out selection split 上严格优于当前才接受，否则拒绝；不只在安全门（D3/D7/D8）上过。这是把我们的 safety gate 从"合规门"升级成"合规 + 严格更优门"。被拒 candidate 不丢，进 rejected buffer 供下次 evolver 参考（负反馈记忆）。承认 SkillOpt 这处比我们当前严，立为原则补上。
P3 有界编辑（自 SkillOpt textual learning rate）：evolver 每步最多应用 $L_t$ 条 add/delete/replace，按预期收益排序截 top- $L_t$ ——防大幅改写、防语义跳跃、防"改完分不清是哪条带来提升/退化"。这与 EvolverAsSkill 的"按策略表改部件 + 版本递增"本就同向，立为每次进化步的有界编辑准则。
P4 evidence-type 粒度的失败分类（自 EmbodiSkill）：Verdict.reason 不止"wrong_answer/tool_missing"等粗类，而按轨迹对当前 skill 的证据类型细分（new knowledge / optimization signal / skill defect / execution lapse），喂给 evolver 策略表更精准的"改哪件 + 怎么改"。立为失败归因粒度准则，与 §22 的 eval 信号质量分类配套。

这四条与我们的设计自洽：P1 是域内循环准则（补 inner loop 写法）、P2/P3 是 evolver 接受/步长准则（升级 safety gate）、P4 是失败归因粒度（喂策略表）。不矛盾故提升为原则，而非外挂——它们让"批量-归纳"对称贯穿两级闭环，并补上我们 gate 该严而未严的"严格更优"。

24.3 故事对照

它们 = bounded self-refinement（综述的 bounded cell）：冻结底模 + skill 文件 + 单域 + 固定 evolver + 固定 eval。工程易落地，但天花板=skill 这一层、域=单个、深度=1。
我们 = meta self-evolution + 跨域迁移 + 有界开放式 RSI（§19）：进化对象=七部件+evolver、域=跨、深度=2、eval 协同进化、迁移 distance-gated。不在它们那格，是再上一层。

24.4 一句定位

它们让一个冻结 agent 在一个域里攒 skill 文件（bounded、depth-1、单域、固定 evolver/eval、锁 skill-folder 工具链）；我们让进化能力本身可生成、可二阶进化、可跨域迁移、eval 协同进化（meta、depth-2、跨域、evolver 按域生成+迁移、substrate-agnostic）。它们是"攒经验"，我们是"让攒经验的方法自己长进并搬家"。 它们里不矛盾的精华（Trace2Skill 批量归纳 / SkillOpt 严格更优门+有界编辑 / EmbodiSkill evidence-type）我们提升为 P1–P4 native 原则——尤其 P1"批量交互→统一进化"作为域内循环准则，与元层"批量域→迁移"对称。

25. 工程贡献：framework-agnostic + stage-agnostic 的通用进化层

第 10 条 contribution 的展开。这是面向所有 agent 开发者的实用主张，最大化影响力：你不挑框架、不分阶段，都能用本框架进化你的 agent。关键定位——我们不是又一个 agent runtime（EvoAgentX/LangGraph/AutoGen 都是 runtime，要你迁就它），而是凌驾于任意 runtime 之上的 meta 进化层。

25.1 framework-agnostic：任意框架

M 不要求把 agent 搬进我们的 runtime。它产出该框架能消费的产物形态，靠一个薄 harness adapter 切形状：

框架	M 产出形态	跑 agent 的方式
Claude Code	skill-pack（agent.json+SKILL.md+tools/）	`claude -p` headless（`ClaudeSolver`）
Codex	codex tool/skill 形态	codex headless
LangGraph	graph 节点+prompt 的 delta	跑该 graph
AutoGen	agent 定义 delta	跑其 runtime
自研（alcor-chaos 等）	该 harness 配置面的 delta（prompt 文件/工具注册/seed）	`HarnessSolver` shell 到它的 entrypoint

恒定的是 M + glue（spec 协议/verifier/safety gate/meta-memory），变的是产物形状随框架。一条 SolverBackend 抽象（ClaudeSolver/HarnessSolver/未来各框架 solver）把"跑 agent"和"判 agent"解耦——runtime 不限。

D5 诚实边界：要求框架暴露 ≥1 可进化缝隙（prompt/config/memory/tool-def/eval）——所有主流框架都满足（Claude Code 有 skills/prompts/hooks；Codex 同；LangGraph 有 nodes/prompts/memory；AutoGen 有 agent configs）。全封闭零缝隙框架→M 诚实拒（§16 Q6）。

25.2 stage-agnostic：开发前 / 开发中

开发前（greenfield）：dev 只有一句想法 → M 跑 onboarding 访谈（§16 Q4）→ 起草 Spec_D → 从零 bootstrap 一个自进化 agent（A_D^(0)）。“从一句话到会自进化的 agent”。
开发中（brownfield）：dev 已有 agent（任意框架写的）→ M 走"进化已有 harness"（§16 Q6）：勘察可改缝隙 + run entrypoint → 产 delta（改它读的 prompt/工具/seed）→ HarnessSolver 跑它 → verify/gate 闭环。“原地进化你已经有的 agent”，不重写、不移植。

两阶段共用同一 M + 同一闭环；差别只是产物形态（fresh skill-pack vs delta）和 solver（ClaudeSolver vs HarnessSolver）。

25.3 为什么这能成立（不矛盾的设计）

我们不持 runtime：EvoAgentX/LangGraph/AutoGen 是 runtime，agent 活在它们里；我们是 meta 层，agent 活在你的 runtime 里，我们只产"喂给它/改它"的东西。所以"凌驾任意 runtime"成立。
产物形态可切：七部件里的 harness_config 就是"该框架配置面清单"，M 按框架填它——这是 substrate-agnostic 的工程落点（§3）。
D7 不破：无论哪个框架/阶段，verifier 仍是域的独立 verifier（标签外部）——框架换成 LangGraph 不影响 verifier 独立性。

25.4 影响力主张

用户基数最大化：每个 agent 开发者（Claude Code/Codex/LangGraph/AutoGen/自研）都是潜在用户，不是只有"愿意迁就我们 runtime"的人。
开发阶段全覆盖：从"还没开始"到"已上线一半"都能介入——不是只在 greenfield 或只在 brownfield。
落地门槛最低：不要求换框架/重写 agent/移植进我们的 graph——就着你已有的东西进化。这是相对 EvoAgentX（必须进它的 graph）最大的实用优势。
与 thesis 互支撑：framework-agnostic 不是和 §19 thesis 并列的两件事——正因为"不持 runtime、只产适配形态"，跨域迁移（N1）才有意义（M 的 evolver-pattern 是 runtime-中立的，才能跨框架/跨域搬）。

25.5 一句定位

MEGA（元神）不是又一个 agent 框架，而是任何 agent 框架之上的一层"进化能力"——不管你用 Claude Code、Codex、LangGraph 还是自研，也不管你是从零开始还是已有 agent 半成品，接上这层就能让它自进化。框架由你选、阶段由你定，进化归 MEGA 管。

26. M 自身也在进化：跨域迁移即 M 的自我进化

一个关键且常被忽略的点：MEGA 不是冻结的造物器，它自身就是个自进化 agent——其自我进化发生在知识/迁移层（跨域积累 + 可迁移先验），而非代码层。这让"meta"名副其实：不只 A_D 在进化、不只 evolver 在进化，M 也在进化。

26.1 跨域迁移 = M 的自我进化

元闭环里"M 的元知识跨域迁移"看起来像"知识搬运"，但它本质是 M 的自我进化：M 处理域 A 时把"如何造 evolver"的经验沉淀进 MetaMemory；处理域 B 时检索、复用、修正这些先验——M 的产出策略随跨域经验而变好。这不是静态查表，是 M 的行为/先验随经验更新，即自我进化。形式化见 §2 的 $M^{(t+1)}=\text{MetaUpdate}(\ldots)$ 。

一句话："M 能跨域迁移"不是 M 的一个功能，是 M 在自我进化的表征。

26.2 这是"有界"的自进化（不塌成 open-ended RSI 的危险）

综述点名 open-ended RSI 两大死结：① 改自己评估器→reward hacking；② 无限递归→崩溃。M 的自进化恰好绕开两者：

不动评估器：M 自进化只更新元先验/策略，verifier 标签始终外部锚定（D7）——M 不会"改自己打分标准"作弊。
不动代码结构：M 的代码骨架封顶（D3 基元），进化的只是知识层；L3 不再上溯"更新元先验的机制"——不无限套娃。
开放在域数：M 的知识随处理越多域而越积累、越迁移越好——水平开放（域无界）+ 垂直有界（代码/评估器锁），正是 §19.1 的有界开放式 RSI，现在落到 M 自身。

26.3 三层进化阶梯（递进、各有界）

层	进化对象	速度	有界方式
L1 域内	$A_\mathcal{D}$ 的部件（prompt/tools/memory）	最快	域内、verifier 外锚
L2 元层	$f_\mathcal{D}$ （evolver，M 改它）	中	depth-2、不超 evolver
L3 M 自身	M 的元先验/策略（跨域积累+迁移）	慢	知识层非代码层、代码封顶 D3、评估器外锁 D7

L3 是 M 的自我进化层——这让 MEGA 不只是"进化别人的造物器"，而是"自己也会进化的造物器"，且以安全（有界）方式自进化。

26.4 对 novelty 与故事的影响

N2（二阶/有界开放式 RSI）更扎实：原 N2 说"M 改 evolver（depth-2）“；现补"M 自身在知识层自进化（L3）”——三层进化阶梯，比单纯 depth-2 更完整、更名副其实（"Meta-Evolution"不只是进化 evolver，连 M 自己也在 meta-evolve）。
与 §19 故事呼应：§19.5 收尾句"evolves the evolver itself"可扩成"evolves the evolver, and itself evolves across domains through transferable priors"——M 既是进化者，也是被进化者（在知识层）。
实验启示：M 的自进化可测——跨域越多，M 在新域的 bootstrap 收敛越快（迁移增益随 M 处理域数增长）→ 这本身就是"M 在自进化"的可证伪证据（与 §6.2 子主张 2 跨域迁移增益合一）。

一句话：M 能跨域迁移，本质是 M 在自我进化——只是它进化的是知识/先验层（域越多越会造），不是代码或评估器，所以安全、有界、可证伪。MEGA 因此是个"自己也会进化的造物器"。

27. Ralph Loop 作为执行基底 + MEGA 补其三短板

Ralph Loop（Geoffrey Huntley, 2025）= 极简自主执行环：Bash 脚本无限循环，每轮读 todo 文件→做一个原子任务→测试通过则提交+更新 todo→进程退出、脚本重启全新上下文（状态全持久化在文件+VCS）→直到任务清空。核心纪律：文件存状态（非对话记忆）、每轮上下文重置、一次一个原子任务、todo 驱动、测试/提交背压，更新 CLAUDE.md/AGENTS.md 作知识积累。它和 MEGA 同属长程自主范畴。

27.1 引入它，但作"执行基底"而非 novelty

按 §3"首要贡献=概念+形式化"，Ralph 是执行模式不当 novelty 抬高。引入它是硬需求：MEGA 要"AFK 跑数小时/天"的长程自主进化，不解决上下文腐烂（context rot / Dumb Zone）就跑不动——Ralph 的"文件存状态 + 每轮重置上下文 + 一次一原子任务"正是这个工程解。它作 MEGA 两层循环的执行基底：

L1 域 agent 跑任务（尤其长程：SWE-bench 代码、排障多步诊断）：Ralph 式——状态在文件、每子任务重置、todo 驱动。
L2/L3 元闭环（MEGA verify→Edit→gate 跑多轮）：同样 Ralph 式——meta todo 文件 + 每轮重置上下文 + 文件持久化 MetaMemory，使元循环能 AFK 长跑。

27.2 MEGA 补 Ralph 报告自己点名的三块短板（borrow-and-lift，强故事）

Ralph 报告的局限 vs MEGA 已有设计一一对应——Ralph 社区 future-work 要的，MEGA 已经是：

Ralph 短板（报告点名）	MEGA 已有怎么补
过度依赖测试做背压（测试错/不全→问题累积）	D7 独立 verifier（标签外部锚定，不只信测试）+ §22 eval 协同进化——换掉 Ralph 弱信号
`--dangerously-skip-permissions` 安全/治理风险（报告要"Principal Skinner"基础设施层治理）	safety gate D3/D7/D8/D9 = 报告要的基础设施层确定性约束+实时治理（非 prompt 写安全指令）
缺全局优化 + 局部最优 fixation（报告 future-work 要叠"元认知监督 agent"）	MEGA 元层 L2/L3（M 改 evolver + M 自身跨域自进化）= 报告要的元认知监督，且跨域

一句话：Ralph 是内层执行环，MEGA 是它上面补齐三短板的 meta 层——Ralph 报告自己列的 future-work（基础设施治理 + 元认知监督）正好是 MEGA 已有设计。这不只是"引入 Ralph"，是"MEGA = Ralph 执行环 + 原则化信号(D7) + 安全 gate + 全局 meta 优化"。

27.3 Ralph 的 CLAUDE.md/AGENTS.md 持久化 = MEGA 宿主原生记忆层

报告说 Ralph 每轮更新 CLAUDE.md/AGENTS.md 作知识积累与"一定程度的自我进化"——这正是 MEGA §3 的"产出走宿主原生配置"。所以 Ralph 的知识文件持久化 = MEGA 的 MetaMemory + 域 agent memory 的宿主原生实现，不是新概念；MEGA 把 Ralph 的"CLAUDE.md 当 scratch memory"升级为"带跨域迁移的 MetaMemory"（§26：M 自进化在知识层）。

27.4 执行纪律提升为 native 原则（P5，接 §24.2）

Ralph 的循环纪律与 MEGA 不矛盾，提升为 P5 执行原则（接 P1–P4）：

P5a 文件存状态、非对话记忆：所有跨迭代状态（todo/进度/MetaMemory/agent config）持久化文件，不靠 context。
P5b 每迭代上下文重置：每个原子任务/元迭代结束进程重启、全新上下文——防 context rot，长程不降质。
P5c 一次一原子任务：todo 驱动、每轮一个原子单位、做完提交+更新 todo。
P5d 确定性背压：测试/verifier 通过才提交（Ralph 用测试，MEGA 用 D7 独立 verifier——更原则）。

P5 不当 novelty，是 MEGA 长程执行的工程准则。

27.5 一句定位

Ralph Loop 是 MEGA 的内层执行环（让长程自主跑得动、不 context rot）；MEGA 在其上补齐 Ralph 报告自己点名的三块短板——原则化信号(D7)、安全 gate(D3-D9)、全局 meta 优化(L2/L3)——并把它宿主原生的 CLAUDE.md/AGENTS.md 知识层升级为可跨域迁移的 MetaMemory。 Ralph = 怎么跑；MEGA = 怎么跑得对、跑得安全、跑得越跑越好。

28. 环境版本控制与执行可逆性

当前盲区：gate 拒绝后怎么回滚？verify 跑域 agent 时环境被改了怎么恢复？进化历史怎么存？Ralph loop 每轮重置上下文后 M 不记得改了什么——不能靠 M 的记忆回滚。解法：git 做版本控制+回滚，git worktree/Docker 做执行隔离。

28.1 Agent 配置回滚：git in `_pack/`（必做，轻量）

_pack/（agent.json + CLAUDE.md + skills + tools）本身是一个 git 仓库（或主仓库的 tracked 子目录）：

gate 接受：git add -A && git commit -m "v<N> accepted: <reason>"。这一版成为新的"已知好版本"。
gate 拒绝：git checkout .（或 git reset --hard HEAD）→ 自动回滚到上一个 accepted commit。M 不需要记住改了什么——git 替它记。
进化历史：git log = agent 的完整版本历史，每个 accepted 版本一个 commit，可 diff 看每版改了什么。这是论文 artifact 的一部分（可审计、可复现）。

与 Ralph loop 兼容：mega_loop.sh 每轮 claude -p 退出后，根据 gate 结果自动 commit 或 checkout——不依赖 M 的上下文记忆。

28.2 执行环境隔离：tiered（verify 跑域 agent 时）

域 agent 在 verify 时可能 改文件 / 装包 / 跑系统命令（如 SWE-bench agent 改代码、排障 agent 操作集群）。这些副作用不应污染宿主环境。分三档：

档	机制	适用	代价
none	不隔离	只读域（数学：agent 只解题不改文件）	零
worktree	`git worktree add /tmp/mega_verify_<ts>`，域 agent 在 worktree 跑，完后 `git worktree remove`	改文件但不装包（代码 agent、文档 agent）	轻（秒级）
docker	临时容器（如 MOSS ephemeral workers），跑完丢弃	改系统/装包（SWE-bench、排障真集群）	重（分钟级）

verify CLI 加 --isolation none|worktree|docker 标志，M 按域性质选。默认 none（数学等只读域），代码/排障域用 worktree 或 docker。

28.3 固定 benchmark 的 pristine 保证

公共 benchmark（SWE-bench/Langfuse）本身是固定 git 仓库——域 agent 在 worktree/clone 里跑，改的是 clone 不是原 benchmark。verify 后 clone 丢弃 → benchmark pristine。这是 SWE-bench 官方 eval 的做法（每题一个 fresh Docker container + repo checkout），我们沿用。

28.4 mega_loop.sh 的 git 逻辑

# 每轮 claude -p 退出后：
if gate 结果 = accept; then
  git -C "$PACK_DIR" add -A
  git -C "$PACK_DIR" commit -m "v$(cat iter) accepted: $(reason)"
else
  git -C "$PACK_DIR" checkout .    # 自动回滚
  echo "rejected, rolled back"
fi

M（短循环 in-session）同理：SKILL.md 告诉 M “accept → git commit；reject → git checkout .”。

28.5 与现有设计的关系

D8 安全不退化：gate 拒绝后 git checkout = 确定性回滚，不靠 M 记忆——这是 D8 的基础设施层落地（不只 gate 返回 reject，还有 git 物理恢复）。
Ralph Loop（§27 P5）：git 天然是 Ralph 的"文件存状态"——每轮 commit = 一个可恢复 checkpoint。
MOSS 对照：MOSS 已有"in-place container swap + health-probe rollback"（§7），我们的 git worktree + commit/checkout 是更轻的等价物（不需 Docker 级 swap，只需 git 级回滚）。
可审计可复现：git log = 完整进化历史，论文可附（每版改了什么、为什么、gate 结果）。

一句话：git 是 MEGA 的"undo + snapshot + history"——gate 接受就 commit、拒绝就 checkout、verify 跑在 worktree/docker 不污染宿主、git log 是进化历史。不靠 M 的记忆，靠 git 的确定性。

29. 多智能体架构（7 sub-agents + 2 确定性工具 + hooks 底线）

原设计把推理塞在 M 一个会话里（或 Python 类里）。重构后：所有推理拆成 sub-agent，所有确定性检查是 agent 调的工具，hooks 是底线。M 只做编排——Claude 是指挥官，sub-agent 是参谋，Python 是确定性仪器。

29.1 架构全图

M（编排者）——只调度 sub-agent + 调确定性工具
  │
  ├── Phase 0: 起飞检查（并行）
  │   ├─► env-assessor      "环境能跑？可进化(D5)？sandbox？batch？trace(P6)？"
  │   ├─► eval-architect    "eval 公正(D7)？信号够？不够→造一个（代码测试/exact-match/LLM-judge/cluster）"
  │   └─► seam-surveyor     "(brownfield)现有 harness 暴露哪些缝隙？"
  │
  ├── Phase 1: Bootstrap
  │   ├─► warm-starter      "读 MetaMemory→近邻域→建议策略+prompt+工具"  (替代 memory.py)
  │   └─► bootstrap-builder "写 agent.json + CLAUDE.md + skills/deltas"
  │
  ├── Phase 2: 进化循环（N 轮）
  │   ├─► Bash: verify       ← 确定性工具（D7 独立判分+全 trace）
  │   ├─► evolution-analyst  "读 signals+traces→edit plan（部件+改法+rationale）"  (替代 evolver.py)
  │   ├─► M: Edit per plan
  │   ├─► Bash: gate         ← 确定性工具（D3/D8 安全门）
  │   └─► git commit/checkout（§28 回滚）
  │
  └── Phase 3: 知识提取
      ├─► generality-checker "prior 够跨域？PASS/FAIL+改写"  (已有)
      └─► M: 写 MetaMemory（L3 自进化）

29.2 七个 sub-agent

#	sub-agent	阶段	输入	输出	替代的旧代码
1	env-assessor	0	domain 目录	env_report.md（就绪+gap+可进化性）	新
2	eval-architect	0	domain+spec+用户 benchmark	verifier.py+benchmark.py+eval_report.md	新（你说的"造公正 eval"）
3	seam-surveyor	0(brownfield)	现有 harness 源码	seam_map.md（缝隙+entrypoint）	新
4	warm-starter	1	MetaMemory 文件+新域特征	warm_start.json（策略+prompt+工具）	替代 `memory.py`
5	bootstrap-builder	1	spec+Phase0 报告+warm_start	agent.json+CLAUDE.md+skills	新
6	evolution-analyst	2(每轮)	EvalSignals+traces	edit_plan.json（部件+改法+rationale, ≤4 edits）	替代 `evolver.py`
7	generality-checker	3	提取的 prior	PASS/FAIL+改写建议	已有 ✅

29.3 两个确定性工具（agent 调用，不是独立系统）

工具	谁调	为什么必须是代码
verify	M(Bash)	D7：跑+判分必须确定性+独立（agent 不能自判=reward hacking）
gate	M(Bash)	D3/D8：安全门必须基础设施层（不是 LLM 判断）

29.4 hooks（harness 强制，agent 不能绕）

D3（禁写 self_evolve/）+ D8（禁危险 Bash）——.claude/settings.json PreToolUse 自动拦截，agent 甚至不知道它存在。这是"Principal Skinner"底线。

29.5 eval-architect 的核心设计（“造公正 eval”）

eval-architect 接到 domain →
  ├── 用户有 benchmark（SWE-bench/Langfuse/MATH）？
  │   → 写 adapter（runtime load label，不 inline，D7 独立检查）
  ├── 用户没有？
  │   → 造公正 eval：
  │     (a) 代码域 → pytest/unittest（标签=测试通过/失败）
  │     (b) 数学域 → exact-match（标签=数据集 ground-truth）
  │     (c) 文本/研究域 → 外部 LLM-as-judge+rubric（judge≠agent 模型/session）
  │     (d) 排障域 → inject→validate→recover 真集群
  ├── 造不了（无 ground truth 来源）？
  │   → 报告→M 触发 D9 问用户（人=外部 ground truth，D7-safe）
  │   → 连人都没有→D5 拒绝
  └── eval 方法可进化？
      → 固定 benchmark：只进化方法（verifier code/rubric），不进化 truth
      → 活 eval：可扩覆盖/难度，标签仍 D7 外部

29.6 Python 从 11 → 10（删 evolver.py + memory.py，加 signals.py）

留（确定性基底）	删
spec.py（schema）	~~evolver.py~~（→ evolution-analyst sub-agent）
solver.py（Mock/ClaudeSolver）	~~memory.py~~（→ warm-starter sub-agent 读 memory 文件）
domain_runtime.py（verify 核心）
verifier.py（D7 契约）
safety.py（gate D3/D7/D8）
hooks.py（PreToolUse）
signals.py（EvalSignals+FailureSummary+DEFAULT_STRATEGY_TABLE，新建）
harness_adapter.py（fallback_agent+write_agent_json）
cli.py（verify/gate/pack）

一句话：所有推理在 sub-agent（7 个），所有确定性检查在 agent 调的工具（verify/gate，2 个），所有物理拦截在 hooks（D3/D8）。M 只编排。 Claude 是指挥官，sub-agent 是参谋，Python 是仪器。

附录 A：alcor-chaos 现有 evolver 复盘（作为 spec 协议实例来源）

alcor-chaos 的 eval-improve 已实现一个手工 evolver，其结构可作为" $M$ 应自动产出什么"的参照：

失败 case 输入 ──► 根因分类(工具缺失/被干扰/题面歧义/prompt不足/case无效)
                ──► 改部件映射:
                       工具缺失 → 改 MCP 工具仓库(加工具如 gpu_inspect)
                       prompt不足 → 改 langfuse 托管 prompt(强化排查顺序/排除干扰)
                       题面歧义 → 改 case seed 题面/troubleshoot_path
                       case无效 → 删/换 case (case-dedup)
                ──► 重跑验证(langfuse-trace 收 score + 工具序列)

这个"分类→改部件→重跑"的三段式，正是综述里 f 的工程实例。 $M$ 要做的就是把这种"人写的失败分类表 + 改部件映射"自动化生成（按 spec 产出），并跨域复用这个三段式骨架、替换域特定内容。

文档状态：v0.8 构想。论文定名 MEGA（Meta-Evolution Genesis Agent / 元神）—— A Spec-Driven Framework for Bootstrapping Cross-Domain Self-Evolving Agents。 缩写 M-E-G-A（Meta-Evolution 命名 depth-2、Genesis 命名 bootstrap、Agent=M）；元神作系统昵称。

§3：首要贡献=概念+形式化；产出走宿主原生配置（CLAUDE.md/AGENTS.md+skills/delta/code），我们只提供薄/统一适配框架便于复现、不局限 harness、与标题"Framework"相符；evolver 分 skill/code 两形式。

§7：已读综述 RSI + MOSS + HiSME（depth-2 最近邻）+ EvoAgentX（工程最完整）+ ADAS（ICLR 2025，最危险竞品——已验证跨域+跨模型迁移）；存活 novelty 收为两条——N1 跨域元自进化 + N2 二阶/有界开放式 RSI。HiSME 的 depth-2 / ADAS 的跨域迁移不是我们 novelty（差异见 §7.3/§7.4）。

§12–§14：10 创新点 + 9 优化 + 10 不足→方案。

§15–§16：P0/P1 落地 + 设计问答。

§17：首个真实域实验——排障域自进化 8 失败→仅 1 失败、65%→≈96%（evolver 首个正面证据）。

§18：后续建议。

§19：更大的故事——二阶自进化 + 有界开放式 RSI（综述 open 问题的 tractable 第三路）+ skill↔code 谱论 + 跨域迁移独占位。

§20：更 solid 的实验矩阵（+§20.6b 借鉴 HiSME 的实验设计：static ablation/跨域 meta-test/process curve/组件消融/token cost/case study/3 runs）——三域×三 baseline、held-out 迁移、消融、substrate generality、安全红队。

§21：对照 EvoAgentX 的差异化（不拼工程广度，拼 thesis/跨域/substrate/depth-2/safety）+ 7 额外创新点。

§22：env/eval/verifier 协同进化的必然性——静态 eval 必触顶/信号衰减/盲区持续（信息论必然）；区分固定 benchmark（SWE-bench/Langfuse，M 不碰 benchmark 只进化用户的评测方法代码）vs 活 eval（可扩覆盖/难度，标签仍 D7 外部）；verifier 信号质量分类 + 4 实验。

§23：信息不足时主动问用户（ask-when-insufficient）——信号够自主、不够且高 stakes 就靶向提问；人答=外部 ground truth（问= D7 合规取标，非自供）；vs 被动 HITL；问率有界。skill 已落 D9 规则。

§24：对照"经验与技能积累 skills"类——7 差异化优势；不矛盾的精华提升为 P1–P4 native 原则（P1 批量交互→统一进化=域内循环准则、P2 严格更优才接受、P3 有界编辑、P4 evidence-type 粒度）。

§25：工程贡献：framework-agnostic + stage-agnostic 通用进化层——不是又一个 runtime（vs EvoAgentX/LangGraph/AutoGen），而是任意 runtime 之上的 meta 层；任意框架（Claude Code/Codex/LangGraph/AutoGen/自研）×任意阶段（开发前 bootstrap/开发中原地进化）；最大化用户基数与落地性。

§26：M 自身也在进化——跨域迁移即 M 的自我进化（在知识/先验层，非代码层）；三层进化阶梯 L1 域部件→L2 evolver→L3 M 元先验；有界（代码/评估器锁 D3/D7，L3 不上溯）；N2 更扎实；可证伪（跨域越多→新域 bootstrap 越快）。D3 重述为"代码层固定、知识层自进化"。

§27：Ralph Loop 作执行基底——文件存状态+每轮上下文重置+一原子任务+确定性背压，是 MEGA 长程自主跑得动的工程基底（非 novelty）；MEGA 补 Ralph 报告自己点名的三短板（D7 原则化信号/安全 gate/全局 meta 优化），CLAUDE.md 知识层升级为可迁移 MetaMemory；纪律提升为 P5 原则。

§28：环境版本控制与执行可逆性——git in _pack/ 做 agent 配置回滚（accept→commit、reject→checkout）；执行隔离 tiered（none/worktree/docker）；mega_loop.sh 内置 git。

§29：多智能体架构——7 sub-agent（env-assessor/eval-architect/seam-surveyor/warm-starter/bootstrap-builder/evolution-analyst/generality-checker）+2 确定性工具（verify/gate）+hooks 底线；删 evolver.py+memory.py→sub-agent 替代；eval-architect 造公正 eval；4 阶段编排。——git in _pack/ 做 agent 配置回滚（accept→commit、reject→checkout，不靠 M 记忆靠 git）；执行隔离 tiered（none/worktree/docker，verify --isolation）；固定 benchmark pristine（worktree/clone 丢弃）；mega_loop.sh 内置 git commit/checkout。——文件存状态+每轮上下文重置+一原子任务+确定性背压，是 MEGA 长程自主跑得动的工程基底（非 novelty）；MEGA 补 Ralph 报告自己点名的三短板（D7 原则化信号/安全 gate/全局 meta 优化），CLAUDE.md 知识层升级为可迁移 MetaMemory；纪律提升为 P5 原则。
实现进 self-evolve 仓库。evolver 主张=经验上有效（不与人写 evolver 比优劣）。仍需补：精读 #4/#6/MOSS/EvoAgentX/skills 类全文（D1）、上真 MATH/GSM8K、MEGA 自动驱动复现 8→1（证有效）、三域曲线、held-out 域迁移、EvoAgentX 对照、§22 信号质量实验、§23 ask-rate 实验、P1–P5 落地、§25 多框架 adapter。

文章作者: Roger-Lv

文章链接: http://example.com/2026/07/21/2026-07-21-Meta-Self-Evolving-Agent%E6%9E%84%E6%83%B3/

Agent 自进化 research MEGA