← 博客

从会用到用好 Agent:理解原理,优化科研工作流

写在前面:为什么要理解 Agent 的原理?

这篇文章不是写给第一次接触 AI Agent 的读者的。假设你已经使用过 ChatGPT、豆包这样的 AI 助手,也可能尝试过 WorkBuddy、Codex 等 Agent,知道它们不仅能回答问题,还能够搜索资料、读取文件、编写代码,甚至独立完成一系列复杂任务。

我们尤其希望这篇文章能够帮助已经开始使用 Agent 的科研工作者,包括高校老师、研究生,以及其他需要大量处理文献、数据和文字的知识工作者。

对于这些读者,从我个人的经历出发,大家可能有两个共同的困惑。

第一个困惑是:怎样才能把 Agent 用得更好? 我们或多或少已经见识过 Agent 的能力,也经常能看到 AI 公司展示的惊人成果。就在 2026 年 10 月,OpenAI 一次性公开了 700 多份由模型生成的数学研究手稿,涉及数百组数学研究成果;Anthropic 的 Claude 在 11 天内完成了费马大定理的形式化证明,使这项著名定理的完整证明可以由计算机检验;一项发表于《Nature》的研究中,AI Agent 甚至已经能够阅读数百篇文献、提出科学假设,并根据真实实验结果不断修正自己的判断。但在实际使用中,Agent 的表现却未必总是令人满意。我们希望知道这些问题为什么发生,以及怎样通过调整自己的工作方式,让 Agent 更稳定、更有效地完成任务。

第二个困惑是:怎样才能跟上不断发展的 AI 技术?仅仅回顾 2026 年的前九个月,AI 领域就已经出现了一波又一波的热潮。年初,OpenClaw 突然爆火,掀起全民养龙虾热潮;与此同时,Skills 成了新的热门话题,蒸馏同事、skills市场,大家都在焦虑的用各种skills。3 月,Andrej Karpathy 发布 Autoresearch,展示了让 Agent 自己运行实验、不断改进模型训练代码的可能性;到了 6 月,Agent Memory 又成为一个重要的讨论方向,人们开始研究怎样让 Agent 记住过去的经验;最近几个月,RSI(Recursive Self-Improvement,递归自我改进)又受到关注,研究者开始发布让 Agent 自动改进自己的运行框架。对于并不从事 AI 研究的普通用户来说,要逐一学习这些新东西,既耗费时间,也很难判断哪些是真正有价值的技术进步,哪些只是已有技术的重新包装。

我认为,解决这两个问题的一个共同起点,是理解 Agent 背后的基本运行原理。

尽管今天的 Agent 看起来越来越复杂,但许多看似不同的功能,都可以还原到几个相对稳定的环节。我们不需要成为 AI 工程师才能理解这些机制。就像我们不必亲自制造汽车,也可以通过理解发动机的基本原理,更好地判断汽车的问题出在哪里。

更重要的是,一旦理解了这些原理,我们就有了一套可以反复使用的分析框架。当 Agent 表现不好时,可以尝试判断:究竟是模型能力不足、提供的信息不够,还是执行环境存在限制?当一个新的 AI 概念出现时,也可以将其拆解到底层原理上去理解。

这也是本文的核心思路:与其不断追逐新的工具和概念,不如先理解那些相对不变的基本原理,再从原理出发理解新技术、改进自己的工作流。

全文分为三个部分。第一部分从最简单的大模型输入和输出开始,逐步解释多轮对话、工具调用和 Agent Loop,建立对 Agent 运行机制的基本理解。第二部分以大模型(Model)、上下文(Context)和执行框架(Harness)为线索,讨论如何选择合适的工具、管理研究资料,以及改进日常科研工作流。第三部分再回到当前流行的 AI 概念,尝试用同一套框架理解 Skills、Memory、MCP 和 Multi-Agent 等技术,看看它们究竟在解决什么问题。

希望读完这篇文章之后,你不仅能够更好地使用今天的 Agent,也能够在未来面对新的 AI 产品和概念时,更快地理解它们,并判断它们是否值得被引入自己的工作。

第一部分 · 理解原理

从大模型到 Agent:它究竟是如何工作的?

2022 年底,ChatGPT 刚刚出现的时候,我们对它的印象其实很简单:输入一段文字,它就会返回一段文字,也就是 text in, text out。如果暂时不考虑模型内部复杂的计算过程,我们可以把它理解成一个黑箱:给定一段输入,模型根据输入的信息生成相应的输出。

把大模型看作文字黑盒:输入文本,经 LLM 生成输出文本
把大模型看作文字黑盒:输入文本,经 LLM 生成输出文本

几年过去了,今天的 Agent 已经能够完成远比聊天复杂的任务。它不仅可以回答问题,还能够搜索和下载论文、编写和运行代码、分析数据,甚至围绕一个研究目标持续工作几个小时。表面上看,今天的 Agent 和最早的 ChatGPT 似乎已经是两种完全不同的东西。

但有趣的是,支撑这些功能的大语言模型,仍然可以从那个最简单的输入输出过程来理解。虽然今天的大模型已经能够处理图片、语音等多种模态,也具备了更强的推理和工具使用能力,但就本文讨论的 Agent 而言,我们仍然可以先把模型简化成一个根据输入的上下文生成输出的黑箱。

那么,一个原本只能生成文字的模型,究竟是怎样获得读取文件、执行代码乃至自主完成复杂任务的能力的?

要回答这个问题,我们不妨采用一种类似于经济学建模的思路:暂时放下那些复杂的产品功能,从最简单的模型出发,逐步引入新的机制,看看每一步究竟解决了什么问题。最终我们会发现,许多看起来截然不同的 Agent 产品,其实可以用一套相对简单的基本框架来理解。

我们先从一次最简单的大模型调用开始。

1.1 从一次模型调用到多轮对话

大模型不等于 Chatbot

上一节我们把大语言模型(LLM)看作一个简单的黑箱:给定一段输入,模型生成相应的输出。那么,怎样才能把这个黑箱变成我们日常使用的 ChatGPT 这样的聊天机器人(Chatbot)呢?

最简单的方法,就是在模型外面增加一个能够与用户交互的程序。比如,我们在 ChatGPT 中输入输入:

请解释一下什么是大语言模型。

LLM 输出:

大语言模型是一种通过大量文本训练出来的模型……

这就是最基础的 chatbot。

但拆开来看,背后其实涉及两个不同的部分。

第一个部分是大语言模型(LLM),负责根据输入的信息生成回答。第二个部分是聊天程序(Chatbot),负责接收用户输入、调用大模型,并将模型生成的内容展示给用户。换句话说,我们平时看到的 ChatGPT 聊天界面,并不是大模型本身,而是一个建立在大模型之上的应用程序。

在实际运行时,聊天程序通常通过 API(应用程序编程接口)与模型服务进行通信。我们暂时不需要理解 API 的具体技术细节,只需要知道,它提供了一种让程序向模型发送请求、再接收模型返回结果的方式。比如,当我们发送一条消息时,聊天程序会将用户的问题以及必要的指令一起交给模型;模型生成回答后,程序再将结果展示在聊天界面上。

为什么要特意区分模型和外部程序?因为接下来我们会发现,从最简单的单轮对话,到多轮对话、记忆,再到工具调用和 Agent,许多功能的实现,都离不开模型之外的程序逻辑。 大模型负责根据已有信息生成输出,而外部程序则决定应该向模型提供什么信息、如何处理模型的输出,以及如何将它与外部环境连接起来。

理解了这个区别,我们就可以进一步研究:当用户发送一条消息时,程序究竟向模型传递了哪些信息?模型又是怎样生成一次回答的?

从一次模型调用开始

我们先研究一次最简单的模型调用:用户提出一个问题,模型生成一个回答。

一次最简单的模型调用(Model Call)就是:

User: 什么是 LLM?
Assistant: LLM 是 Large Language Model,大语言模型……

单轮对话是LLM运作起来的核心,也是理解LLM到agent的”最小单位“,再往下的所有部分都建立在单轮对话的基础上。

单轮对话:输入上下文包含系统提示和用户消息,LLM 据此生成助手回答
单轮对话:输入上下文包含系统提示和用户消息,LLM 据此生成助手回答

这里有两个值得注意的地方。

首先,大模型并不是像传统搜索引擎那样,从数据库中查找一段现成的答案。它的基本工作方式,是根据输入的信息,利用训练中学到的知识和规律,逐步预测并生成后续内容。因此,模型生成什么样的回答,不仅取决于它自身的能力,也取决于这一次调用时,我们向它提供了什么信息。

这些提供给模型的信息,就构成了我们经常听到的上下文(Context)。它可以包括用户当前的问题、系统预先设置的指令,以及之前的聊天记录、工具返回的结果等。模型一次能够处理的信息总量存在上限,这个限制通常被称为上下文窗口(Context Window),其容量一般以 Token 为单位衡量。我们可以暂时把 Token 理解为模型处理文字时使用的基本单位。

为什么要区分单轮对话和一次模型调用?因为讲到下面的 tool call 大家就会发现:一轮用户交互、一次模型调用和一次工具调用,是三个不同的计数单位。 在最简单的聊天应用里,一轮提问恰好对应一次模型调用;但在 Agent 里,一轮任务通常包含多次模型调用和多次工具调用,而且它们的数量不一定相同。

多轮对话

多轮对话看起来像这样:

User: 我正在写一个关于 LLM 到 Agent 的教案。
Assistant: 好的,可以从 Chatbot、Tool Call、ReAct 三部分讲起。

User: 那你帮我展开第一章。
Assistant: 第一章可以从单轮对话、多轮对话和上下文记忆讲起……

为什么模型知道”那你帮我展开第一章“的第一章指的是什么?是因为模型记住了我和他的对话吗?

No!模型没有记忆,只有上下文窗口:

第 2 轮输入 = 系统提示 + 第 1 轮用户消息 + 第 1 轮助手回答 + 第 2 轮用户消息

也就是说,多轮对话本质上是:把历史聊天记录拼接进新的 prompt 里,换句话说,每一轮对话之间都是独立的,这也就是为什么说LLM是一个无状态(stateless)的机器,每一次模型调用对它来说都像是全新的开始。

多轮对话:上一轮的提问与回答被加入下一轮输入上下文
多轮对话:上一轮的提问与回答被加入下一轮输入上下文

到这里,我们其实已经能够理解一个聊天机器人是怎么运行的了。

第一,大模型每一次生成回答,都依赖当前输入的上下文;第二,多轮对话并不是模型突然拥有了人类一样的记忆,而是外部程序把聊天历史重新提供给模型;第三,让大模型效果更好的一个至关重要的事情:下一次调用大模型的时候,应该给它提供哪些信息?

1.2 Tool Call:大模型如何开始行动

上一节我们已经知道,Chatbot 通过不断向大模型提供历史对话,就能够实现连续的多轮交流。但到目前为止,无论我们怎样组织上下文,大模型仍然只能生成回答。如果我们希望它不只是告诉我们应该怎么分析数据,而是真的打开数据集、运行回归;不只是告诉我们可以去哪里找论文,而是真的搜索并下载 PDF,又该怎么办?

一个很自然的想法是:既然大模型自己不能执行这些操作,能不能让外部程序替它执行?

我们知道,程序代码本身也是文本,而大模型恰好非常擅长理解和生成文本。比如,我们可以让模型写出一段 Python 代码,用来读取数据、运行回归并保存结果。但生成代码和执行代码是两回事:模型可以告诉我们应该运行什么,却不能仅仅通过生成这些文字,就让代码在电脑上运行起来。

那么,我们能不能更进一步,让模型不仅生成代码,还能够告诉外部程序应该执行什么操作?比如,模型提出“运行这段 Python 代码”,外部程序就负责真正地执行它;模型提出“读取这个文件”,程序就去读取文件,并把内容返回给模型。

这就是工具调用(Tool Call)的基本思路:大模型根据任务决定要使用什么工具、提供什么参数,外部程序负责实际执行操作,再将结果返回给模型。这样一来,模型虽然仍然只负责处理输入和生成输出,却可以借助外部工具间接地操作真实世界。

为了理解这种分工,我们可以把一个基于大模型的 Agent 简单地拆成三个部分:

  • 大脑(Model):负责理解用户的目标,根据已有信息判断下一步应该做什么。
  • 记忆(Context):指模型当前能够获得的信息,包括用户要求、历史对话以及工具执行的结果。
  • 身体(Harness):负责组织模型调用、管理工具和执行环境,在必要时执行模型提出的操作,并将结果提供给模型。
Agent 的组成:记忆 Context 输入给大脑 LLM,大脑通过身体 Harness 调用工具,结果再写回记忆
Agent 的组成:记忆 Context 输入给大脑 LLM,大脑通过身体 Harness 调用工具,结果再写回记忆

Anthropic是这样定义Harness的:An agent harness (or scaffold) is the system that enables a model to act as an agent: it processes inputs, orchestrates tool calls, and returns results.

这三个部分并不是不可分割的整体。大模型可以来自不同的开发商(可以用gpt、可以用claude、可以用deepseek),也可以自己部署在本地;Harness 同样可以运行在用户自己的电脑上,也可以运行在远程服务器上。只要接口和工具调用方式兼容,同一个 Harness 就可以使用不同的大模型,同一个模型也可以运行在不同的 Harness 中:我可以用claude code(harness)配deepseek(模型);我也可以用pi(harness)配gpt-6.1-sol(模型)。

从“最后一行就是命令”到结构化的 Tool Call

上一节的内容其实没有讲清楚一个点:大模型生成的都是输出,Harness 怎么知道哪些内容是给用户看的回答,哪些内容是需要执行的操作?

举个例子,假设我们希望 Agent 查看当前文件夹的位置。大模型可能生成下面两种内容:

我想查看当前文件夹的地址是什么。

或者:

pwd

这两段内容表达了类似的意图,但对计算机来说却有很大的区别。pwd 是一条可以在 Linux 或 macOS 终端中执行的命令,运行后能够返回当前工作目录的路径;而第一句话只是普通的自然语言,不能直接作为终端命令来执行。

那么,一个最简单的想法是:我们能不能提前告诉大模型,每次需要执行操作时,都把命令放在回答的最后一行?比如:

我需要查看当前文件夹的位置。
pwd

这样,Harness 只需要提取模型输出的最后一行,再把它交给终端执行,就可以让大模型间接操作电脑了。

这个办法看起来很简单,但也很脆弱。比如,大模型不小心在 pwd 后面加了一个句号,变成 pwd。,终端就可能无法识别;如果模型在命令后面又补充了一句“等待执行结果”,Harness 提取到的最后一行就不再是需要运行的命令了。

更重要的是,如果我们希望 Agent 不仅能运行终端命令,还能够读取文件、编辑文档、搜索网页,那么问题就更复杂了。Harness 不仅需要知道模型想不想执行操作,还需要知道它想使用哪个工具,以及应该向这个工具传递哪些信息。

这就是结构化工具调用(Tool Call)要解决的问题,也是让大模型从聊天搭子走向干活牛马的关键一步。

Tool Call 对比:上方是靠“最后一行就是命令”的脆弱约定会解析失败,下方是结构化 JSON 明确指定工具名和参数
Tool Call 对比:上方是靠“最后一行就是命令”的脆弱约定会解析失败,下方是结构化 JSON 明确指定工具名和参数

它的基本思路是:提前为大模型定义一组可以使用的工具,包括每个工具的名称、功能以及需要的参数。当模型判断某项任务需要使用工具时,就按照约定的结构生成一个工具调用请求,而不是只输出一段普通文字。

例如,我们可以提前告诉模型,它有一个叫 execute_bash 的工具,作用是在终端中执行命令,需要提供一个名为 command 的参数。

当用户要求查看当前文件夹的位置时,模型就可以生成这样一个结构化请求(这里用简化的 JSON 表示):

{
  "name": "execute_bash",
  "arguments": {
    "command": "pwd"
  }
}

这一小段内容看起来像代码,但我们并不需要学会编写它。只要看懂两个地方就够了:

name 表示调用哪个工具。 这里的 execute_bash 告诉 Harness,模型希望使用终端执行命令。

arguments 表示传递给工具的参数。 这里的 command: "pwd" 告诉 Harness,具体要执行的命令是 pwd。

如果模型希望使用文件编辑工具,就可以指定另一个工具名称,并提供文件路径、修改内容等参数。这样,Harness 就不需要再去猜测模型输出的哪一行是命令,而是可以根据结构化的信息,识别模型提出的操作请求。

这个时候,harness就会打开bash终端,然后运行命令:

pwd

有了 Tool Call,大模型就不再只能依赖已有知识回答问题,而是可以借助外部工具获取新的信息,或者执行实际操作。但违反直觉的是,从工具调用的诞生,到agent工具大行其道,其实中间隔了很长时间。姚顺雨的经典Agent框架ReAct是在2022年10月提出的,而openai在2023年6月才正式推出面向开发者的 Function Calling 接口,当时还是GPT-4系列模型。后面等到大众熟知的Devin、Cursor Agent已经过去一年多了。到Manus红遍国内外已经到2025年。

从Tool Call到agent的时间线
从Tool Call到agent的时间线

为什么呢?因为一开始的工具调用大家并没有想到可以用来做agent,当时主要的目的是补充模型训练好之后参数就固定,无法获取外界最新知识的这个问题。于是大量被用来查天气、做计算和搜索。

chatbot和现在大家熟知的agent工具,主要的区别在于模型不可能总是在开始时就准确知道接下来应该执行的每一步。它需要根据操作的结果,不断决定下一步该做什么。

工具调用解决了模型如何执行操作的问题,但怎样让模型围绕一个目标,持续地采取行动、观察结果并调整下一步行动呢?

这就是我们接下来要介绍的 Agent Loop。

1.3 Agent Loop:从一次操作到完成复杂任务

上一节我们解决了大模型如何调用工具的问题。但仅仅能够执行操作,还不足以让 Agent 自主完成一项复杂任务。

我们不妨先想一想,人类是怎样完成一项复杂任务的。

假设你被带到一片荒野,需要通过钻木取火生起一堆火。你会怎么做?

首先,你需要观察周围的环境:有没有合适的木头?木头是否干燥?天气是否潮湿?获得这些信息后,你才会开始判断应该使用哪些材料、采取什么方法。

接下来,你开始尝试钻木取火。但第一次尝试可能并不成功。于是你需要根据结果重新判断:是木头太潮湿了,还是方法不合适?如果木头太湿,就尝试寻找更干燥的材料;如果已经出现火星却没能引燃,就需要调整下一步的操作。

这个过程可能会反复很多次,直到最终成功生火。

大家会发现,在整个过程中,我们其实一直在重复几个基本动作:观察环境、根据已有信息作出判断、采取行动,然后根据行动的结果重新观察和判断。

而且,每一次行动都可能改变我们所处的环境,也可能让我们获得新的信息。因此,我们下一步做什么,并不是在任务开始时就完全确定的,而是取决于前面采取了什么行动,以及这些行动产生了什么结果。

现在,我们再把这个过程放回大模型身上。

回忆一下上一节介绍的 Tool Call。虽然大模型不能像人类一样直接观察电脑上的文件和程序状态,但它可以通过工具获取信息。例如,模型可以调用文件读取工具查看代码,调用终端运行程序,再从工具返回的结果中获得报错信息。

对 Agent 来说,观察环境本身也可能需要一次工具调用。重要的不是严格区分哪个动作属于“观察”、哪个动作属于“行动”,而是理解:模型可以通过工具获得新的信息,再根据这些信息决定下一步应该做什么。

比如,用户告诉 Agent:“请检查这个 Python 项目里的报错,修复问题,并确保程序能够正常运行。”

Agent 可能首先调用工具查看项目中的文件,判断哪些代码与问题有关;接着运行程序,发现出现了一个报错。模型根据报错信息判断可能的原因,然后调用文件编辑工具修改代码,再次运行程序。

如果程序仍然报错,它就需要根据新的错误信息继续分析;如果测试通过,就可以向用户汇报任务已经完成。

这个过程并不是让模型在最开始就生成一份完整的操作清单,然后交给 Harness 机械地执行。相反,每次工具执行后的结果,都会成为模型下一步判断的依据。

在技术实现上,Harness 将用户的任务、已有的上下文,以及工具执行结果提供给大模型。模型根据这些信息生成下一步的操作请求,Harness 执行操作,再将新的结果放回上下文,重新调用模型。

这样,模型与外部环境之间就形成了一个不断重复的循环:

判断下一步(Reason)→ 执行操作(Act)→ 观察结果(Observe)→ 再次判断……

这就是 Agent 最核心的运行机制,我们通常称之为 Agent Loop。

Agent Loop:模型决定下一步,Harness 执行工具,将结果加入上下文后再次调用模型,完成或停止时向用户返回结果
Agent Loop:模型决定下一步,Harness 执行工具,将结果加入上下文后再次调用模型,完成或停止时向用户返回结果

实际上,早在 2022 年,Shunyu Yao 等人就提出了一个非常有代表性的框架:ReAct:Synergizing Reasoning and Acting in Language Models。

ReAct 是 Reasoning(推理)和 Acting(行动)的组合,它的核心思想正是让大模型交替进行推理与行动,并利用外部环境返回的观察结果,不断更新自己的判断。这样,模型不需要提前规划好所有操作,而是可以随着任务的推进,逐步决定下一步应该做什么。

这里还可以回顾一下我们在 1.1 中介绍的“一次模型调用”。对于用户而言,他可能只发送了一条指令,但 Agent 在执行任务的过程中,往往需要反复调用大模型,并在中间执行多次工具调用。每次调用时,模型获得的上下文都可能不同,因为其中加入了之前操作所产生的新信息。

所以,Agent Loop 并没有改变大模型根据输入生成输出的基本工作方式。它只是通过 Harness 将多次模型调用和外部工具连接起来,使模型能够围绕同一个目标不断采取行动,并根据反馈调整后续操作。

从这里我们终于能够理解,为什么一个原本只能生成文本的大模型,可以逐步完成如此复杂的任务。

Tool Call 让模型能够采取行动,而 Agent Loop 让这些行动能够根据反馈持续进行,直到任务结束。

不过,这里还有一个有趣的问题可以留给大家思考:如果 Agent Loop 可以不断循环,那么它究竟是怎么知道什么时候应该停止的?

提示:回忆一下,Harness 是怎样区分模型的普通回答和工具调用请求的。

小结:Agent 的三个核心部分

从这里我们终于能够理解 Agent 的三个核心部分分别在干什么:

  • 大脑(Model):理解目标,根据现有信息决定下一步行动。
  • 记忆(Context):保存任务要求、过去执行过的步骤,以及工具返回的结果,让大模型知道之前发生了什么。
  • 身体(Harness):组织整个执行循环、调用实际工具、收集反馈,并管理权限和运行环境。

这是一套简化的理解框架。严格来说,Context 并不是一个与 Harness 完全独立的软件模块,通常也需要由 Harness 负责组织和管理。但这样的划分可以帮助我们理解:模型负责作出判断,上下文提供判断所需的信息,Harness 则负责让整个系统真正运转起来。

不过,这里可能还有一个值得思考的问题:既然 ReAct 早在 2022 年就已经提出,工具调用和 Agent Loop 的基本原理也并不复杂,为什么今天的 Agent 能够完成越来越复杂的任务,甚至围绕同一个目标持续工作几个小时,而早期的 Agent 却很难做到?

原因在于,理解 Agent 的运行原理,并不意味着我们已经解决了让 Agent 可靠运行的所有问题。

一方面,大模型自身的能力在不断进步。早期的模型即使能够调用工具,也可能选错工具、提供错误的参数,或者无法正确理解工具返回的结果。随着模型训练越来越重视推理、工具使用和多步骤任务,模型不仅更善于决定下一步行动,也更能够根据执行结果发现问题、调整计划。

另一方面,Harness 也在不断改进。从最初简单的工具执行,到今天更加完善的上下文管理、错误处理、权限控制和任务状态管理,外部系统能够为模型提供更可靠的执行环境,让模型可以持续尝试、检查结果,并在遇到问题时继续推进任务。

因此,今天 Agent 能力的进步,并不只是因为大模型变得更加聪明,也不只是因为出现了某种新的工具调用方式,而是模型能力与外部执行系统共同改进的结果。

理解了这一点,我们就有了一套分析 Agent 的基本框架。下一次当 Agent 无法完成任务时,我们可以尝试判断:究竟是模型本身的能力不足,还是提供给模型的信息不够充分,抑或是 Harness 无法有效地执行和管理任务?

这也自然引出了本文的第二部分:既然我们已经理解了 Agent 的基本运行机制,那么应该怎样从 Model、Context 和 Harness 这三个方向入手,把自己的 Agent 用得更好?

第二部分 · 实际应用

理解了原理,我们该如何用好 Agent?

上一部分我们把 Agent 拆解成了三个核心部分:大脑(Model)、记忆(Context)和身体(Harness)。有了这套框架,我们就可以尝试从原理出发,思考怎样让 Agent 更好地参与自己的日常工作。

一个 Agent 表现不好,可能是因为模型能力不足,也可能是因为它没有获得完成任务所需的信息,或者缺少合适的工具和执行环境。这三种问题对应着不同的改进方式。因此,我们接下来就分别从 Model、Context 和 Harness 三个方面,讨论如何改善 Agent 的实际使用效果。

2.1 Model:怎样选择合适的模型

首先是大脑,也就是大语言模型。模型自身的能力是决定 Agent 能够完成多复杂任务的重要因素。如果模型无法正确理解一个问题,即使我们给它提供了充足的信息和完善的工具,也很难得到理想的结果。

2026 年,OpenAI 和 Anthropic 相继公布了令人惊讶的数学研究成果。例如,OpenAI 一次性公开了数百组由前沿模型产生的数学研究结果,Anthropic 的 Claude 则在 11 天内完成了费马大定理的计算机形式化证明。这些成果让我们看到了前沿模型的能力已经发展到什么程度。

不过,对于日常科研工作来说,我们未必总需要最强大的模型。让 Agent 整理一份数据、运行一段 Stata 代码,和让它从零复现一篇顶刊论文,对模型能力的要求显然不同。选择模型时,最重要的问题是什么样的模型最适合我们正在做的任务。

那么,我们应该从哪些方面评价一个模型?

模型规模:知识广度

首先是知识广度。 对于科研工作者而言,我们希望大模型能够掌握广泛的背景知识,熟悉不同领域的理论、研究方法和学术文献。比如,当我们和 Agent 讨论一个劳动经济学问题时,自然希望它不仅了解劳动经济学的基本理论,也知道相关的计量方法,甚至能够联系其他领域的研究。

一个比较直观的参考指标是模型的参数量(Parameters)。我们可以把大模型的训练理解成一个从海量数据中学习、压缩知识和规律的过程。一般而言,模型规模越大,能够学习和表示的知识与复杂关系就越多。 因此,参数量可以作为我们理解模型知识容量的一个粗略指标。

这里有一个值得了解的技术细节:今天许多大模型采用了 MoE(Mixture of Experts,混合专家)架构。对于这类模型,我们通常需要区分两个数字:总参数量(Total Parameters)和激活参数量(Active Parameters)。前者反映整个模型的参数规模,后者表示模型在处理一个 Token 时实际参与计算的参数规模。

例如,DeepSeek V4 Pro 拥有 1.6 万亿(1.6T)总参数量,但每个 Token 仅激活约 490 亿(49B)参数;DeepSeek V4 Flash 则拥有 2840 亿(284B)总参数量、约 130 亿(13B)激活参数量。Kimi K3 的总参数量更是达到了 2.8 万亿(2.8T),激活参数量约为 1040 亿(104B)。相比之下,我们在一些自然语言处理研究中使用的 BERT-base 只有约 1.1 亿参数。今天最大的开源模型,其总参数量已经是 BERT-base 的两万多倍。

为什么需要区分总参数量和激活参数量?因为 MoE 模型在生成每个 Token 时,并不需要动用全部参数。它可以通过稀疏激活的方式,在保持较大模型容量的同时,减少每一步计算所需的资源。因此,相比总参数量,激活参数量通常与每个 Token 的计算成本有更直接的联系。

对于实际使用,我们通常用 TPS(Tokens per Second,每秒生成的 Token 数量)来衡量模型的输出速度。激活参数量较小的模型,往往更容易实现较快的推理速度,但实际表现还取决于硬件、模型架构和推理优化等因素,不能仅凭参数量判断。

所以,我们可以先建立一个简单的认识:模型规模越大,知识广度越大

思考强度:推理能力

除了知识广度,另一个重要的维度是推理能力(Reasoning)。一个模型知道很多知识,并不意味着它一定能够解决复杂的问题。比如,模型可能熟悉双重差分法(Difference-in-Differences)的定义,也知道平行趋势假设是什么,但如果我们给它一篇真实的论文,让它判断作者的识别策略是否成立,就需要它进一步分析和推理。

那么,怎样才能提高模型解决复杂问题的能力呢?

早在 2022 年,研究者就发现,让大模型在回答问题时先生成中间推理步骤,而不是直接给出答案,可以显著改善它在数学、逻辑等任务上的表现。这种方法被称为思维链(Chain-of-Thought,CoT)。直观上看,一个需要多步推导的问题,如果模型能够先把问题拆解成若干步骤,逐步分析和检查,就可能比直接生成答案更准确。

到了 2024 年 9 月,OpenAI 发布了 o1,进一步推动了这一研究方向。OpenAI 发现,通过强化学习训练模型,使它学会更加有效地利用中间推理步骤,并在回答前投入更多的计算资源,能够显著提高复杂任务的表现。一个重要的研究方向由此受到广泛关注:Test-time Scaling,即通过增加模型在推理阶段的计算量,进一步提高解决问题的能力。

2025 年 1 月,DeepSeek 发布了 R1,并公开了详细的技术报告,让外界能够更清楚地了解推理模型是怎样训练出来的。研究者通过强化学习,让模型在解决数学等问题时逐渐学会自我检查、重新评估已有判断,以及尝试不同的解题路径。在 DeepSeek-R1 等模型中,推理过程可以通过 <think>...</think> 这样的标记与最终回答区分开来。

不过,推理模型的关键并不是简单地让它输出更多文字,或者给思考过程加上一个 **<think>** 标签,而是通过训练,让模型学会更有效地利用这些额外的推理步骤。 这也是为什么一味要求普通模型“多想一点”,并不一定能取得与专门训练的推理模型相同的效果。

到了今天,思考强度已经成为许多大模型可以直接调整的参数。例如,GPT-6 Astra 的 API 提供了五个 Reasoning Effort 档位:low、medium、high、xhigh 和 max。这些档位决定模型在处理任务时投入多少推理计算资源。一般来说,更高的思考强度可以让模型在困难问题上进行更充分的分析,但也可能需要更多的 Token、更长的等待时间,以及更高的调用成本。

当然,思考并不是越多越好。对于简单的知识查询、信息提取或文字格式调整,较低的思考强度通常就足够了;而对于复杂的数学推导、研究设计、识别策略分析等任务,更高的思考强度可能带来明显的收益。即使面对困难问题,增加推理预算也不保证答案一定更准确。

因此,我们可以建立第二个直觉:模型规模帮助我们理解模型掌握知识的潜在容量,而思考强度帮助我们理解模型在解决当前问题时投入了多少推理资源。

工具调用与编程:Agentic 能力

另一个重要的评估维度,是模型的 Agentic 能力,也就是它能否借助外部工具,持续、可靠地完成一项任务。对于 Agent 来说,知道得多、想得深,还不一定意味着能够把事情做好这件事情在2025年年底到2026年的年初的模型竞赛中体现的最为明显:openai在持续迭代模型的思考能力,主攻解决复杂的数学和科学问题;而Anthropic发现模型的agentic能力也非常重要,于是opus4.6在claude code和openclaw里面展现出优秀的解决真实问题能力。

回忆一下第一部分介绍的 Agent Loop:模型需要不断判断下一步应该做什么,选择合适的工具,理解工具返回的结果,并根据反馈调整后续行动。因此,Agentic 能力不仅取决于模型能否正确调用工具,还取决于它能否在执行过程中发现和解决问题。

编程就是一个非常典型的例子。对于科研工作者来说,我们可能需要 Agent 编写 Python 或 R 代码、修改 Stata 程序、运行回归和处理数据。如果模型只是能够写出一段看起来正确的代码,却无法根据实际运行结果发现错误,那么它还很难成为一个可靠的科研助手。

比如,我们让 Agent 修复一段 Stata 程序。一个 Agentic 能力较强的模型,不仅能够阅读代码、理解报错,还能够主动检查数据中的变量名称,判断问题究竟来自代码还是数据,然后修改程序、重新运行并检验结果。这个过程需要的不只是编程知识,还包括工具使用、问题定位以及根据反馈不断调整行动的能力。

近几年,编程与工具调用能力已经成为各大模型厂商竞争的重要方向。一些相对高效的小模型,例如 DeepSeek V4.1 Flash 和 GLM-5.3 Flash,也能够以较低的成本完成不少编程和工具使用任务。不过,对于复杂的软件开发、困难的数学推理或需要长期自主执行的研究任务,能力更强的前沿模型通常仍然更值得优先尝试。

这里还需要注意一个细节:我们看到的 Agentic 表现,并不完全由模型决定。同一个模型放在不同的 Harness 中,由于可以使用的工具、上下文管理方式和执行环境不同,完成任务的效果也可能存在差异。因此,在比较模型的 Agentic 能力时,最好尽量保持 Harness 和任务环境一致。

说人话:沟通与表达能力

另一个容易被忽略的维度,是模型的沟通与表达能力。

我们使用 Agent 并不只是为了让它写代码,还经常需要它帮助我们解释论文、讨论研究思路、修改文章,甚至判断一个研究问题是否值得继续做。对于这些工作,模型能否自然、准确地理解和表达复杂的想法,同样十分重要。

从我自己的使用体验来看,不同模型在表达风格上确实存在明显差异。有的模型逻辑很强,但回答过于机械,写出来的文字不像人话;有的模型喜欢把简单的问题解释得非常复杂,还有的模型经常使用大量项目符号,看起来条理清楚,却缺少连贯的论述。对于需要大量写作的科研工作者来说,这些差异会直接影响我们的使用体验。

不过,好的沟通能力不仅意味着文字流畅、表达自然,还包括能否准确理解用户的要求、区分事实和推测,以及在信息不足时承认不确定性。尤其在科研工作中,一个能够清楚指出论证漏洞、说明自身判断依据的模型,往往比一个表达漂亮、却对所有观点都表示赞同的模型更有价值。

因此,评价模型时,我们不能只看数学和编程榜单,还应该关注它能否按照我们的要求进行准确、自然的交流。比如,可以让几个模型解释同一篇论文、修改同一段中文文章,比较它们在表达清晰度、论证严谨性和指令遵循方面的表现。

性价比:完成一项任务究竟需要多少成本?

最后是性价比。对于实际使用 Agent 的用户来说,这可能是最需要考虑的因素之一。

回忆一下第一部分的 Agent Loop:用户虽然只提出一次请求,但 Agent 可能在执行过程中反复调用模型,并使用大量工具。因此,一次复杂任务的成本,并不只取决于模型单次调用的价格,还取决于整个执行过程消耗了多少 Token,以及模型需要尝试多少次才能完成任务。

举个例子,假设我们让两个模型修改同一段代码。模型 A 的 Token 单价很低,但它反复修改、不断报错,最终需要尝试很多次才能完成任务;模型 B 的价格虽然更高,却能够迅速定位问题,一两次就完成修改。那么,模型 B 最终的使用成本反而可能更低。

因此,对于 Agent,我们更应该关注完成一项任务的总成本,而不只是每百万 Token 的价格。

除了价格,速度也是一个重要因素。前面我们介绍过 TPS(Tokens per Second),它反映模型生成文本的速度。但对于 Agent 来说,最终完成任务的时间还受到模型思考、工具执行、网络延迟以及错误重试等因素影响。一个每秒生成 Token 很快的模型,如果需要反复尝试才能解决问题,最终也可能比一个较慢但更可靠的模型耗时更长。

目前,不少国产模型在价格和速度方面都具有相当不错的竞争力。对于日常的数据整理、简单编程和批量信息处理,我们未必需要始终使用最昂贵的旗舰模型;但对于复杂的研究设计、程序架构或者高难度推理,使用更强的模型又可能减少错误和返工,反而更划算。

这也引出了一个很自然的思路:不同难度的任务,可以交给不同能力和价格的模型。 比如,让强模型负责复杂的规划和审核,让更经济的模型承担相对简单的执行工作。在一些情况下,我们还可以通过 Multi-Agent 的方式,让多个 Agent 分工协作。不过,多 Agent 并不一定节省成本,它也可能因为额外的沟通和协调增加开销。我们会在后面专门讨论这一点。

从我个人的使用体验来看,GPT-6 Astra 和 Claude Fable 5.1 在一些高难度推理和复杂任务中表现很好;国产模型中,我比较喜欢 Kimi K3,而 DeepSeek Flash、GLM Flash 等模型也很适合尝试处理日常、高频的任务。

最终,最适合我们的模型,不一定是排行榜上最强的,也不一定是 Token 单价最低的,而是那个能够以合理的时间和成本,稳定完成我们实际任务的模型。

如何选择适合我们的模型

我认为最有效的选型方法,是拿自己真正需要完成的任务,去比较不同模型的实际表现。

当然,模型厂和各大评测机构发布的模型评测非常重要,他们相当于一个基准:在coding benchmark上面表现更好的模型,大概率在日常使用中也不错。除此之外,我们可以自己整理一些任务作为测试,考察模型能力。

例如,我们可以选择一组有代表性的科研任务:让几个模型分别阅读同一篇论文并解释识别策略,修改同一段存在错误的 Stata 代码,或者根据同一份研究结果撰写英文摘要。在尽可能保持 Harness、输入资料和工具权限一致的条件下,比较各个模型的完成质量、耗时、成本,以及需要人工纠正的次数。

2.2 Context:怎样给模型提供有效的信息

除了模型本身的能力,另一个影响 Agent 表现的重要因素是上下文(Context)。

回忆一下第一部分介绍的大模型运行机制:模型每次生成输出,都依赖于当前提供给它的上下文。对于一个条件概率预测模型来说,模型自身的能力固然重要,但如果缺少完成任务所需的信息,再聪明的模型也很难作出正确判断。正所谓“巧妇难为无米之炊”,随着大模型的能力不断提高,怎样为它提供充分、准确的信息,也变得越来越重要。

例如,我们让 Agent 帮忙修改一段 Stata 程序。如果模型不知道数据集里有哪些变量、每个变量代表什么、程序原本想实现什么目的,即使它有很强的编程能力,也可能反复修改代码却始终无法解决问题。反过来,如果我们提前为它提供了数据说明、项目结构和研究目标,模型就更容易理解问题所在。

这正是上下文管理(Context Management)所关心的问题:怎样让模型在需要的时候,获得完成当前任务所必需的信息。

对于日常科研工作,我认为可以从两个方面入手:一是创造一个对 Agent 友好的科研环境,让它能够方便地访问和理解我们的资料;二是建立上下文管理的意识,在实际使用过程中,合理地控制提供给模型的信息。

创造一个 Agent-native 的科研环境

最近我们经常听到 Agent-native 这个词。虽然它在不同场景下有不同的含义,但在这里,我想用它表达一个简单的思想:尽可能把自己的科研资料和工作流程组织成 Agent 容易访问、理解和操作的形式。

首先是文件格式。大模型本身擅长处理文本,而对于 Agent 来说,结构清晰、能够直接读取的文本文件通常也最方便使用。因此,我们可以考虑尽量使用 Markdown 或 TXT 保存研究笔记,使用 LaTeX 编写学术论文,使用 CSV 等结构化格式保存需要直接处理的表格数据。

这并不是说 Word、Excel 或 PDF 不适合 Agent。今天的 Agent 已经能够借助工具处理这些格式,而且对于包含公式、图表和复杂排版的内容,保留原始文件往往十分必要。这里更重要的原则是:尽量减少 Agent 获取信息所需要的额外步骤,同时保留研究资料本身的完整性。 例如,对于一篇 PDF 论文,我们可以保留原始 PDF,同时提供能够搜索的文本版本,方便 Agent 快速定位相关内容。

其次是文件的组织方式。

Agent 通常可以通过文件读取、搜索和终端工具,在一个项目工作区中寻找需要的信息。因此,对于科研工作,我比较推荐以研究项目为单位组织文件夹,把数据、代码、论文、笔记和研究结果放在相对固定的位置。

例如,我们可以为一个研究项目创建独立的工作文件夹,在里面设置 data、code、papers、notes 等子文件夹,再提供一个 README.md,简单说明整个项目的研究目标、文件结构、重要数据和代码的用途。

这样,当我们让 Agent 修改一段代码时,它就不必每次都从头询问数据在哪里、哪些文件最重要,而是能够通过项目说明和文件搜索工具,逐步找到自己需要的信息。

这里还可以再进一步:对于一个持续几个月甚至几年的科研项目,我们可以让 Agent 帮忙维护一些总结性的 Markdown 文档,记录研究进展、重要决策、已经完成的工作,以及尚未解决的问题。

这些文档不只是为我们自己准备的,也是为下一次进入项目的 Agent 准备的。即使更换了模型,或者开启了一个全新的会话,新的 Agent 也可以通过阅读这些文件,快速了解项目的基本情况,而不必重新探索整个项目。

我自己也在尝试将这样的科研工作流程标准化,例如编写了一个 Research Engineering Skill,以及一套用于整理项目资料和保存工作进展的 Memory System。

这里有一个需要特别强调的区别:让 Agent 能够访问某个文件,并不意味着文件的全部内容已经进入模型的上下文。 文件仍然保存在本地或其他存储系统中,只有当 Agent 通过工具读取、检索相关内容时,这些信息才会被提供给模型。

因此,创造 Agent-native 环境的目标,并不是每次都把所有资料交给模型,而是让 Agent 在需要某项信息时,能够方便地找到并使用它。

建立上下文管理的意识

有了一个 Agent-friendly 的工作环境,我们还需要考虑另一个问题:在实际执行任务时,究竟应该让模型看到多少信息?

一个直观的想法是,既然模型需要足够的上下文,那么给它的信息是不是越多越好?

答案并不一定。

2024 年发表在 TACL 上的一篇论文 Lost in the Middle: How Language Models Use Long Contexts 研究发现,在一些长文本问答任务中,当关键信息位于上下文中间时,模型提取和利用这些信息的表现可能明显下降。虽然如今的模型已经拥有更长的上下文窗口,也在不断改善长上下文能力,但这项研究提醒我们:模型能够接收很长的文本,并不意味着它总能同样有效地利用其中的每一条信息。

这就产生了一个取舍(Trade-off):更多的上下文可能为模型提供更充分的信息,但也可能引入无关内容,增加模型识别和利用关键信息的难度。

例如,我们希望 Agent 根据某篇论文修改回归代码,就没有必要把整个研究项目中所有历史对话、全部文献和过去几个月的调试记录都提供给它。相反,我们可以让它先阅读项目说明,再根据当前任务寻找相关的数据和代码,只有在需要时才进一步读取其他资料。

从这个角度看,好的上下文管理不是尽可能多地提供信息,而是让模型在合适的时候获得合适的信息。

这一思想还可以应用到日常的会话管理中。

我们平时使用 Agent 时,很容易养成一种习惯:在同一个会话里不断交代新的任务。上午让它修改数据,下午让它搜索文献,晚上又让它讨论研究设计。时间一长,上下文中就可能积累大量与当前任务无关的信息,包括过去的对话、已经完成的操作,以及工具返回的各种输出。

因此,我比较推荐一个简单的原则:不同的任务尽量使用不同的会话,同一个任务则根据需要保留、整理或交接上下文。

如果我们刚刚完成数据清洗,接下来准备研究另一个完全不同的问题,就可以直接开启新的 Agent 会话。这样,新的模型调用就不必携带之前那些已经不再相关的上下文。

但如果一项工作需要持续很长时间,例如一个复杂的科研项目,就不能简单地每隔一段时间把所有历史记录清空。毕竟,之前的工作可能已经形成了重要的判断和发现,丢掉这些信息同样会影响后续任务。

这时候就可以考虑两种常见的方法。

第一种是 Compaction(上下文压缩),也就是把已经积累的大量历史对话和工具结果整理成一份较短的摘要,保留重要的目标、结论与未完成事项,再让 Agent 继续工作。不过,摘要难免丢失细节,因此需要注意保留原始文件和关键证据。

第二种是 Handoff(任务交接)。我们可以让当前 Agent 在结束任务时,将已经完成的工作、重要发现、相关文件路径和下一步计划整理成一份文档,再开启一个新的 Agent,让它根据这份文档继续推进任务。

例如,假设我们让 Agent 帮忙完成一项实证研究的数据清洗工作。在任务结束时,可以要求它记录已经处理了哪些变量、使用了哪些清洗规则、生成了什么数据文件、哪些异常仍然没有解决。下一次我们需要继续分析时,就可以让新的 Agent 阅读这份工作记录,而不必重新经历之前的全部对话。

当然,交接文档并不一定能够完整保留过去的所有信息,尤其是那些没有记录下来的细节。因此,对于需要长期维护的科研项目,最可靠的方式往往是把重要的研究决策和结果直接保存到项目文件中,而不只是依赖某一次聊天记录。

回过头来看,无论是创建 Agent-native 工作环境,还是压缩上下文、进行 Handoff,背后的思想其实是相同的:将大量资料保存在模型能够访问的外部环境中,再根据当前任务,把真正需要的信息提供给模型。

这样,我们就不必指望一个 Agent 永远记住所有事情,而是通过更合理的信息组织和管理方式,让它能够在需要的时候找到正确的信息。

对于科研工作者来说,这可能是改进 Agent 使用体验最值得投入精力的方向之一。

2.3 Harness:怎样选择和配置执行环境

最后,我们来讨论 Agent 的身体,也就是 Harness。

前面我们已经知道,Harness 负责组织模型调用、管理上下文、执行工具,并维持整个 Agent Loop 的运行。因此,即使使用同一个大模型,不同的 Harness 也可能带来不同的使用体验。

例如,我们让两个 Agent 完成同一项科研任务:阅读一组论文、提取需要的信息,再运行一段 Python 代码进行分析。虽然两个 Agent 使用的是相同的模型,但如果其中一个能够方便地搜索文件、读取 PDF、执行代码,并在出错时保留必要的上下文,另一个却需要反复手动提供资料,那么它们最终的表现就可能相差很大。

现在有一种观点认为,随着大模型越来越聪明,Harness 的作用正在逐渐减弱。我认为这个观点有一定道理。早期模型的工具使用能力较弱,需要外部程序通过复杂的提示词和执行流程来弥补模型自身的不足。而今天的前沿模型已经能够更加自主地决定下一步行动,对这些额外引导的依赖可能有所下降。

一个很有代表性的例子是 Pi。它采用了相对极简的设计,默认只有读取文件、写入文件、编辑文件和执行终端命令四种核心工具,却仍然能够配合前沿模型完成复杂的编程任务。这说明,当模型足够聪明时,并不一定需要为它设计一套非常复杂的执行框架。

Databricks 在自家数百万行代码库的真实开发任务上做过一组对照实验:同一个模型、同样的思考强度,仅仅更换 Harness,每项任务的成本就可能相差两倍以上,而任务通过率基本相同。差异主要来自不同 Harness 每一轮重复传给模型的上下文量——例如,Opus 4.8 在 Claude Code 中每项任务累计传入的上下文中位数约为 742k tokens,换成 Pi 后约为 236k,相差约 3.2 倍。

相同模型、相同思考强度下,不同 Harness 每项任务重复传入模型的上下文总量(中位数):Pi 明显少于 Claude Code 和 Codex
相同模型、相同思考强度下,不同 Harness 每项任务重复传入模型的上下文总量(中位数):Pi 明显少于 Claude Code 和 Codex

来源:Benchmarking Coding Agents on Databricks' Multi-Million Line Codebase,Databricks,2026 年 7 月。

但这并不意味着 Harness 已经不重要了。尤其对于需要持续几个小时、跨越多个上下文窗口的任务,如何管理状态、保存进展、处理错误以及隔离执行环境,仍然需要 Harness 提供支持。一个好的 Harness,不一定是功能最多的 Harness,而是能够以尽可能简单、可靠的方式,让模型充分发挥自身能力的 Harness。

不同的 Harness,应该怎样选择?

目前比较有代表性的 Coding Agent 包括 Claude Code、Codex、Pi、Kimi Code 和 OpenCode。它们都能够让模型读取文件、执行命令、修改代码,但在功能设计和使用方式上存在不少区别。

本节涉及的代表性 Agent 产品:上排为六个 Coding Agent / Harness,下排为三个图形化 / 通用工作 Agent
本节涉及的代表性 Agent 产品:上排为六个 Coding Agent / Harness,下排为三个图形化 / 通用工作 Agent

标识来自各产品官网及 Lobe Icons 开源图标库,仅用于教学中的产品识别。

Claude Code 是 Anthropic 开发的 Coding Agent,也是我之前使用最多的工具之一。它提供了比较完整的默认功能,包括文件操作、上下文管理、Skills、Hooks 和子 Agent 等。相比极简框架,它会主动为模型提供更多工具和执行规则。我个人的感受是,Claude Code 对一些模型能够起到不错的辅助作用,让原本不太稳定的模型更容易完成复杂任务。当然,功能更多也意味着系统更复杂,可能增加上下文和工具调用的开销,具体是否值得还需要看任务。

Codex 则是 OpenAI 开发的 Coding Agent。它最吸引我的地方之一是图形化界面。除了终端和 IDE,Codex 还提供独立的桌面应用,可以比较方便地管理不同项目、查看 Agent 的工作进展,以及审查代码修改。对于不熟悉命令行的科研工作者来说,这种交互方式可能更容易上手。如果已经订阅了 ChatGPT,并希望使用 OpenAI 的前沿模型,Codex 是一个值得优先尝试的选择。

Pi 则走了另一条路线:尽量保持核心框架简单,把更多功能留给用户按需扩展。它支持多个模型提供商,也允许用户通过 Extensions 自定义工具、快捷命令、权限控制和上下文管理方式。我最近比较喜欢使用 Pi,一个重要原因就是我经常需要切换不同厂商的模型。相比功能非常丰富的官方 Agent,Pi 更像一个可以自己组装的工具箱。当然,这也意味着如果想使用更复杂的功能,往往需要自己安装和配置插件。

OpenCode 同样是一个支持多模型的开源 Coding Agent。它提供终端、桌面应用和 IDE 集成,并支持大量模型提供商。与 Pi 相比,它更强调开箱即用的完整功能。如果希望使用不同厂商的模型,又不想从零配置太多基础功能,OpenCode 也是值得考虑的选择。

国内厂商同样在开发自己的 Harness。例如,Kimi Code 提供 CLI、桌面应用和编辑器集成,DeepSeek 则推出了开源的 DeepSeek Harness(dsh),采用“Everything is a Plugin”的设计,让工具、模型和其他功能可以通过插件进行组合。

我自己尝试过早期的 dsh,感觉当时还有不少地方需要完善。不过,它的设计方向很有意思:尽可能将 Agent 的各个组成部分模块化,让用户根据需要自行配置。这样的设计可能更适合愿意折腾、希望深入理解 Agent 系统的开发者,而不一定是普通用户的第一选择。

前面介绍的主要是 Coding Agent,也就是以读取文件、执行代码和操作项目工作区为主要能力的 Agent。对于不熟悉编程的科研工作者,还可以考虑豆包工作、腾讯 WorkBuddy、阿里 Qoder 等图形化产品。这些应用通常更强调自然语言交互和完整的用户体验,希望用户不必理解命令行,也能够完成文档处理、资料整理和日常办公任务。

当然,这两类产品并没有严格的界限。今天的 Coding Agent 也在逐渐增加图形化界面,甚至能够制作 PPT、处理表格和完成日常办公任务。因此,我觉得没有必要纠结某个产品究竟属于哪一类,关键仍然是它能否方便、可靠地完成我们需要的工作。

这些 Harness 之间的差异,也可以在同一个模型上直接观察到。FrontierHarness Eval 这项测评固定使用 Kimi K3 模型、同一推理服务和同一任务环境,比较了 9 种 Harness 的 12 套配置,包括 Codex、Claude Code、Pi、Kimi Code、DeepSeek Harness 和 OpenCode。在 30 项软件开发任务上,各配置的通过率集中在 50%–66.7% 之间,差距并不算大;但每项任务的中位成本却从 1.05 美元到 18.34 美元不等。例如,Claude Code 与 DSH Creator 的通过率同为 63.3%,完成任务的中位成本却分别为 18.34 美元和 3.28 美元,相差约 5.6 倍。

FrontierHarness Eval:固定同一个 Kimi K3 模型,9 种 Harness 的 12 套配置在相同任务上的通过率与中位成本
FrontierHarness Eval:固定同一个 Kimi K3 模型,9 种 Harness 的 12 套配置在相同任务上的通过率与中位成本

来源:FrontierHarness Eval,Runta,2026 年 9 月。需要注意的是,这项测试每个配置只运行一次,结果可能受到模型接口适配和缓存机制的影响,适合用来说明差异的存在,不适合作为 Harness 的绝对排名。

同一个模型,为什么在不同 Harness 中表现不同?

这里还有一个值得讨论的问题。

前面我们提到,同一个 Harness 可以使用不同的大模型,同一个大模型也可以运行在不同的 Harness 中。但这是否意味着,我们可以随意组合 Model 和 Harness,而且完全不用担心兼容性?

答案当然不是。

首先,不同 Harness 提供给模型的工具和系统指令并不完全相同。模型需要根据这些信息决定如何行动,因此,同一个模型在不同 Harness 中可能采取不同的操作方式。

其次,不同 Harness 的上下文管理、工具执行和错误处理机制也存在差异。特别是在长时间任务中,如何压缩历史信息、保留关键结果、处理工具调用失败,都可能影响最终的任务完成质量。

这种差异在科研类任务上可能相当显著。普林斯顿大学的 HAL(Holistic Agent Leaderboard)榜单包含科研代码复现基准 CORE-Bench Hard。根据其公开数据,同一个 Claude 模型搭配专门的复现框架 CORE-Agent 与搭配 Claude Code,成绩可以相差约 18–36 个百分点:Opus 4.5 从 42.2% 提升到 77.8%,Sonnet 4.5 从 37.8% 提升到 62.2%。模型和任务完全相同,变的只是外面的 Harness。

最后,还有一个实际使用中很容易被忽略的问题:模型和 Harness 之间的适配,以及模型厂商提供的订阅和计费方式。

虽然很多模型都提供兼容 OpenAI 或 Anthropic 的 API 接口,使我们能够把它们接入第三方 Harness,但接口能够连接成功,并不意味着所有功能都能获得同样的支持。例如,模型的思考强度、上下文窗口、工具调用格式和缓存机制,都可能需要额外配置。

我之前经常通过 Claude Code 使用 Kimi 或 GLM,也尝试过直接使用它们各自的官方 Agent。一个很直观的感受是,不同组合在速度、稳定性和额度消耗上可能存在差异。特别是使用 Coding Plan 等订阅套餐时,我们需要区分官方客户端、第三方工具和独立 API 的计费规则,不能简单地认为接入同一个模型,使用额度就一定相同。

从原理上看,这并不奇怪。不同 Harness 对模型的调用方式、上下文组织和工具执行过程可能不同,而厂商也会针对自己的产品进行专门适配和优化。因此,使用某家模型时,先尝试它的官方 Harness,通常是一个合理的起点。但这并不意味着官方组合一定最优,实际表现仍然值得比较。

UC Berkeley 与 Arena 的一项研究(HarnessTax,2026 年 9 月)把 7 个模型分别放进 Claude Code、Codex CLI 和 Pi 三种 Harness 中,在 SWE-bench Lite 和 Terminal-Bench 2.0 两个基准上测试。结果很有启发性:同一个模型在不同 Harness 中的任务成功率通常相差不大(SWE-bench Lite 上平均在 ±2% 以内),但成本最多相差约 5 倍;而且在 12 组「模型 × 基准」的比较中,有 9 组是厂商自家之外的 Harness 取得了最高成功率——Claude 模型不一定在 Claude Code 里表现最好,GPT 模型也不一定在 Codex 里表现最好。

HarnessTax:同一个模型在 Pi、Codex、Claude Code 中的单次任务成本与成功率对比(SWE-bench Lite)
HarnessTax:同一个模型在 Pi、Codex、Claude Code 中的单次任务成本与成功率对比(SWE-bench Lite)

来源:HarnessTax: How Much Does the Harness Matter for Coding Agents?,UC Berkeley × Arena,2026 年 9 月。绿框标出每个模型成本最低和成功率最高的组合。

最后,怎样选择适合自己的 Harness?

对于没有太多编程经验,只希望让 Agent 帮忙处理文档、整理资料和完成日常办公工作的科研人员,我更推荐先从图形化产品入手,例如 Codex 的桌面应用,或者 WorkBuddy 等面向日常工作的 Agent。它们的优势是交互方式比较直观,不需要用户一开始就花费大量时间配置工具。

如果经常需要编写 Python、R 或 Stata 程序,处理科研数据,或者希望让 Agent 直接在项目文件夹中工作,那么 Claude Code、Codex 和 Kimi Code 这类 Coding Agent 就很值得尝试。虽然名字里带着 Coding,但它们已经不只是帮助程序员写代码的工具,也可以成为科研工作的重要助手。

如果已经具备一定的使用经验,希望自由切换模型、管理不同的订阅和 API,甚至自己开发工具和插件,那么 Pi、OpenCode 等更加开放的框架,可能提供更大的灵活性。

除此之外,对于科研工作,我认为还应该特别关注 Harness 的安全性和可控性。毕竟,Agent 可能直接访问我们的原始数据、运行程序,甚至修改文件。一个能够清楚展示执行过程、允许用户审查重要操作,并对文件和网络权限进行适当限制的 Harness,通常比一个功能很多、却让人不知道它在后台做了什么的 Harness 更值得信任。

总的来说,选择 Harness 和选择模型一样,没有一个适合所有人的标准答案。 我们不必因为某个新 Agent 很火就立刻更换工具,也不必为了增加几个功能而不断安装插件。更好的方法是从自己的实际工作出发,判断哪些功能是真正需要的,再选择一个能够稳定支持这些功能的执行环境。

Databricks 的测评还画出了一条值得参考的曲线:以每项任务的平均成本为横轴、任务通过率为纵轴,每个点代表一个「模型 × Harness × 思考强度」的组合,红色虚线是帕累托前沿——也就是在给定成本下能达到的最高通过率。可以看到,前沿上既有 OpenAI 和 Anthropic 的模型,也有开源模型(如 GLM 5.2);既有多功能 Harness,也有极简的 Pi。换句话说,不存在一个在所有预算下都最优的组合。更实际的问题是:在自己的预算和任务类型下,哪个组合离这条前沿更近。

Databricks 真实代码库测评:每个点是一个「模型 × Harness」组合,红色虚线为性能—成本帕累托前沿
Databricks 真实代码库测评:每个点是一个「模型 × Harness」组合,红色虚线为性能—成本帕累托前沿

来源:Benchmarking Coding Agents on Databricks' Multi-Million Line Codebase,Databricks,2026 年 7 月。

从这个角度看,用好 Agent 不只是给它配置一个聪明的大脑,还需要提供足够的信息,以及一个适合它开展工作的环境。Model、Context 和 Harness 共同决定了 Agent 最终能够做成什么事。

第三部分 · 理解新概念

用基本原理重新理解 AI 热词

在第一部分,我们从最简单的模型调用出发,逐步理解了 Agent 的运行原理;在第二部分,我们又从 Model、Context 和 Harness 三个方面,讨论了怎样把 Agent 用得更好。

现在,我们不妨用同样的框架,重新审视近几年 AI 领域出现的一些热门概念,包括 Skills、Agent Memory、MCP 和 Multi-Agent。它们听起来各不相同,但如果仔细分析,就会发现其中许多技术并没有改变大模型本身的工作原理,而是在上下文管理、工具使用和任务执行等环节进行了改进。

因此,遇到一个新的 AI 概念时,我们可以先问三个问题:它究竟改变了 Agent 的哪个部分?解决了什么原来存在的问题?对于我们的实际工作,又能带来多大的帮助?

3.1 Skills:按需加载的任务说明书

Skills 是近一年非常热门的概念。我们经常会看到各种各样的 Skills,有帮助 Agent 写论文的 AER-Skills、Nature-Skills,也有帮助 Agent 制作 PPT、处理数据、搜索文献的 Skills。安装这些 Skills,真的能够让 Agent 突然获得新的专业能力吗?

要回答这个问题,我们不妨先回想一下早期的大模型使用方式。

2023 年前后,提示词工程(Prompt Engineering)曾经非常流行。为了让大模型更好地完成任务,人们会精心编写各种提示词,告诉模型应该扮演什么角色、遵循什么流程、按照什么格式输出。有时,一段提示词甚至可以长达几千字。

从原理上看,Skills 和提示词工程其实有很紧密的联系。它们都在尝试通过提供额外的指令,引导模型按照特定的方法完成任务。Skill 并不是一种新的模型训练方式,也不会因为安装了一个 Skill,就直接改变大模型本身的知识和能力。

那么,既然我们已经有了 Prompt,为什么还需要 Skills?

一个很现实的问题是,每次向 Agent 重复提供一大段提示词,不仅麻烦,还会占用宝贵的上下文窗口。特别是当我们有几十个甚至上百个不同的工作流程时,如果把所有指令都放进上下文,既浪费 Token,也可能干扰模型对当前任务的判断。

Skills 提供了一种非常简单的解决思路:把不同任务的操作说明分别保存成文件,让 Agent 知道有哪些说明书可以使用,并在真正需要的时候再读取。

这就是 Skills 最重要的设计思想之一:渐进式披露(Progressive Disclosure)。

按照目前的 Agent Skills 标准,一个 Skill 通常是一个包含 SKILL.md 文件的文件夹。SKILL.md 又由两个主要部分组成:YAML Frontmatter(元数据)和 Markdown Body(指令正文)。

元数据通常包含两个最重要的信息:name 和 description,也就是 Skill 的名称和描述。名称告诉 Agent 这个 Skill 叫什么,描述则告诉 Agent 它能完成什么任务,以及什么时候应该使用。

Markdown 正文负责解释具体应该怎样完成任务,例如需要遵循哪些步骤、使用哪些工具、注意什么问题,以及最后应该输出什么结果。

当 Agent 启动时,Harness 通常只需要将各个 Skills 的名称和描述提供给模型,让模型知道自己有哪些可用的技能。等到用户提出了相关任务,模型才会通过读取文件,将对应 SKILL.md 的完整指令加载到上下文中。

如果任务还需要更加详细的参考资料、模板或者专门编写的脚本,Agent 可以继续读取 Skill 文件夹里的其他资源。

这就形成了一个逐步加载信息的过程:先加载简短的名称和描述,再按需加载详细说明,最后根据任务需要读取相关资源。

这样,即使我们安装了大量 Skills,也不需要在每次模型调用时都提供它们的全部内容。回忆一下第二部分的上下文管理,这实际上正是在解决同一个问题:怎样让模型在合适的时候,获得完成当前任务所需要的信息。

那么,Skills 究竟有什么实际价值?

我认为,它最直接的价值,是把反复执行的工作流程固定下来,并且方便地复用。

例如,我经常需要把写好的文章发布到微信公众号。这个过程并不只是写一篇文章,还需要把 Markdown 转换成合适的 HTML 格式、生成封面图片、检查排版,最后将内容推送到公众号草稿箱。

如果每次发布文章,我都需要重新向 Agent 解释整个流程,显然非常麻烦。但如果把这些操作步骤整理成一个 Skill,以后只需要告诉 Agent“把这篇文章发布到公众号草稿箱”,它就可以根据 Skill 中的说明,依次完成相应的工作。

当然,这里还有一个需要注意的区别:Skill 告诉 Agent 应该怎样完成任务,但并不意味着它自动拥有执行任务所需的所有工具。 比如,要向公众号推送文章,Harness 仍然需要能够调用相应的接口,并获得必要的访问权限。Skill 可以指导模型怎样组织这些操作,但真正执行操作的仍然是 Harness。

除了这些相对固定的工作流程,我认为 Skills 还有一个更值得探索的方向:把专家的经验、判断标准和工作方法整理成可复用的说明书。

例如,一位经验丰富的经济学研究者,在阅读论文时可能会有一套比较稳定的判断流程:先识别研究问题,再分析识别策略,检查核心假设,最后思考结果是否支持作者的结论。我们完全可以尝试把这套方法整理成一个 Skill,让 Agent 在阅读新论文时参考这些步骤。

从这个意义上说,Skills 可以帮助我们把一部分原本依赖个人经验的工作方法,转化成能够被反复执行、修改和分享的流程。网上有时会把这种做法戏称为“蒸馏”专家的经验,不过它并不是机器学习中通过训练进行的知识蒸馏,而是将专家的工作方法显式地记录下来,供模型在完成任务时参考。

但这里也需要保持清醒。一个 Skill 的名字叫 AER-Skills,并不意味着安装后,Agent 就能写出 AER 水平的论文。 Skill 所提供的知识和判断标准,首先取决于编写者自身的理解;而 Agent 最终能否正确执行这些指令,还取决于模型能力、任务难度、工具和资料是否充分。即使流程本身很合理,也不代表模型一定能够按照要求完成每一步。

因此,与其关注某个 Skill 的名字有多么厉害,不如直接打开它的 SKILL.md,看看它究竟提供了哪些方法、说明和资源,能否解决我们实际工作中的问题。

回到最开始的框架,Skills 主要是在 Context 层面组织和提供信息,同时借助 Harness 的文件读取和工具执行能力,将这些说明应用到具体任务中。它的价值不是让大模型突然变得更聪明,而是让我们能够以一种标准化、可复用、按需加载的方式,把自己的工作经验提供给 Agent。

3.2 Agent Memory:让信息能够跨会话复用

上一节我们介绍了 Skills,它可以帮助 Agent 保存和复用一套工作方法。但除了这些事先编写好的说明书,Agent 在实际工作中还会不断获得新的信息:比如用户的个人偏好、过去任务中积累的经验,以及某个研究项目已经取得的进展。这些信息能不能也被保存下来,供未来的 Agent 使用呢?

一个很常见的例子是,我们让 Agent 帮忙修改论文,发现它总是喜欢使用项目符号,于是告诉它:“以后修改我的论文时,尽量使用连贯的段落,不要动不动就列出一大堆 Bullet Points。”在当前会话中,Agent 通常能够遵守这个要求。但如果关闭会话,第二天重新开始一个新任务,它可能又会恢复原来的写作习惯。

这是因为我们在第一部分已经讲过,大模型并不会因为一次对话,就自动把新的偏好写入自己的参数。它能够遵守刚才的要求,是因为这条指令存在于当前的上下文中。一旦开启新的会话,如果没有其他机制重新提供这条信息,模型就可能不知道我们过去提出过什么要求。

Agent Memory 要解决的,正是怎样让这些有价值的信息跨越不同会话,在未来继续发挥作用。

2026 年 6 月 24 日,LangChain 在文章 How to Give Your Agent Memory 中给出了一个很简洁的定义:

Memory is durable context that an agent can retrieve across runs to guide its behavior.

也就是说,Memory 是一种能够被持久保存,并在未来的任务中重新检索和利用的上下文。

从这个定义来看,Memory 并没有改变大模型本身的工作原理。它仍然是我们在第一部分介绍的上下文管理:将过去产生的重要信息保存到外部存储系统中,在之后的任务需要时,再把相关信息提供给模型。

通常,我们可以把 Agent Memory 分成短期记忆(Short-term Memory)和长期记忆(Long-term Memory)。

短期记忆主要服务于当前任务或会话,包括我们刚刚讨论过的内容、工具返回的结果,以及任务执行过程中产生的临时状态。它和我们前面介绍的 Context Window 密切相关,但不完全相同:短期记忆可以保存在会话状态中,只有实际加载的内容才会进入某一次模型调用的上下文。

长期记忆则是指那些能够跨任务、跨会话保存的信息,例如用户的个人偏好、某个研究项目的重要决策,以及 Agent 从过去任务中总结出的经验。它们不会因为当前会话结束就失去作用,而是可以在未来被重新使用。

那么,这样的记忆具体是怎样实现的呢?

一个非常直观的例子是年初爆火的 OpenClaw。它在 Agent 的工作区中使用 Markdown 文件保存不同类型的信息,例如 SOUL.md 用来定义 Agent 的行为风格,USER.md 用来记录用户信息和偏好,而 MEMORY.md 则用于保存经过整理的长期事实、决策和经验。此外,它还可以使用按日期组织的记忆文件,记录日常工作中产生的详细信息。

当新的会话开始时,Harness 可以将部分重要信息加载到上下文中;如果后续任务需要了解某段过去的经历,也可以通过记忆搜索工具找到相关记录,再提供给模型。

例如,假设我们之前让 Agent 帮忙运行一组回归,经过几次修改,最终确定标准误应该在学校层面聚类。如果 Agent 把这个研究决策保存到了项目记忆中,那么下一次我们继续分析同一个项目时,它就可以根据这条记录,沿用之前确定的处理方式,而不必让我们重新解释整个过程。

当然,并不是把所有聊天记录保存下来,就等于拥有了好的 Memory。 更重要的是从过去的交互中提取哪些信息值得长期保留,以及在未来什么时候需要重新使用它们。如果把所有对话都原封不动地保存并加载,既浪费上下文,也可能让已经过时或不再相关的信息干扰模型的判断。

因此,一个比较完整的 Agent Memory 系统,通常需要完成几个环节:从历史对话和任务结果中提取重要信息,将其保存在文件或数据库中,在未来的任务中检索相关记忆,再将这些信息重新提供给大模型。有些系统还会定期整理和更新记忆,删除过时的信息,或者将反复出现的经验总结成更加通用的规则。

这也让我们可以进一步理解 Memory 和 Skills 的关系。Skills 通常用于保存“怎样完成某类任务”的方法,而 Memory 更强调保存“过去发生了什么、我们已经知道什么,以及从中学到了什么”。两者并不是完全独立的,例如 Agent 从过去任务中总结出的一套有效工作流程,就可以进一步整理成一个 Skill,在未来反复使用。

我自己也在尝试通过一套 Memory System,把科研项目中的重要信息、工作进展和经验保存成可以跨会话复用的文件,让不同时间启动的 Agent 能够在已有工作的基础上继续推进任务。

回到我们最开始的框架,Agent Memory 本质上仍然是 Context Management 的一种扩展:通过外部存储和检索机制,让原本只存在于某次会话中的信息,能够在未来重新进入模型的上下文。

它并没有让大模型像人类一样真正拥有持久的记忆,但可以让 Agent 不必每次都从零开始了解用户和任务。随着使用时间的增加,一个具有良好记忆管理机制的 Agent,就有机会逐渐适应我们的工作习惯,并利用过去积累的信息,更有效地完成新的任务。

3.3 RSI:让 Agent 学会改进自己

前面我们介绍了 Skills 和 Memory。通过 Skills,我们可以把一套工作方法保存下来,让 Agent 在未来重复使用;通过 Memory,Agent 则可以保存过去的经验,并在之后的任务中重新利用。

但这里还有一个更有意思的问题:既然 Agent 已经能够编写代码、修改文件,也能够根据过去的执行结果积累经验,那么,它能不能进一步主动改进自己的工作方法,甚至修改自己的运行框架,让下一次执行任务的 Agent 比这一次更强?

这就是近几个月非常热门的 RSI(Recursive Self-Improvement,递归自我改进)所研究的问题。

乍一听,RSI 似乎是一种非常复杂的技术,但如果回到第一部分介绍的 Agent Loop,我们其实很容易理解它背后的基本思路。

回忆一下,普通的 Agent Loop 是让模型围绕用户提出的任务,不断执行操作、观察结果、调整下一步行动。例如,我们让 Agent 修改一段 Python 程序,它会先阅读代码,发现问题,修改程序,再运行测试。如果测试失败,就继续修改,直到任务完成。

但请注意,在整个过程中,Agent 改变的是外部任务的结果,而不是 Agent 自身。 无论它修改了多少次 Python 代码,用来执行任务的 Harness、工具和工作流程通常还是原来那一套。下一次再遇到类似的任务,它可能仍然会犯同样的错误。

那么,我们能不能把 Agent 自己也当成一个需要改进的对象?

例如,一个 Coding Agent 总是在修改代码后忘记运行测试。我们可以让另一个 Agent 检查它过去的执行记录,发现这个问题,然后修改它的 Harness,在代码修改完成后增加一个自动验证的步骤。

修改完成后,我们再让新版本的 Agent 执行一组编程任务,比较它和旧版本的表现。如果新版本确实更好,就保留这次改进;如果没有改善,甚至变得更差,就放弃这次修改。

更进一步,下一轮改进不再从最初的 Agent 开始,而是从刚才改进后的版本开始。于是,我们就有可能形成一个新的循环:

Agent 执行任务 → 评估表现 → 提出改进方案 → 修改 Agent 自身 → 测试新版本 → 保留有效改进 → 继续改进。

这就是递归自我改进的基本思想:让 Agent 的工作对象不再只是外部任务,还包括用于完成任务的 Agent 系统自身。一个改进后的 Agent,可以成为下一轮改进的基础。

实际上,这个想法并不是最近才出现的。早在大语言模型诞生之前,AI 研究者就已经提出过让程序修改自身代码、不断改善自身能力的构想。但直到近几年,大模型具备了较强的编程、工具使用和长时间任务执行能力,这些设想才开始有机会在实际系统中得到验证。

2025 年 5 月,Sakana AI 与英属哥伦比亚大学等机构的研究者提出了 Darwin Gödel Machine(DGM)。这个系统能够修改自己的 Agent 代码,例如改进文件编辑工具、优化上下文管理方法,或者增加代码验证步骤。每产生一个新版本,系统就通过编程基准测试评价它的表现,并保留不同的候选版本,继续探索新的改进方向。

img
img

在研究报告的实验设置中,DGM 将 Agent 在 SWE-bench 上的任务解决率从 20% 提高到了 50%。值得注意的是,研究者并没有重新训练底层大模型,而是让模型不断改进 Agent 的执行框架,使相同的基础模型能够更有效地完成任务。

到了 2026 年 7 月,Weco AI 又公布了一项名为 AIDE² 的研究,并于 9 月公开了技术论文。

AIDE² 的思路更加直接:研究者原本已经开发了一个能够自主开展机器学习实验的 Agent,现在他们尝试让 Agent 自己去改进这个科研 Agent。整个系统包含两个循环:内部循环负责完成实际的研究任务,外部循环则负责修改内部 Agent 的代码,并通过一系列实验检验新的设计是否更好。

img
img

在八天的自主运行中,AIDE² 总共进行了 100 轮候选修改与评估,最终发现了七次连续的有效改进。这些改进涉及搜索策略、上下文管理和防止错误利用评估规则的机制,而且部分改进效果还能够迁移到原先没有用于优化的任务中。

这些研究说明了一件很有意思的事情:我们不一定需要改变大模型的参数,也可以通过不断优化 Agent 的运行方式,让同一个模型完成更多、更复杂的任务。

回到我们最开始的 Model、Context 和 Harness 框架,目前很多所谓的自进化 Agent,主要改进的其实是 Context 和 Harness。例如,让 Agent 自动优化自己的提示词、修改工具代码、调整工作流程,或者改进记忆的存储和检索方式。更进一步的研究则希望 Agent 能够参与模型训练和算法设计,最终改进底层 Model 本身。

当然,我们也不能因此认为,今天的 Agent 已经能够无限地让自己变得更聪明。

首先,Agent 需要一种可靠的方法来判断修改究竟有没有带来进步。如果只根据少量测试结果进行优化,就可能出现过拟合,甚至为了提高测试分数而采取违背真实任务目标的做法。其次,一个 Agent 即使能够连续改进自己,也不意味着每次改进都会让下一轮改进变得更快、更有效。AIDE² 的研究者就明确指出,他们尚未观察到这种能够持续加速自我改进的现象。

因此,目前的 RSI 研究更适合被理解为:在特定任务和可验证的评估条件下,让 Agent 自动探索、测试并保留对自身系统的改进。 距离一个能够在各种领域持续、自主地提升智能水平的系统,还有不少问题需要解决。

不过,对我们这些普通的 Agent 用户来说,RSI 背后的思想已经具有一定的启发意义。我们不必真的搭建一个能够自动修改自身代码的系统,也可以尝试让 Agent 在完成任务后总结错误、记录有效的方法,并通过实际测试判断哪些改进值得保留。对于那些经过验证、能够反复使用的经验,可以进一步整理成 Skills、Memory 或项目工作流程。

到这里,我们也就完成了对几个热门概念的拆解。Skills 让 Agent 能够复用工作方法,Memory 让 Agent 能够积累过去的信息,而 RSI 则进一步尝试让 Agent 利用这些能力,主动改进自己的工作方式。

它们听起来代表着不同的技术方向,但背后仍然离不开我们在第一部分介绍的基本机制:模型根据上下文作出判断,Harness 执行操作并提供反馈,整个系统再根据新的信息继续工作。

理解了这些基本原理,我们就不必每次遇到一个新概念,都从头学习一套完全不同的知识。相反,我们可以先看清它究竟改变了 Agent 的哪个环节,再判断这种改变是否真的能够帮助我们更好地完成任务。

appendix

Chatbot 的记忆:Contexts

LLM的核心就是这个上下文窗口,也就是说每一次交互其实都是一个单轮对话。因此想让模型记住一些事情,除了重新训练底层参数之外,就是两种方法:

短期记忆:当前对话窗口里的上下文
长期记忆:系统额外保存、检索、再塞回 prompt 的信息

LLM的参数每次训练完成后都会固定下来,不会改变,所以他只是在理解上下文窗口里面,用户/系统塞给他的东西


滑动窗口

滑动窗口是最简单的上下文管理方式。

假设模型最多只能看 10 条消息,那么第 11 条出现时,系统就丢掉最早的一条,只保留最近的 10 条。

滑动窗口:更早的消息滑出上下文窗口被丢弃,只有窗口内的消息送入 LLM
滑动窗口:更早的消息滑出上下文窗口被丢弃,只有窗口内的消息送入 LLM

优点:

实现简单,最近发生的事情通常最重要。

缺点:

早期的重要信息会被遗忘。

比如一个常见的坑,用户一开始说:

我不要英文缩写,所有概念都用中文解释。

聊了很久以后,这句话滑出窗口,模型可能又开始使用 LLM、Agent、Tool Call 这些英文缩写。


概括摘要 compact

为了解决滑动窗口丢失早期信息的问题,可以把旧对话压缩成摘要。

概括摘要:长历史先被压缩成一段摘要,再和最近几轮对话、新问题一起组成新的输入
概括摘要:长历史先被压缩成一段摘要,再和最近几轮对话、新问题一起组成新的输入

优点:能保留长期主线。

缺点:摘要会丢细节;如果摘要写错了,后续对话会一直被错误信息影响。

不过现在主流的agent工具基本都用compact功能。