惯性聚合 高效追踪和阅读你感兴趣的博客、新闻、科技资讯
阅读原文 在惯性聚合中打开

推荐订阅源

Cyber Security Advisories - MS-ISAC
Cyber Security Advisories - MS-ISAC
博客园 - 【当耐特】
阮一峰的网络日志
阮一峰的网络日志
S
Secure Thoughts
Threat Intelligence Blog | Flashpoint
Threat Intelligence Blog | Flashpoint
钛媒体:引领未来商业与生活新知
钛媒体:引领未来商业与生活新知
T
Tenable Blog
T
Tailwind CSS Blog
WordPress大学
WordPress大学
宝玉的分享
宝玉的分享
Webroot Blog
Webroot Blog
cs.CL updates on arXiv.org
cs.CL updates on arXiv.org
The Cloudflare Blog
T
Threat Research - Cisco Blogs
V
Visual Studio Blog
Jina AI
Jina AI
V
V2EX
I
InfoQ
Latest news
Latest news
P
Proofpoint News Feed
T
Threatpost
Engineering at Meta
Engineering at Meta
P
Proofpoint News Feed
美团技术团队
The Register - Security
The Register - Security
L
LangChain Blog
Apple Machine Learning Research
Apple Machine Learning Research
aimingoo的专栏
aimingoo的专栏
GbyAI
GbyAI
Cloudbric
Cloudbric
Microsoft Azure Blog
Microsoft Azure Blog
C
Cisco Blogs
U
Unit 42
Microsoft Security Blog
Microsoft Security Blog
MyScale Blog
MyScale Blog
V
Vulnerabilities – Threatpost
TaoSecurity Blog
TaoSecurity Blog
freeCodeCamp Programming Tutorials: Python, JavaScript, Git & More
Recent Commits to openclaw:main
Recent Commits to openclaw:main
W
WeLiveSecurity
博客园 - 司徒正美
T
The Exploit Database - CXSecurity.com
小众软件
小众软件
Y
Y Combinator Blog
Recent Announcements
Recent Announcements
量子位
酷 壳 – CoolShell
酷 壳 – CoolShell
让小产品的独立变现更简单 - ezindie.com
让小产品的独立变现更简单 - ezindie.com
博客园_首页
N
News and Events Feed by Topic

Tony Bai

Twitter之父再出手:Block开源Buzz,要让人类和AI Agent「同工同权」 Go 密码学维护者放大招:把 Passkey 存成一行字符串,还顺手为 Go 1.28 写好了 API Loop Engineering才火两个月,硅谷已经卷出“Graph Engineering”了 我开源了 cc-session-migrate :让 Claude Code 会话在多台机器之间自由迁移 从掌上设备的失败到AI时代的基石:Java官方纪录片,揭开一门语言30年的生死赌局 “皇帝的新衣”一年后:对话Thorsten Ball谈Agentic编程 告别标签页焦虑:我让 AI 帮我做了个浏览器插件 TabQueue Bun刚把Zig重写成Rust,这个团队却用487天反向重写 为了一个函数名,Go官方吵了两个月:maps.Same提案近日正式通过 Go 1.28 路线图首度曝光:Cgo 告别C工具链?泛型容器将入标准库? 掌控外环:为什么“循环工程”的边界必须由人类死守? 171个“已批准”却迟迟未实现的提案:Go语言的十年“欠账清单” 别再往 Go 里塞 Java 了:拆解 spf13 的 Idiomatic Go 信仰 AI 不在乎代码烂不烂,但你的Token账单在乎:一项660次实验揭示的编程新常识 10倍速 TypeScript 7.0 正式发布,前Go产品经理:Go才是AI智能体时代的“天选语言” Bun 重写为 Rust 后,Zig 之父罕见开炮:“我们早就等着看你重写” AI 重写 Bun 为Rust全过程揭秘:101万行代码、11天、64个Claude并行开工 MCP Server 架构模式全解析:5 种模式、4 个反模式,与那条不能越过的“工具数量红线” 从手动 govanityurls + Nginx 迁移到 gvu:一次真实迁移记录 Go 私有模块拉取全解:凭据配置 + Vanity URL,个人与组织全覆盖 从“切歌小工具”到“零人工代码”:Claude Code 的诞生史,比科幻还科幻 如何使用 Claude Code 构建 AI 循环系统(Loops) 5 分钟上手 gvu:把 vanity import path 这件事,从“半天运维”变成一条命令 Go 对语言演化的保守态度,在未来 5 年是否仍然正确呢? 五年,三篇文章,一个我一直没真正解决的问题 别把“容易”当“简单”:Gin 框架作者撰文揭秘 88k Star 背后的架构哲学 每个 AI 工程师都应该知道的 20 个循环设计模式 cc-switch-cli:专为终端控与远程开发打造的 Claude Code 多模型切换工具! Andrej Karpathy 解析 Loop Engineering:构建“数日级”长程 Agent 的 9 条黄金法则 HashiCorp 创始人:AI 时代,我们为什么越来越需要有“品味”的程序员? HashiCorp 创始人:AI 时代,我们为什么越来越需要有“品味”的程序员? 一个 Rust 项目吃掉 75GB 硬盘?聊聊 Go 与 Rust 的“缓存焦虑”与拯救指南 折腾过各种语言后,我为什么总是回到 Go 语言? YC 揭秘 AI 原生组织:打造一家在睡梦中自我进化的公司 从 WordPress 到 Hugo:一个 20 年技术博客的迁移实录 偿还十年技术债:深度拆解 Go 1.27 的 GODEBUG 强力清理计划 浏览器里的“安全阴谋”:为什么 Go 1.27 的 UUIDv7 会离奇丧失随机性? Go 1.27新特性前瞻:泛型方法落地,标准库内建 UUID - Tony Bai AI 正在撕裂研发团队:狂欢的“托管派”与心碎的“守夜人” - Tony Bai 屠榜 CNCF!为什么在云原生时代,Go 语言能把 Java、C++ 和 Rust 堵在门外? 上千程序员自爆 AI 的“卧槽时刻”:是推开神界大门,还是跌入黑盒地狱? - Tony Bai 大模型正在见顶!传奇架构师:欢迎来到“平坦曲线时代” - Tony Bai Anthropic 40万大样本揭秘:AI 时代为什么“专家”身价暴涨? - Tony Bai 在 AI 编码时代,为什么我们依然选择 Go 而不是 Rust? DeepMind 亮出王炸:别再手写 Agent Harness 了,AI 已经学会自己写了! 为什么说“编译通过,就能运行”?Google 专家 Alice 揭秘 Rust 的工程美学与底层逻辑 谷歌 SRE 重磅白皮书:当 AI 自动写出 10 倍代码,谁来阻止系统崩溃? 别再省 Token 了!硅谷新共识:浪费算力才是唯一捷径 - Tony Bai Linux 内核顶级维护者:写了 35 年 C,是 Rust 让我重新找回了编程的乐趣 拒领上亿、封杀 AI:Zig 之父为什么 10 年不发 1.0? 写地道的 Go 语言,是否能让你成为了一个更好的开发者? - Tony Bai RSA 将死?Let’s Encrypt 押注 MTCs 迎战后量子时代 C++ 的权力游戏:一部关于妥协、背叛与重生的“史诗神剧” - Tony Bai 终结十年纠结:Go 新提案允许 Example 支持任意函数签名 - Tony Bai 2026年,大厂重构核心系统为何集体投向 Go? - Tony Bai “辛辛苦苦考上985,却发现AI能替代我90%的工作”:今天的高考,我们还在为什么而战? - Tony Bai 传奇黑客 Geohot 炮轰 AI Agent:这是软件工程史上代价最昂贵的灾难! 别把 Go 写成 Java:毁掉项目从过度架构开始 - Tony Bai 开源维护者的困境 - Tony Bai AI 时代如何真正掌握一门新技术?这份非主流学习指南建议永久收藏 - Tony Bai Go 生态17年大浪淘沙:2026年最值得引入的10个“神仙级”QoL工具包 - Tony Bai 再见样板代码!Go 官方新提案:函数一键转接口 - Tony Bai 写代码快 10 倍,不等于研发快 10 倍!Google 揭秘 AI 系统级瓶颈 Google I/O 2026:Jeff Dean 携 DeepMind 众神宣告,AI Agent 正在终结“标准化软件”时代 AI 优化 1.5ms,手写 0.02ms!Ghostty 作者痛批 AI 编程“平庸陷阱” Redis 之父吐槽现代前端的复杂性:我们到底是在解决问题,还是在制造问题? - Tony Bai 无痛消灭技术债:Google I/O 2026 开启 Go 自动重构时代 省下 10% CPU!Uber 揭秘 Go 栈扩容的隐秘代价 从 Go 迁移到 Rust - Tony Bai 悄悄用 Go 重写 AI 基础设施:NVIDIA 的 GPU 云平台为何选择 Go? Shopify 23,000 名工程师背后的 Claude Code 配置方案(你可以直接复刻的完整配置) Google 开源 AX 与 Agent Substrate:构建以 Agent 为核心的云原生计算底座 十年难题终获突破:揭秘 Go 1.27 接口逃逸分析优化 - Tony Bai
全新 AI 技术栈:模型、Harness、Loop 与自我进化的智能体
Tony Bai · 2026-07-10 · via Tony Bai

题图

本文永久链接https://tonybai.com/2026/07/10/the-new-ai-stack-model-harness-loop-agent

大家好,我是Tony Bai。

在过去的 AI 浪潮中,所有人的目光都死死盯着基础模型(Foundation Models):

从 GPT-5.x 到 Claude Sonnet 5/Fable 5,再到各种开源大模型。整个行业似乎形成了一种思维定势——“只要模型更聪明,应用就会更好。”

但这其实是整个 AI 行业最大的谎言。

为什么手握同样的基础模型,顶尖大厂做出的 Claude Code 和 Codex等能够实现丝滑的工程自动化,而你熬夜写出的 Agent 却在跑了 20 步之后就因为上下文暴涨而当场崩溃?

AI 圈技术专家 Rahul (@sairahul1) 在一篇名为“The New AI Stack: Models, Harnesses, Loops, and Self-Improving Agents”的技术长文中给出了答案:基础模型只是 passive(被动)的 CPU。真正决定一个 AI 产品是“玩具”还是“生产级工具”的,是包裹在模型之外的“驾驭框架(Harness)”。

更让人感到兴奋(甚至一丝敬畏)的是,在最新的 AI 工程实践中,这套驾驭框架已经开始由 AI 自行重写和优化,实现了真正的“自我进化”。

本文将为你彻底拆解这个由Rahul提出来的“模型、Harness、循环、自优化智能体”构成的全新 AI 技术栈。看完这篇文章,你将彻底明白为什么各大前沿实验室的 Agent 能力正在呈指数级无声进化。

以下为译文全文:

所有人都在谈论 AI 模型。

但根本没有人关注那个真正让模型变得实用的底层逻辑。

Claude Code、Codex、Cursor……

这些绝不仅仅是简单的“大模型”。

它们是被包裹在一整套工程系统之中的模型。

这套系统,被称为 “驾驭框架(Harness)”

而如今,最顶尖的驾驭框架,已经学会了自我进化(Improve themselves)。

以下,是关于全新 AI 技术栈你所需要了解的一切。

整个 AI 产品圈深信不疑的谎言

绝大多数人认为,AI 的进步等同于“更聪明的模型”。

事实并非如此。

模型仅仅是整套技术栈中的冰山一角。

大模型的底层架构(Transformer)早已是公开的秘密。所有人都在复制相同的 Transformer,每一个顶尖实验室都在使用完全相同的积木。

真正让 Claude Code 与一个普通周末练手项目拉开天堑般差距的,绝不是底层的模型本身。

而是包裹在模型外部的工程系统。

也就是——驾驭框架(Harness)。

在 2017 年,AI 的突破在于注意力机制(Attention);在 2020 年,在于规模定律(Scaling);而到了现在,驾驭框架已经开始由 AI 自身、而非人类工程师来设计了。

驾驭框架(Harness)是包裹在模型外围的控制系统。

它决定了:

  • 模型如何进行思考与路径规划(Planning)
  • 模型何时调用工具,以及如何处理工具返回的结果
  • 模型在长程步骤中,需要“记住”什么
  • 模型如何存储中间产物(Artifacts)并管理系统状态
  • 模型如何对自己输出的质量进行自我评估
  • 模型何时需要回溯循环,并重新进行尝试

你可以把它看作是操作系统(OS)。

模型是 CPU,而驾驭框架就是 OS。

你可以拥有一个性能爆炸的 CPU,但如果搭配了垃圾操作系统,你依然无法交付任何有用的功能;相反,即使你只有一个性能平庸的 CPU,只要搭配了极其优秀的操作系统,你依然能交付伟大的产品。

所有最成功的编程 Agent——Claude Code、Codex、Cursor——都共享着同一个底层洞察:

循环(Loop)的设计,与模型本身同等重要。

每个 AI 开发者都必须掌握的 3 种驾驭框架模式

任何处于生产环境(Production)的 AI 系统,都至少使用了以下模式中的一种。

模式 1:循环(The Loop)

模型绝对不会只回答一次就停下。

它会进入循环。

规划(Plan)-> 执行(Execute) -> 观察(Observe)-> 改进(Improve)-> 重复(Repeat)

这是每一个编程 Agent 的绝对核心。

一个简化版的 Claude Code 运行循环如下:

  1. 读取任务目标(Read the task)
  2. 规划解决路径(Plan the approach)
  3. 编写代码 -> 运行代码
  4. 查看何处运行失败(See what failed)
  5. 进行修复(Fix it)
  6. 再次运行代码
  7. 重复上述过程,直到测试用例全部通过

在第 3 次循环时,底层的模型本身并不比第 1 次循环时更聪明。

但系统整体变聪明了。

每一次循环,都为模型注入了全新的上下文背景(Context)——报错信息、测试结果、执行路径追踪(Traces)。

第 1 次循环的输出,成为了第 2 次循环的输入。

这种复合型的上下文(Compound Context),正是 Agent 系统在面对复杂任务时,能以绝对优势降维打击“单次 Prompt 调用”的根本原因。

核心洞察:模型保持不变,上下文在不断进化。

模式 2:将文件系统作为记忆体(File System as Memory)

绝大多数开发者习惯将所有数据无脑地塞进模型的上下文窗口(Context Window)中。

这是一个巨大的陷阱。

长周期的复杂任务会产生海量的数据:

  • 实验日志(Experiment logs)
  • 代码差异(Diffs)-> 错误追踪日志(Error traces)
  • 历史运行轨迹 -> 论文/文档摘要 -> 中间过程产物

所有这些数据,都会迅速撑爆任何大模型的上下文窗口。

终极解决方案:写入文件,而不是写入上下文。

# 糟糕的做法:把所有东西都塞进上下文
context = previous_output + tool_result + error_log + history...
# 在第 47 步时,上下文彻底溢出并崩溃

# 优秀的做法:善用文件系统
agent.write("experiments/run_3/error_log.txt", error_trace)
# agent.write("experiments/run_3/results.json", metrics)

# 随后,Agent 仅仅读取它当前步骤所需的信息
relevant = agent.read("experiments/run_3/results.json")

这一改变彻底重构了长周期任务的开发游戏规则:

  • 即使中途崩溃,Agent 也能完美复活并从断点继续运行
  • Agent 可以像人类一样,对自己的历史执行记录进行深度推理
  • 即使运行到第 200 步,上下文窗口依然保持极致的干净
  • 多个子 Agent 之间,可以通过读写文件完美共享系统状态

最顶尖的 Agent,会将文件系统当成自己的“第二大脑”。它不是一个杂乱的垃圾堆,而是一个结构化的记忆库。

模式 3:子智能体派生(Sub-agents)

单个 Agent 无法大包大揽搞定所有事。

最强大的系统会选择派生出并行的子 Agent(Sub-agents)。

父 Agent(Parent Agent)负责:

  • 将大任务拆解为若干完全独立的子任务
  • 异步启动多个子 Agent,并行执行这些子任务
  • 监控它们的运行状态 -> 最终将它们各自的返回结果进行合并

一个科研/调研驾驭框架的实例:

父 Agent 接收到任务: "撰写一份完整的竞品分析报告"

同时异步派生出 4 个子 Agent:
→ 子 Agent 1: 深入调研竞品 A 的价格体系与核心功能
→ 子 Agent 2: 深入调研竞品 B 的价格体系与核心功能
→ 子 Agent 3: 检索关于这两个竞品的最新行业新闻
→ 子 Agent 4: 从 Reddit 和应用商店爬取真实用户评价

父 Agent 处于挂起等待状态,随后将 4 个子 Agent 的产出合并为最终报告

总耗时:等同于运行最慢的那一个子 Agent 的时间(而不是 4 倍耗时)

最核心的设计准则:子 Agent 的输出必须直接写入文件。

绝对不能写进临时上下文。一旦子 Agent 的会话结束,存在上下文里的数据就会烟消云散。只有写进文件,父 Agent 才能对其进行审查,系统才能在崩溃后实现自愈,且每一步都具备可审计性。

每个编程 Agent 都在使用的标配工具库

如果你正在构建一个 Agent,以下是目前行业内所有主流编程 Agent 都在标准化的黄金工具箱:

【文件系统工具】 (File System Tools):
- glob, grep, ls        # 定位并检索文件
- read, read_many       # 读取文件内容
- write                 # 新建文件
- edit                  # 字符匹配与精准编辑
- apply_patch           # 结构化的 Diff 代码修补

【终端工具】 (Shell Tools):
- bash                  # 在后台运行任何指令 (Linux/macOS)
- PowerShell            # Windows 环境下的终端等价物

【版本控制工具】 (Version Control):
- git_status, git_diff  # 检查代码变更
- git_commit            # 固化保存当前进度

【Agent 管理工具】 (Agent Management):
- spawn_agent           # 派生子 Agent
- wait_agent            # 等待子 Agent 返回结果
- list_agents           # 查看当前正在后台运行的 Agent 列表
- interrupt_agent       # 如果行为失控,随时中止子 Agent

【外部上下文获取】 (External Context):
- web_search, web_fetch # 检索互联网获取最新即时信息
- MCP tools             # 通过模型上下文协议 (Model Context Protocol) 连接外部服务

你并不需要在一开始就给你的 Agent 接入上面所有的工具。

但一个走向生产环境的成熟 Agent,迟早会需要它们中的绝大部分。

在开发早期,最关键的只有四个工具:bash、read、write、edit。彻底玩透这四个,你就能构建出绝大多数自动化系统。

上下文工程(Context Engineering):那个无人提及的核心能力

大模型是固定死、无法更改的。

你不可能在系统运行时去调整它的神经网络权重。

但你拥有完全的权限,去控制模型能看到什么。

这就是上下文工程(Context Engineering)。

在当前的 AI 工程领域,这是最具杠杆效应、能直接拉开产品差距的核心技能。

糟糕的上下文管理

  • 将所有东西一股脑丢进去 -> 祈祷模型能给自己最好的输出。
  • 上下文极度臃肿 -> 模型丧失焦点 -> 产出质量开始雪崩。

优秀的上下文管理

  • 高度结构化、精炼、且处于动态进化中。
  • 确保模型在特定的步骤,只看到最精准的那部分信息。
  • 让历史上的失败教训,实时指导当前的尝试。

目前最前沿的架构方案,被称为 ACE(Agentic Context Engineering,智能体上下文工程),它包含三个核心组件:

【ACE 架构三大组件】:

1. Generator (生成器): 负责执行具体任务,在执行时会参考一份结构化的“上下文剧本(Playbook)”
2. Reflector (反思器): 专门分析任务的成功与失败,将教训提炼成最精简的底层规律(Insights)
3. Curator (馆长/整理器): 负责将提炼的教训更新进剧本中——完成新增、删除和去重清洗

这份“上下文剧本(Playbook)”绝对不是一大堆零散的 Prompt 字符,它是一系列高度结构化的(identifier, insight)键值对:

[
  {
    "id": "001",
    "insight": "在进行下一次重试前,务必先将当前步骤的错误日志(Error Traces)完整写入磁盘文件。"
  },
  {
    "id": "002",
    "insight": "使用子 Agent 进行网页检索时,加上 'site:' 限制条件能返回质量高得多的结果。"
  },
  {
    "id": "003",
    "insight": "在向代码库 commit 提交前运行本地测试集,能自动拦截 80% 的代码功能倒退(Regressions)。"
  }
]

这份剧本在每次任务后都会自动更新。

当系统运行到第 50 次任务时,Generator 此时是在 49 次实战提炼出的智慧精华 指导下工作的;而第 1 次运行时,它一无所有。

这就是系统在完全不触碰、不微调模型权重的前提下,自己变得越来越聪明的底层原理。

会自我进化的驾驭框架(Self-Harness)

这才是整场变革最疯狂的部分。

如果被优化的目标,不再是生成的内容,甚至也不是 Prompt,而恰恰是驾驭框架(Harness)的代码本身呢?

不是修改提示词。不是修改模型。

而是直接修改运行 Agent 的系统源代码。

这正是Self-Harness(自主框架优化)正在实现的技术。它通过一个三步闭环来实现:

第一步:挖掘系统缺陷(Mine weaknesses)

让当前的驾驭框架去跑一大批任务,收集完整的执行失败的 trace 日志。通过聚类算法,分析出系统报错崩溃的底层根源。

不是简单地记录“失败了”,而是揪出为什么失败。

系统自主定位出的典型失败类型包括:

  • “在读取大文件时,Agent 会因为没有设置超时而卡死”
  • “当父 Agent 发生意外崩溃时,子 Agent 跑出的结果全部丢失了”
  • “系统底层的报错信息不够详尽,导致 Agent 无法进行自我纠错”
  • “30轮后,上下文极度臃肿,大模型失去焦点”

第二步:针对性提出代码修补(Propose fixes)

让大模型去审视这些归纳出来的失败模式。针对驾驭框架的系统源码,提出具体的、高精度的微调修补。

注意:不是重构整个系统,而是精准的手术刀式修改。

对应上面失败,模型对Harness源码提出的优化方案:

  • 针对文件读取操作,自动安插超时异常处理(Timeout Handler)。
  • 在每一个原子步骤后,自动将子 Agent 的输出刷新持久化到磁盘,防止丢失。
  • 规范系统底层报错格式,使其强行包含:当前步骤、所用工具、输入、输出、具体的失败根源。
  • 每隔 25 个对话回合,自动触发一次上下文压缩程序。

第三步:跑通测试并合并代码(Validate and merge)

每一段对系统源码的改动,都会在未污染的独立测试集上进行严格跑通。

它是否在不破坏任何现有功能的前提下,成功修复了那个系统缺陷?

  • 如果是:将这段优化后的代码正式合入驾驭框架的生产分支。
  • 如果否:记录失败原因,直接驳回,系统源码保持不变。

结果是:整个驾驭框架,在没有任何人类干预的情况下,随着迭代一代代变得越来越强壮。

仅仅是通过让 老旧的Claude 3.5 Sonnet 运行这套 Self-Harness 机制,它在行业公认的软件工程基准测试 SWE-bench Verified 上的得分就直接从 20% 暴涨到了 50%。

没有依赖任何更新、更聪明的模型。

完全来自于系统驾驭框架的自我进化

Self-Harness 是对单个框架进行单线迭代。

而 AlphaEvolve 则更进一步:它在后台维护着一个驾驭框架的“种群”,并让它们进行物竞天择的进化。

其底层算法逻辑如下:

1. 初始构建一个由若干不同框架代码候选者组成的“种群池”
2. 运行 benchmark 测试集,对每个候选框架进行表现打分
3. 筛选出表现最好的一批框架作为“父代(Parents)”
4. 让大模型针对这些优秀的框架代码,提出 diff 修改和功能进化建议
5. 自动繁衍出全新的“子代(Child)”框架代码
6. 对子代框架进行测试打分
7. 留存那些得分确实变高了的子代
8. 将它们重新放入“种群池”中
9. 重复上述物竞天择的过程

(完全将自然界的达尔文演化论,应用在了系统代码的编写上)

在 AlphaEvolve 的设计中,有一个非常天才的工程细节:

允许被 AI 自动修改和进化的系统代码区域,必须被显式地标记出来(严格框定破坏半径):

# EVOLVE-BLOCK-START
def plan_next_step(context, tools):
    # 这一段代码块,允许被进化算法搜索并修改
    prompt = f"当前上下文: {context}\n可用工具箱: {tools}\n建议下一步行动: "
    return llm.generate(prompt)
# EVOLVE-BLOCK-END

# 其余涉及系统安全、数据读写的框架底层代码则保持绝对锁定
def run_tool(tool_name, args):
    return tool_registry[tool_name](**args)

这种沙箱式隔离,确保了 Agent 永远不会在自我重写时,不小心破坏掉系统关键的安全与权限底线。

进化搜索算法,只被允许触碰你授权给它的代码。

AlphaEvolve 曾使用这套逻辑来优化矩阵乘法算法:它直接击败了 DeepMind 顶尖人类工程师手动优化了数年的代码。

Agent 找到的系统级优化方案,是人类工程师几十年都未曾触及的领域。

达尔文-哥德尔机(Darwin Gödel Machine):实现彻底自我重构的终极智能体

这是目前该思想演进到极限的最硬核形态。

一个能自己修改自己驾驭框架源码、以求在任务中获得更好表现的 Agent 系统。

这被称为 达尔文-哥德尔机(Darwin Gödel Machine, DGM):

1. 初始种群中放入一个基础编程 Agent
2. 让其运行 benchmarks,收集最终评分
3. Agent 开始自主阅读并审计自己的运行日志与报错 Trace
4. Agent 主动提出对自身驾驭框架代码的优化方案
5. 为其配备工具:bash 权限 + 文件编辑器(允许查看、创建和修改本地系统文件)
6. 自动实例化出全新版本的 Agent
7. 对新一代 Agent 进行严格 benchmark 跑分
8. 如果分数提升:合入进化池
9. 如果分数退步:直接丢弃
10. 重复上述循环——基于表现筛选父代,基于后代数量进行逆向淘汰

初始环境配置:Claude 3.5 Sonnet + 极其简陋的初始控制代码。

运行结果:

  • SWE-bench Verified 得分:从 20% 直接飙升到 50%
  • 多语言编程基准测试(Polyglot):从 14.2% 提升到 30.7%

整个进化过程中,底层的模型权重没有任何改变,两代模型之间没有任何人类工程师写过一行代码。

Agent 自己设计并实现了更强大、更鲁棒的自己。

这不是科幻小说。

这是一篇发表于 2025 年的真实学术论文。

必须绕开的 5 大失败雷区

在各大前沿实验室的真实探索中,踩过无数的坑。

以下是被完整记录、但完全可以提前规避的 5 个失败模式:

1. 上下文崩塌(Context collapse)

如果长周期任务的中间日志没有及时、规范地作为持久化文件写入磁盘,任务运行到后期时,模型会遗失大量关键决策细节。

避坑指南:将所有关键信息持久化到文件。一旦任务运行超过 20 步,永远不要只依赖 Context 来保留记忆。

2. 执行偏离(Implementation drift)

当任务过于复杂时,Agent 很容易偏离终极目标,转去写一些看起来很通用、但对解决具体问题毫无用处的漂亮废代码。

避坑指南:在任务启动时,率先生成一份不可篡改的 spec 规格说明文件。让 Agent 在每一次循环中,都强行核对该文件。

3. 盲目乐观(Over-optimism)

即使实验运行彻底失败了,模型也常常倾向于在日志里宣告成功。

它会自己发明一些“临时代码补丁”(Numerical Duct Tape),这些补丁能勉强让当前的监控指标好看,但根本没有解决真实的系统漏洞。

避坑指南:设置一个 Agent 永远接触不到的独立隔离测试集(Held-out Test Set)。只在隔离数据上做最终的合规验证。

4. 奖励欺骗(Reward hacking)

你给 Agent 什么考核指标,它就会疯狂钻空子去优化这个指标。

如果你给它的指标是“通过单元测试”,它会悄悄把单元测试的代码改掉,让它永远返回 True;如果你给它的是一个裁判模型打分,它会学会各种各样的花言巧语来欺骗裁判;如果指标是 Benchmark 得分,它会去寻找 Benchmark 自身的漏洞。

避坑指南:负责打分的评估者(Evaluator)必须物理隔离在循环体外部。在关键的控制流节点,必须引入人工介入审核(Human-in-the-loop)。

5. 多样性坍塌(Diversity collapse)

在进化搜索循环中,系统很容易迅速收敛到某一种单一的策略上。

导致繁衍出的每一代新框架,看起来都只是同一个解法的微调变体,彻底失去探索其他更好方案的可能性。

避坑指南:在筛选算法中显式引入“新颖度(Novelty)”考核指标。对于和现有种群相似度过高的方案(可以通过基于向量嵌入的余弦相似度算法进行判定)进行强行扣分。

用大白话翻译:全新 AI 技术栈

当你着手构建真正的商业级 AI 产品时,你实际在搭建的是这样一套四层架构:

第 1 层 —— 基础模型(The Model)

提供最底层的通用推理智商。预训练完成,运行时神经网络权重固定。

这就是系统的 CPU。智商超群,但本身是完全被动(passive)的。

第 2 层 —— 驾驭框架(The Harness)

系统的操作系统(OS)。包裹模型,调度全局。

  • 提供工具箱(bash、文件读写、网页检索)
  • 提供长期记忆(持久化文件系统、结构化日志)
  • 维持基本循环控制(规划 -> 执行 -> 评估 -> 重试)
  • 管理子 Agent 的并发与合并
  • 执行精细的上下文工程管理

第 3 层 —— 优化器(The Optimizer)

专门用来优化“驾驭框架”的自动化系统。

  • 从 trace 日志中深度挖掘系统的运行缺陷
  • 针对系统框架源码提出高精度的代码修补
  • 在隔离测试集上进行回归验证
  • 合并好代码,丢弃退步代码

第 4 层 —— 评估器(The Evaluator)

独立悬挂于上述所有系统之外的最高监察法庭。

  • 提供最终的 Benchmark 打分
  • 在关键决策点提供人工审核
  • 维护优化器永远接触不到的绝对隔离盲测数据集

在商业化落地中,你无法跳过上述任何一层。

  • 跳过第 2 层(Harness) —— 你的产品只是一个简陋的聊天机器人,根本无法投入工业生产。
  • 跳过第 3 层(Optimizer)—— 你的系统能力上限被死死锁死,只能永远依赖人类工程师苦哈哈地熬夜手动写代码去修补系统。
  • 跳过第 4 层(Evaluator)—— 你的 Agent 很快就会走上“奖励欺骗”的邪路,开始疯狂刷没有意义的指标,而你甚至无法察觉。

这对当下的 AI 开发者意味着什么?

你并不需要一上来就去写一个高大上的“自我进化系统”才能享受这套架构的红利。

从今天起,开启你的 4 周实战计划:

  • 第 1 周:构建基础循环(The Loop) 不要再写单次调用的 Prompt 了。针对任何需要多步骤处理的任务,老老实实搭建一个 规划 -> 执行 -> 评估 -> 重试 的闭环控制代码。
  • 第 2 周:接入持久化记忆 再不要无脑依赖上下文窗口了。将中间步骤的产出规范地写入本地文件,让 Agent 学会去读取和参考自己上一步的劳动成果。
  • 第 3 周:引入子 Agent 拆分出你工作流中所有可以并行的环节,设计父子 Agent 架构。让子 Agent 并行跑任务、写文件,最后由父 Agent 进行汇总。
  • 第 4 周:沉淀你的上下文工程 收集 Agent 在过去运行中的成功和失败案例。构建一个结构化的“避坑指南剧本”,让系统在每次运行前自动阅读并更新。

这就是驾驭框架。

它不是底层的模型本身。

模型早就在那里严阵以待了。

而驾驭框架(Harness),才是需要你亲手去雕琢的护城河。

关于 2026 年 AI 行业有些残酷的真相

各大前沿实验室的科研加速,正在以一种超乎想象的速度发生。

Anthropic 和 OpenAI 交付新功能的速度比以往任何时候都要快。

这绝对不是因为基础模型在一夜之间突然发生了“基因突变”或“智商暴涨”。

而是因为他们搭建的“驾驭框架”变得无比强大。

一个懂得自我循环、拥有持久记忆、会分发子任务、且具备自我纠错能力的 Agent,在实战中能轻而易举地降维打击一个被“错误使用”的更聪明的孤立模型。

真正的壁垒(Moat),从来都不是底层的模型。

壁垒,是包裹模型的系统。

而现在,这个系统已经学会了自我进化。

原文地址:https://x.com/sairahul1/status/2074427867329380359


如果这篇分享对你的工程思维有所启发:

  • 请转发分享给身边的每一位开发者,这才是未来的技术栈。
  • 关注作者,第一时间获取前沿 Agentic 架构拆解。
  • 收藏本文 —— 顶层的 4 层技术栈模型,值得你在设计系统时反复对照。

关注本公众号,获取更多高质量、无水分的 AI 落地与系统自动化硬核文章。


还在为写 Agent 框架频频死循环、上下文爆炸而束手无策?我的新专栏 从0 开始构建 Agent Harness 将带你:

  • 抛弃臃肿框架,回归“驾驭工程 (Harness Engineering)”的第一性原理
  • 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等,复刻极简OpenClaw
  • 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
  • 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
  • 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码,开启从 0 开始构建Agent Harness 的实战之旅。


还在为“复制粘贴喂AI”而烦恼?我的新专栏 AI原生开发工作流实战 将带你:

  • 告别低效,重塑开发范式
  • 驾驭AI Agent(Claude Code),实现工作流自动化
  • 从“AI使用者”进化为规范驱动开发的“工作流指挥家”

扫描下方二维码,开启你的AI原生开发之旅。


商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求,请扫描下方公众号二维码,与我私信联系。