Meta Description: Discover how self-improving AI agents using the Continual Harness architecture and Recursive Language Models are replacing static scaffolding in 2026 — with code, benchmarks, and real-world deployments from Google DeepMind, Meta, and PrimeIntellect.

一切改变的时刻

静态样板代码的问题

持续套件：自我修正的形式化框架

递归语言模型与程序化工具调用

模型-套件协同训练：当智能体训练自己的脚手架

多智能体编排实践

安全：自我修正智能体的阴暗面

这对开发者意味着什么：实用要点

AGI horizon：自我改进释放的信号

结论与下一步

1. 一切改变的时刻

2026 年初，一个 AI 智能体坐下来玩《宝可梦 红》。没有攻略。没有手工编码的招式表。没有预先整理好的工具库告诉它战斗系统如何运作，也没有告知第二个道馆需要水系宝可梦。它从一张原始截图和一个空白提示词开始。

当它完成游戏时——不仅通关了《宝可梦 红》，还通关了《蓝》《黄 Legacy》（困难模式）、《水晶》和《绿宝石》——完成这五款游戏的智能体与它开始时已有了本质不同。它重写了自己的记忆结构，发明了新的子智能体来处理特定机制，更新了反映来之不易的战斗策略的提示词，并剪掉了不再有效的技能。这就是自我改进 AI 智能体的架构：这些系统不仅仅使用工具，而是实时对自己的样板代码进行 CRUD 操作。

这不是一个花哨的把戏。它是一个概念证明，代表着自 Transformer 以来 AI 系统领域最重大的架构转变之一。而今天，这项研究已经落地生产：PrimeIntellect 推出了 Prime Agent，Meta 推出了由 Muse Spark 1.2 驱动的 Muse Code，Cloudflare 给了智能体一台真正的计算机，Uber 在 MLSys 2026 上开源了面向智能体系统的企业级安全方案。静态样板代码的时代已经结束——如果你在 2026 年构建 AI 系统，你需要了解取代它的是什么。

左图：冻结、脆弱的静态样板代码世界。右图：一个自我改进的智能体动态演化自己的架构。

2. 静态样板代码的问题

要理解为什么自我改进 AI 智能体重要，你首先需要了解它们正在突破的天花板。

你使用过的每一个智能体框架——LangChain、LangGraph、CrewAI、AutoGPT、Claude Code 的早期迭代——都有一个共同的设计假设：样板代码由人类编写，在部署时固定。工具在 JSON schema 中定义。提示词是配置文件中的字符串。记忆策略是带有硬编码分块逻辑的检索管道。技能是包装在 @tool 装饰器中的 Python 函数。

当底层模型相对较弱时，这是一个合理的假设——你需要用聪明的工程来弥补模型的局限性。但正如 PrimeIntellect 团队直接表达的："现代套件设计是围绕早期一代模型的能力构建的。"

静态样板代码在规模化时的三个失败模式现在已有完善的文档记录：

上下文压缩丢失。 长时程任务会耗尽上下文窗口。现有解决方案——摘要、滑动窗口、分层记忆——都涉及有损压缩。当 200 次工具调用前做出的关键决策影响下一个动作时，那个信息往往已经丢失。

技能集冻结。 静态智能体中的每个技能都是其设计者预见的。一旦任务需要设计者没有预先构建的能力，智能体要么失败、要么幻觉出一个虚假的工具调用、要么产生降级的结果。

硬编码的工具 schema。 固定的 JSON schema 强制模型使其推理适应 schema 的词汇。在自我改进系统中，情况恰恰相反：智能体定义它需要的接口，而不是反过来。

这些不是边缘案例——它们是当今最佳编程智能体仍被描述为"有用的助手"而非"自主工程师"的核心原因。瓶颈是架构性的。

3. 持续套件：自我修正的形式化框架

Google DeepMind 的论文 Continual Harness: Online Adaptation for Self-Improving Foundation Agents（arxiv:2605.09998）是对下一步发展最清晰的形式化论述。

论文将智能体的套件定义为一个四组件状态向量：

H = (rho, G, K, M)

rho — 系统提示词和任务特定指令

G — 活跃的子智能体集合

K — 技能库（可调用的工具和函数）

M — 记忆存储（情景记忆、语义记忆、工作记忆）

在静态框架中，你在部署时设置一次 H，然后不再触碰它。在持续套件中，智能体在运行中的 episode 期间对自身套件的每个组件拥有完整的 CRUD 访问权限。

自我修正循环的工作方式如下：

def refiner_loop(agent, trajectory, H, F=50):
    # 持续套件的核心：无需重置的在线适应。
    # Refiner 读取失败特征并对 H 的每个组件应用有针对性的 CRUD
    # 操作，而无需暂停 episode。
    if len(trajectory) % F == 0:
        failure_signatures = detect_failures(trajectory[-F:])

        for sig in failure_signatures:
            if sig.type == "prompt_drift":
                # 根据观察到的任务漂移更新系统提示词
                H.rho = agent.update_prompt(H.rho, sig.context)

            elif sig.type == "missing_skill":
                # 合成新技能并添加到库中
                new_skill = agent.synthesize_skill(sig.task_description)
                H.K = H.K.create(new_skill)

            elif sig.type == "memory_staleness":
                # 驱逐陈旧的记忆条目并重新索引新鲜版本
                H.M = H.M.delete(sig.stale_memory_ids)
                H.M = H.M.create(agent.reindex(sig.stale_memory_ids))

            elif sig.type == "subagent_bottleneck":
                # 为重复出现的瓶颈生成新的专业子智能体
                spec = agent.spawn_spec(sig.bottleneck_task)
                H.G = H.G.create(spec)

    return H

将持续套件与 GEPA 等前身区分开来的关键洞察是无需重置。此前的自我改进智能体会运行完整的 episode，评估性能，然后在运行之间应用更新。持续套件在 episode 内部运行 Refiner——智能体在任务仍在进行中时进行适应，从不停止。

持续套件状态向量及其 Refiner 循环——智能体的样板代码是一等公民的可变对象，实时更新。

在手工工程专家套件作为天花板的基准测试中，持续套件"相对于极简基准线大幅降低了按钮按压成本，并在无需任何精选知识、无手工制作工具、无领域样板代码的情况下恢复了与手工工程专家套件之间差距的大部分。"这是关键基准：在没有工程成本的情况下匹配专家人工工程。

4. 递归语言模型与程序化工具调用

当 Google DeepMind 将理论形式化时，PrimeIntellect 交付了运行时：递归语言模型（RLM）——驱动 Prime Agent 的执行底层。

RLM 抽象做出一个激进的设计决策：智能体的上下文是一个存储在持久化 IPython REPL 中的 Python 变量。会话是一个活的 Python 进程。过去的结果不会被摘要掉——它们作为命名变量存储在一个跨轮次持久化的命名空间中。子智能体委托是一个异步 Python 函数调用，在子智能体完成时返回。

这通过架构设计消除了上下文溢出。当智能体需要 500 步前的信息时，它从持久化、仅追加的存储中读取 rlm.harness.memory.get(id)——而不是一个有损摘要。

子智能体的编程模型：

import asyncio
from prime_agent import RLM, agent_message

async def analyze_codebase(rlm: RLM):
    # 向三个并行专业子智能体扇出。
    # 每个在自己的 IPython 内核中运行，拥有自己的会话历史。
    # 这个模式取代了数百行 LangGraph 编排代码。

Spawn three named parallel sub-agents — each gets its own REPL kernel

auth_task  = rlm(
    "Summarize the authentication flow in auth/. "
    "Cover OAuth2 flows, token refresh, and session management.",
    name="auth-expert"
)
api_task   = rlm(
    "Summarize the HTTP API layer in src/api/. "
    "Cover routing, middleware, error handling, and rate limiting.",
    name="http-expert"
)
infra_task = rlm(
    "Summarize the infrastructure in infra/. "
    "Cover Kubernetes manifests, secrets management, and CI pipeline.",
    name="infra-expert"
)

All three run concurrently in parallel sub-processes

auth, api, infra = await asyncio.gather(auth_task, api_task, infra_task)

Mid-flight follow-up: message a running sub-agent

await agent_message.send(
    "Also flag undocumented endpoints — look for @app.route with no docstring.",
    receiver_role="child",
    receiver_name="http-expert"
)

Synthesize into a unified architectural overview

return await rlm(
    f"Given these analyses:\n\nAuth: {auth.result}\n\n"
    f"API: {api.result}\n\nInfra: {infra.result}\n\n"
    f"Write a comprehensive overview for a new senior engineer.",
    name="synthesizer"
)

注意这里完全缺失了什么：JSON 工具模式、`@tool` 装饰器、`BaseTool` 继承、`ToolExecutor` 类。LangChain 中占据数千行代码的整个工具调用体系已被 `await rlm("task")` 完全取代。

RLM 会话树——每个节点都是一个独立的 Python 进程，拥有自己的持久化历史。子 Agent 委托就是简单的 `await`。

![RLM session tree visualization](https://cos.poetries.top/aiMonitor/1786598040406.jpg)

Memory 成为一个 Python 变量：

Store a discovered pattern mid-session — no retrieval pipeline needed

memory_id = await rlm.harness.memory.create({ "type": "architectural_pattern", "name": "retry_with_exponential_backoff", "observed_in": ["src/api/client.py", "workers/task_queue.py"], "description": "All external calls use tenacity: max_attempts=5, expo base=2", "relevant_for": ["new service integrations", "external API wrappers"] })

300 tool calls later — no context compaction, no information loss

pattern = await rlm.harness.memory.get(memory_id) print(pattern["description"])

-> "All external calls use tenacity: max_attempts=5, expo base=2"

这就是**编程式工具调用（Programmatic Tool Calling，PTC）**：Agent 在需要时使用纯 Python 定义自己所需的接口。

## 5. Model-Harness 联合训练：当 Agent 训练自己的脚手架

Continual Harness 和 RLM 是运行时框架。但还有一个更深的层次：如果模型的权重也能与脚手架一起训练呢？

这正是 Meta 借助 Muse Spark 1.2 所实现的。从 Meta AI Research 博客中了解到："拒绝采样的脚手架轨迹和目标、压缩和子 Agent 的配方优化被反馈到 Muse Spark 1.2 的训练中。" 成功的脚手架自我修改成为训练数据，产生了一个权重不仅反映"如何写代码"还反映"如何在这个脚手架中成为有效 Agent"的模型。

驱动这一点的 RLVR 训练循环：

def rlvr_training_loop(model, dataset, reward_fn, optimizer, epochs=3): # Reinforcement Learning from Verifiable Rewards (RLVR). # No human annotation needed — rewards come from verifiable outcomes. # This is the recipe that produced models beating GPT-5.6 Sol at 100x lower cost. for epoch in range(epochs): for task in dataset: trajectory = model.run_agentic_episode(task) reward = reward_fn(trajectory=trajectory, ground_truth=task.ground_truth) loss = ppo_loss(trajectory, reward) optimizer.zero_grad() loss.backward() optimizer.step() avg = compute_avg_reward(dataset, model) print(f"Epoch {epoch+1} complete — Avg reward: {avg:.4f}")

def reward_fn(trajectory, ground_truth): # Three independently verifiable reward signals — zero annotation cost. # retrieval: did the agent fetch the correct source document/chunk? # citation: did the agent cite the right passage in its answer? # correctness: does the final answer match the ground truth exactly? answer = parse_final_answer(trajectory) retrieval = score_retrieval_accuracy(trajectory, ground_truth.source_chunks) citation = score_citation_accuracy(trajectory, ground_truth.citations) correctness = int(answer.strip().lower() == ground_truth.answer.strip().lower()) # Correctness matters most; retrieval + citation provide dense intermediate signal return 0.3 * retrieval + 0.3 * citation + 0.4 * correctness

Castform 的成果——开源 RLVR 调优模型以约 $0.0003/请求的成本击败 GPT-5.6 Sol（后者约 $0.03/请求）——对于大多数企业用例来说是可复现的。你不需要前沿模型 API 访问权限就能构建同领域最佳的 Agent。你公司的内部数据本身就是一个训练资产。

关于联合训练为何有效的理论框架来自 Skill-Native LLMs 论文（arxiv:2608.05139，Sanjeev Arora 等，普林斯顿大学/伊利诺伊大学厄巴纳-香槟分校）。该论文引入了技能熵（Skill Entropy，SkE）：一种衡量依次需要多样化技能时性能下降程度的指标。静态模型在序列中超过 8-10 种不同技能后性能迅速下降。联合训练的模型在高 SkE 下保持平坦的性能曲线——因为它们已经在训练中接触过运行时遇到的确切技能切换模式。

## 6. 多 Agent 编排实践

2026 年 8 月 6 日的 GitHub Trending 页面是多 Agent 编排问题的生产级答案目录。

Cloudflare Computer（github.com/cloudflare/computer，趋势排名第一）为 Agent 提供了一台持久化计算机：一个 Durable Object 内部虚拟文件系统，后端为 SQLite，带有可插拔的执行面：

const workspace = new Workspace();

// Full FUSE-mounted Linux userland — outperforms real disk on metadata-heavy ops // Critical for agents doing rapid codebase introspection const containerResult = await workspace.runtime.exec(sourceCode, { backend: "container" });

// Bash via Dynamic Worker — zero container startup overhead const shellResult = await workspace.runtime.exec(shellScript, { backend: "isolate-shell" });

// ECMAScript modules in V8 isolates const jsResult = await workspace.runtime.exec(jsModule, { backend: "isolate-javascript" }); // All backends share persistent SQLite state; FUSE sync via capnweb RPC

Muse Code 的持久化子 Agent 使 1,000+ 次工具调用的 GPU 内核优化运行成为可能（24+ 小时，编写/编译/分析 NVIDIA Hopper 内核）。会话状态机和仅追加事件日志使会话具有精确重放能力：

class AgentSession: # Muse Code session lifecycle: Running -> Idle -> Inactive. # Background agents persist in Idle state between task assignments, # eliminating redundant context gathering on every new invocation.

def init(self, session_id, agent_role): self.session_id = session_id self.agent_role = agent_role self.state = "Running" # Append-only: every action, result, and state transition is logged. # Enables exact replay from any checkpoint. self.event_log = EventLog(f"sessions/{session_id}.jsonl")

async def transition(self, new_state): assert new_state in ("Running", "Idle", "Inactive") await self.event_log.append({ "type": "state_transition", "from": self.state, "to": new_state, "timestamp": utcnow() }) self.state = new_state

async def assign_task(self, task): if self.state == "Inactive": raise SessionError("Cannot assign task to an inactive session") await self.transition("Running") result = await self.run_task(task) await self.transition("Idle") # Agent stays alive, ready for next task return result

2026 年的生产级多 Agent 拓扑：持久化子 Agent、共享内存中心，以及作为执行面的无服务器持久化计算机。

![Multi-agent orchestration topology diagram](https://cos.poetries.top/aiMonitor/1786598046458.jpg)

## 7. 安全：自我修改 Agent 的阴暗面

本文中的每一个能力也都引入了攻击面。对于自我改进的 AI Agent 来说，这个攻击面与静态脚手架时代存在的任何东西有着本质的不同。

Uber ADR（Agentic AI Detection and Response，已被 MLSys 2026 接受，已在 Uber 生产环境部署）监控 7 个 AI 编码工具横跨 133 个 MCP 服务器上的 303 项任务，覆盖所有 17 种已知的 Agent 攻击技术。

对于自我改进系统，最危险的特定攻击向量是 Refiner 投毒：精心构造输入，使 Refiner 循环对 H 进行定向修改。在静态智能体中，提示词注入只影响单次响应。而在 Continual Harness 智能体中，成功注入 Refiner 上下文可以重写系统提示词、添加恶意子智能体、向 H.K 注入恶意技能，或破坏 H.M——这些更改会在会话剩余时间内持续存在。

ADR 的两层检测架构：

第一层 — 高召回率分诊（低延迟）：

实时捕获所有工具调用、文件系统操作、网络请求 标记：异常数据泄露、意外二进制执行、 高熵工具序列、对 H 的 CRUD 操作超出预期范围 高误报率可接受——将可疑会话传递给第二层

第二层 — 智能体推理层（高精度）：

对完整标记会话轨迹进行深度 LLM 分析 重建意图：解决难题 vs. 遭受攻击？ 区分合法技能合成与恶意注入 仅对第一层过滤出的可疑子集进行操作

企业部署检查清单：

明确限定 CRUD 权限范围。将 Harness 修改权限视为文件系统权限——按最小所需授权。

在应用前记录所有 Refiner 输出。从不应用 harness CRUD 操作而不将完整的变更前后差异追加到事件日志。

对 harness 修改进行限速。M 步内超过 N 次 CRUD 操作是安全信号。

沙箱化技能合成。新技能在加入 H.K 前必须在隔离环境中运行。从不未经明确策略审批就允许合成技能访问网络。

## 8. 这对开发者意味着什么：实践要点

使用静态脚手架当：

任务范围较短（少于 50 次工具调用）

完整技能集在设计时已知且稳定

你优先考虑延迟而非长时程能力

任务领域狭窄且有明确规范

使用 Continual Harness / RLM 当：

任务完成需要超过 100 次工具调用或数小时的自主操作

技能集在设计时无法完全枚举

你在没有专家策划工具的新领域中运作

2026 年每位开发者必须做出的四个架构决策：

会话持久性 — 临时（按任务）vs. 持久（按项目，可存活数周）？

记忆拓扑 — 会话本地 vs. 团队共享 vs. 全局共享？

CRUD 范围 — 哪些 harness 组件可以在什么约束下被智能体修改？

协同训练策略 — 在可验证奖励的领域上进行 RL 后训练，还是接受前沿模型上限？

最小化 Continual Harness 入门（Python）：

```python
from dataclasses import dataclass, field
from typing import Callable, Any

@dataclass
class Harness:
    # 最小化 H = (rho, G, K, M)。
    # 所有四个组件都是活 Python 对象——在任何 episode 中都可变。
    rho: str
    G: dict[str, Any]      = field(default_factory=dict)  # 子智能体
    K: dict[str, Callable] = field(default_factory=dict)  # 技能
    M: dict[str, Any]      = field(default_factory=dict)  # 记忆

    def apply_crud(self, component, op, key, value=None):
        # 所有 harness 变异的单一入口点——在调用前记录。
        target = getattr(self, component)
        match op:
            case "create": target[key] = value
            case "read":   return target.get(key)
            case "update": target[key] = value
            case "delete": target.pop(key, None)

class ContinualHarnessAgent:
    def __init__(self, model, initial_harness: Harness, refiner_interval: int = 50):
        self.model      = model
        self.H          = initial_harness
        self.trajectory = []
        self.F          = refiner_interval
        self.step       = 0

    async def run(self, task: str) -> str:
        while not await self.is_done(task):
            action = await self.model.act(
                task=task, harness=self.H,
                trajectory=self.trajectory[-20:]
            )
            result = await self.execute(action)
            self.trajectory.append({"action": action, "result": result})
            self.step += 1

            # 细化：每 F 步对 H 执行 CRUD，途中不停止 episode
            if self.step % self.F == 0:
                crud_ops = await self.model.refine(
                    trajectory=self.trajectory, harness=self.H
                )
                for op in crud_ops:
                    # 在生产环境应用前在此记录操作
                    self.H.apply_crud(**op)

        return self.trajectory[-1]["result"]

领域特定自我改进 AI 智能体的 RL 后训练路径：

from castform import SyntheticQAGenerator, RLVRTrainer
from prime_agent import RLM

# 第一步：从内部语料库生成合成问答对
generator    = SyntheticQAGenerator(corpus_path="s3://your-company/docs/")
dataset      = generator.generate(n=10_000, difficulty="mixed")

# 第二步：在可验证领域奖励上 RL 后训练开放模型
trainer      = RLVRTrainer(
    base_model="google/gemma-4-9b-it",
    dataset=dataset,
    reward_components=["retrieval", "citation", "correctness"],
    training_steps=2_000
)
domain_model = trainer.train()
# 典型结果：以 100 倍更低的推理成本击败前沿 API

# 第三步：使用自我改进 harness 部署
agent = RLM(model=domain_model, harness_config="config/my_domain.yaml")

9. AGI 地平线：自我改进释放的信号

2026 年 8 月 5 日，Sundar Pichai 宣布 Demis Hassabis 将卸任 Google DeepMind CEO，成为 GDM 董事长兼 Alphabet 首席科学家——专注于 AGI。Hacker News 讨论串产生了 619 条评论，成为当日最大规模的 AI 讨论。

这个组织信号值得从技术角度解读。从「优秀的自我改进 AI 智能体」到「AGI」的道路不是产品管理问题，而是一个研究问题，其核心问题是自我改进是否——以及如何——跨越那条鸿沟。