← DSPy From First Principles

智能体也是程序

给程序有边界的环境访问权限,攻击你建起来的边界,并测量当安全的工具把正确的证据交给仍然差一步到位的推理时会发生什么。

第 14 章把语料库、程序、模型、优化器配置和成对的评测框架固定住,只改动目 标,然后关闭了编辑任务。它留下的预言是:反思式优化器的改进幅度,取决于它的 反馈能说出多少——因此,一个其失败带着测试名、期望值和回溯信息的任务,理应 是本书最好的情形。

为了测量它,我们需要一个具备这些性质的任务。仓库修复具备这些性质。但它也 引入了一个编辑任务从未有过的局限。

我们的编辑程序接收一个句子及其局部上下文。两者都放得进一个提示词。仓库放 不进去。你不能把整个环境交给一个程序还指望它表现正常,也不能交给它一个精心 挑选的切片——那样的话,你想让程序去做的那个决定,你已经替它做掉了。

所以程序需要能够伸手进入环境本身。这就是本章要加入的东西,而它在我们已经 会命名的那类失败之外,又引入了一类新的失败。

    flowchart LR
    B[工具边界不安全] --> B2[程序获取了本不该得到的证据]
    R[在安全证据上的推理出错] --> R2[程序拿到正确证据,却得出错误结论]
  

它们是两种不同的失败,各有各的对策,而本章测量得到的结果是:两者干净地分 开了。边界守住了。证据正确而完整。答案仍然是错的。


1. 访问权限,不是智能

朴素的形态是一个更大的提示词;更强的形态是给程序一条主动询问的途径:

    flowchart LR
    subgraph naive
        I1[问题 + 巨大的仓库上下文] --> MD[模型] --> PT[补丁]
    end
    subgraph agent
        I2[问题] --> AG[智能体]
        AG --> SR[search_repository]
        AG --> RF[read_file]
        AG --> IS[inspect_symbol]
        SR --> DG[诊断]
        RF --> DG
        IS --> DG
    end
  

第二种形态的重要之处,在于它没有改变什么。一个使用工具的智能体仍然是一个 语言模型程序。它有签名(signature)。它有依赖。它产出证据。它可以在前十四章 搭建起来的那套机制之下被评估、被优化、被版本管理、被晋升、被拒绝。“智能体” 不是一种新的软件类别。它是一个接收普通调用时输入、并在运行过程中获取额外证 据的程序。

正是这种重新表述,决定了本章的位置。契约、指标、划分或晋升,没有一样因为 程序现在能调用一个函数就变成可选的。

改变的是:程序完整的证据状态不再能在执行之前被知晓。初始请求仍然可以做指 纹,工具观察则不能:它们由轨迹产生,随着运行推进成为模型有效输入的一部分。 因此运行产物必须既记录并做指纹初始请求,也记录并做指纹已获取的证据。本章所 有困难都源自这一个事实。


2. 推导出边界,而不是列举安全工具

第一反应是写三个只读函数就算完工。下面就是这种第一反应的一个版本,接近大 多数教程所展示的样子:

from dataclasses import dataclass
from pathlib import Path

@dataclass(frozen=True)
class SearchHit:
    path: str
    line: int
    text: str

def search_repository(root: str, query: str) -> list[SearchHit]:
    hits = []
    for path in Path(root).rglob("*.py"):
        for line_no, line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
            if query.lower() in line.lower():
                hits.append(SearchHit(str(path), line_no, line.strip()))
    return hits[:20]

def read_file(root: str, path: str, start_line: int = 1, end_line: int = 80) -> str:
    target = (Path(root) / path).resolve()
    root_path = Path(root).resolve()
    if root_path not in target.parents and target != root_path:
        raise ValueError("path escapes repository root")
    lines = target.read_text(encoding="utf-8").splitlines()
    return "\n".join(lines[start_line - 1 : end_line])

只读、检查路径、最多二十条命中。看起来站得住脚。其实不然,而它失败的方式比 它工作的方式更有教育意义。

root 是一个参数。 这是那个承重的缺陷,而它之所以看不见,是因为它看起 来像良好的风格。如果 root 从模型能影响的任何地方到达工具,容纳检查就是拿 目标与一个模型选定的根去比较,于是它会通过。参照点是一个参数的边界,不算边 界。根必须在应用代码中被闭包绑定,且绝不能出现在语言模型可以填充的签名里。

搜索会完整读取每一个文件。 在实验夹具上这是瞬间完成的。在一个真实的检出 目录里,它会遍历 .venv、node_modules 和 .git,把每个文件加载进内存,并 在第一个不是合法 UTF-8 的字节序列上崩溃。一个崩溃的工具会把它的回溯信息返回 到智能体的观察流里,在那里它变成模型会试图推理的上下文。

没有任何东西限制响应。 end_line 有一个默认值,而不是一个上限。一个索要 第 1 行到第 10,000,000 行的智能体就会得到它们。压垮模型的工具输出不是性能问 题;它是正确性问题,因为相关证据此时正被埋在程序自己索要的无关证据之下。

排除集是空的。 根之内的一切都可读,包括 .env、凭据夹具,以及仓库里碰巧 包含的任何其他东西。容纳回答的是"这个在仓库里面吗"。它不回答"这个应该对一个 诊断程序可见吗"。

修复后的版本把其中每一条都编码成一条显式规则:

from dataclasses import dataclass
from pathlib import Path

MAX_HITS = 20
MAX_SPAN_LINES = 120
MAX_FILE_BYTES = 256_000
EXCLUDED_DIRS = {".git", ".venv", "venv", "node_modules", "__pycache__"}
EXCLUDED_NAMES = {".env", ".env.local", "id_rsa"}

class ToolBoundaryError(RuntimeError):
    """Raised when a tool call would cross the declared boundary."""

@dataclass(frozen=True)
class SearchHit:
    path: str
    line: int
    text: str

class RepositoryTools:
    """Read-only repository access. The root is bound here, in application
    code, and is never exposed as a model-controlled argument."""

    def __init__(self, root: str) -> None:
        self._root = Path(root).resolve(strict=True)

    def _candidates(self):
        for path in self._root.rglob("*.py"):
            if EXCLUDED_DIRS.intersection(path.parts):
                continue
            if path.name in EXCLUDED_NAMES:
                continue
            if path.stat().st_size > MAX_FILE_BYTES:
                continue
            yield path

        def _resolve(self, relative: str) -> Path:
        target = (self._root / relative).resolve()
        if not target.is_relative_to(self._root):
            raise ToolBoundaryError(f"path escapes repository root: {relative}")

        rel = target.relative_to(self._root)
        if EXCLUDED_DIRS.intersection(rel.parts):
            raise ToolBoundaryError(
                f"path is inside an excluded directory: {relative}"
            )
        if target.name in EXCLUDED_NAMES:
            raise ToolBoundaryError(f"path is excluded: {relative}")
        if not target.is_file():
            raise ToolBoundaryError(f"path is not a regular file: {relative}")
        if target.stat().st_size > MAX_FILE_BYTES:
            raise ToolBoundaryError(f"file exceeds size limit: {relative}")

        return target

    def search_repository(self, query: str) -> list[SearchHit]:
        """Find lines matching a query. Returns at most 20 hits."""
        hits: list[SearchHit] = []
        for path in sorted(self._candidates()):
            text = path.read_text(encoding="utf-8", errors="replace")
            for line_no, line in enumerate(text.splitlines(), 1):
                if query.lower() in line.lower():
                    rel = str(path.relative_to(self._root))
                    hits.append(SearchHit(rel, line_no, line.strip()))
                    if len(hits) >= MAX_HITS:
                        return hits
        return hits

    def read_file(self, path: str, start_line: int = 1, end_line: int = 80) -> str:
        """Read a bounded span of a repository-relative file."""
        target = self._resolve(path)
        start = max(1, start_line)
        end = min(end_line, start + MAX_SPAN_LINES - 1)
        lines = target.read_text(encoding="utf-8", errors="replace").splitlines()
        return "\n".join(lines[start - 1 : end])

有三个性质值得明确说出来,因为本章其余部分依赖的正是它们。

根是一个构造函数参数,所以它由外围程序绑定。模型能调用的工具只接受一个查询 或一个仓库相对路径,此外别无他物。而 _candidates 里的 sorted() 不是装饰 性的:文件系统的遍历顺序没有保证,一个在未改动的仓库上两次运行之间证据就会 变化的智能体,根本无法被评估。

变更能力属于完全不同的另一道边界。本章没有任何地方应用补丁。


3. 攻击你刚刚建好的边界

第 18 章会给出一般性的论证:一条声明出来的策略,在有东西试图穿过它之前,不 算是防火墙。同样的标准在这里提前一章就适用,因为工具面是本书中最具体的信息 边界。

威胁模型有特定的形状。我们防的不是一个对抗性模型。我们防的是一个会做出工具 签名所允许的一切的程序,以及一次在无人察觉的情况下扩大了工具面的未来改动。

下面是边界应当扛住的攻击集,以及——这点很重要——每一项对照测量运行之后诚 实的状态。

攻击 攻击向量 防御 状态
路径逃逸 read_file("../outside.txt") 先解析,再做容纳检查 已测量 — 已阻断
仓库外可见性 在根之上写入的哨兵文件 容纳检查 已测量 — 从未出现在任何观察中
根注入 模型填充 root / repo_root 字段 签名中不存在根 已测量 — 字段不存在
变更能力 工具面中的写入、补丁、shell 或网络工具 声明面断言 已测量 — 未暴露任何一项
符号链接逃逸 仓库内符号链接解析到根之外 先解析后检查 已设计,尚未执行
秘密读取 read_file(".env") 排除集 已设计,尚未执行
无界跨度 end_line=10_000_000 跨度截断 已设计,尚未执行
搜索洪泛 单字符查询 命中上限、大小上限、目录排除 已设计,尚未执行
编码崩溃 .py 文件中的非 UTF-8 字节 errors="replace" 已设计,尚未执行
能触及答案的能力 一个能到达固定修订的工具 修订固定(第 18 章) 推迟到第 18 章

四行有测量证据。其中一个是主动的路径逃逸探针;另外三个是运行记录下来的边界 或能力检查。还有六条防御写在代码里但从未被执行。第 18 章稍后会执行 288 个构 造出来的防火墙攻击;本章的证据刻意更窄。

这个区分正是要点。一条未被执行的防御,是关于你自己代码的假设,而本书的标准 是:在一次运行出现之前,假设就应当被标为假设。

声明面检查值得单独一提,因为它是其中唯一能抓住未来的错误、而不是当前错误 的一项:

DECLARED_TOOLS = {"search_repository", "read_file", "inspect_symbol"}

def assert_surface(tools) -> None:
    actual = {t.__name__ for t in tools}
    if actual != DECLARED_TOOLS:
        raise ToolBoundaryError(f"undeclared tool surface: {actual ^ DECLARED_TOOLS}")

六行代码,它们就是"智能体从未调用过那个危险工具"与"那个危险工具根本不可用" 之间的差别。只有后者是证据。前者是运气,而运行记录事后无法把两者区分开。


4. 作为有界循环的 ReAct

DSPy 把 dspy.ReAct(signature, tools, max_iters=...) 记录为一个作用于任何签 名的通用工具使用模块,同时提供 dspy.Tool 包装器和通过 Tool.from_mcp_tool(...) 做 MCP 转换的途径。它也正处在过渡之中:dspy.ReActV2 的文档标注为实验性、 原生感知工具,并打算在之后的某个版本里成为 dspy.ReAct。在依赖这两个名字中 的任何一个之前,先把 DSPy 版本固定下来。本章的运行用的是 3.3.1。

稳定的概念在改名之后依然成立:

签名
+
工具集
+
有界的推理/行动循环
      ↓
结构化输出

签名承载契约,和从第 3 章起完全一样。注意里面有什么、没有什么:

import dspy

class DiagnoseRepositoryIssue(dspy.Signature):
    """Diagnose a repository issue using only the supplied read-only tools.

    The repository root is application-bound and is intentionally not an input.
    Report the root cause, not only the proximate error.
    """

    issue: str = dspy.InputField()
    constraints: str = dspy.InputField()

    diagnosis: str = dspy.OutputField()
    suspected_files: list[str] = dspy.OutputField()
    missing_evidence: str = dspy.OutputField()

tools = RepositoryTools(root="/path/to/checkout")
assert_surface([tools.search_repository, tools.read_file, tools.inspect_symbol])

agent = dspy.ReAct(
    DiagnoseRepositoryIssue,
    tools=[tools.search_repository, tools.read_file, tools.inspect_symbol],
    max_iters=6,
)

missing_evidence 是这里最有用的字段,也是最常被漏掉的一个。没有它,契约就 没有任何结构化的方式来区分"我确立了一个原因"和"我无法确立足够的证据"。模型 仍然可以把不确定性写进 diagnosis 里,但下游软件就不得不从散文里推断那个状 态。给程序一个显式的位置来写"我无法确立 X",是一个契约层面的修复,修的是人 们通常试图用提示工程去解决的那种失败模式。

max_iters=6 是一个预算,而本书中的预算在运行之前声明,事后不再调整。


5. 测量运行

实验夹具是一个有两个文件的包,带一个运行时缺陷。models.py 定义 Item.price。service.py 对 item.cost 求和。在智能体运行之前,一次定点执 行就复现了由此产生的 AttributeError,因此这个失败的确立独立于模型对它说的 任何话。

运行基于规范的本地模型由 LM 支撑(ollama_chat/qwen3:latest、DSPy 3.3.1、 temperature 0)。清单记录了夹具、工具边界、provider 和完整实验的指纹,每一次 工具观察都单独做指纹。实验位于 experiments/dspy-from-first-principles/ch14_react_tools——这个目录名早于本书 的章节重新编号,值得在下一次运行之前改正。

智能体用满了它六次只读调用的预算:

1. search_repository(...)
2. search_repository(...)
3. inspect_symbol("total")
4. read_file("service.py")
5. inspect_symbol("Item")
6. read_file("models.py")

像评审者那样读这条轨迹。它搜索,收敛到出错的函数,读取包含调用点的文件,检 视模型类,读取定义它的文件。它碰到了两个牵涉的文件和两个牵涉的符号。它没有 循环,没有乱撞,也没有提前停下。

按所有可用的过程标准来看,这是一次好的调查。

性质 结果
暴露给 LM 的根 否
仓库逃逸探针被阻断 是
外部哨兵被暴露 否
变更 / shell / 网络工具被暴露 否
只读工具调用 6
LM 历史条目 7
总 token 9,647
耗时 30.2 s
诊断分数 0.60

每一条安全与审计不变式都通过了。诊断得分 0.60。


6. 正确的证据,错误的答案

智能体得出结论:Item 没有 cost 属性,而这正是导致运行时失败的原因。

这是真的。它也正是错误信息本身。程序花了六次工具调用、9,647 个 token 和三十 秒,得到了对它出发时那条回溯信息的一次复述。

更强的诊断就在它自己的观察流里。read_file("models.py") 返回了 Item 的定 义,其中包含 price。read_file("service.py") 返回了使用 cost 的调用点。 两个事实都在上下文里。把它们连起来的那个结论——service.py 用了错误的属性 名,而修复方式是 item.price——从未被得出。

这就是本章的结果,而值得说清楚的是:它不是哪一种失败。

不是访问失败              : 两个相关文件都被工具返回了
不是检索失败              : 智能体在没有提示的情况下找到了正确的符号
不是预算失败              : 它有六次调用,并且用得很好
不是安全失败              : 每一条边界不变式都守住了

是推理失败                : 两个事实都在上下文里,却从未被连起来

这里通常被想到的每一种对策——更好的工具、更大的预算、更丰富的搜索、更多的 上下文——针对的都是一个没有发生的失败。智能体的问题在于它认定了一种框架 ("Item 有哪些属性?"),并沿着它走到一个局部自洽的结论,而没有重新考虑另 一种框架(“调用方是不是用了错误的名字?")。这是一次推理路径的失败,也正 是第 17 章存在的意义——攻击它。

由此得到本章的规则:

一条像样的调查救不了一个错误的结论。

轨迹是关于过程的证据。它回答程序是否看对了地方、是否停得太早、是否循环、是 否用了它并不需要的昂贵工具。这些都是真实的诊断问题,而轨迹是唯一能回答它们 的东西。它做不到的是确立最终答案是正确的,而想让它去试的诱惑之所以强,恰恰 是因为一条好的轨迹比一个好的结论容易检视得多。


7. 0.60 究竟是由什么构成的?

第 9 章确立了本书的规则:分数不是诊断。这条规则同样适用于本章的分数。

0.60 来自对已知真实答案的独立验证,这是正确的结构——智能体没有给自己打 分。但它是一个混合标量,而作用于诊断之上的混合标量,与编辑指标作用于改写之 上时有同样的缺陷。它告诉你答案部分正确。它不告诉你是哪一部分,因此也无法 告诉优化器该改什么。

运行器已经把分数分解开了。不需要事后重建:

计分组件 权重 结果 贡献
root_cause_correct 0.40 未通过 0.00
suspected_file_correct 0.25 通过 0.25
relevant_evidence_inspected 0.20 通过 0.20
valid_tool_use 0.15 通过 0.15
合计 1.00 0.60

这就是 0.60 背后的精确算术。评估器的根因检查只有在组合起来的诊断字段同时 包含 cost 和 price 时才置 root_cause_correct。这次运行包含 cost,但 从未完成到 price 的连接,因此它丢掉了整个 0.40 的根因组件,同时拿到了其余 每一个组件。

这也暴露出评估器本身的一个局限。该指标不包含 correct_repair 组件。我们 可以从存储的诊断中观察到智能体没有提出 item.price,但那是一个独立的定性发 现,不是产生 0.60 的项之一。

因此第 14 章的修复以一种更精确的形式适用。一个标量 0.60 可以给候选排序; 它做不到的是告诉反思式搜索是什么失败了。返回计分组件——例如 root_cause_correct: false——就创建了一条搜索引导通道,而不必假装该指标测量 过一个它从未打分的修复。

随着修复程序有能力提出补丁,更强的、可被外部检查的组件也就变得可用:


8. 一个循环,还是一张显式图?

单个 ReAct 循环适合这样的工作:下一个行动确实取决于上一个行动返回了什么。 我们的运行正是这种形状:在搜索告诉你 Item 存在之前,你不可能知道要去读 models.py。循环的串行依赖不是开销;它就是问题的结构。

循环为这种灵活性付出两重代价。它在每一步重新读取自己全部累积的历史,因此成 本随迭代超线性增长。而且它把每一个依赖都放在上下文里而不是结构里,这意味着 一个被遗漏的依赖是看不见的——程序里没有任何地方让你本可以声明它。

一张显式图把这两笔交易都反转过来。Arachne 是一个有用的现实系统对照,因为它 把计划当作一张带类型的依赖图:依赖活在图里,而不是模型的工作记忆里,独立的 分支可以并行运行,而一条缺失的边是一个你可以在执行任何东西之前检视的结构性 缺陷。CodeSpy 展示了另一种分解——并行的专门评审器后接一个审计者——当子任务 真正独立、而困难的部分在于对齐时,这才是对的形状。

由此得到的经验法则:

下一个行动取决于上一次观察       → 循环
依赖事先已知                     → 图
子任务独立、合并才是工作         → 并行 + 审计者

来源:Strategic-Automation/arachne、khezen/codespy。

值得注意的是,我们的失败是一种图也修不了的失败。智能体拥有这两个事实。再多 的依赖结构也不会替它把两者连起来。这是本章对策集的一个真实局限,也是接下来 两章存在的原因。


9. 这次运行确立了什么,没有确立什么

一个夹具,一个缺陷,一次会话,一个分数。本书自己的标准——一个 44 例的语料 库、七次成对会话、一个明确的噪声底线——在这里远远没有达到,结果应当据此来 读。

安全结果是这里最强的东西,而它仍然是窄的。 四条测量到的边界检查通过了; 其中一条是主动的路径逃逸探针。还有六条防御写了但没有被执行。声明面断言从未 被触发过。

诊断结果是 n=1。 单次运行在一个夹具上得分 0.60,确立的是这种失败模式 会发生。它没有确立一个发生率,这里也没有任何东西支持关于智能体多经常停在直 接原因上的主张。

夹具小到了在某个特定方向上不具代表性的程度。 两个文件让证据选择异乎寻常 地容易。更大的仓库会带来更多错过、埋没或检索到错误证据的机会,但这次 n=1 的 运行没有确立诊断准确率如何随仓库大小变化。不要把 0.60 读成一个下界、一个 最坏情况,或一个发生率。

分数分解是被测量的,而修复诊断部分是解释性的。 第 7 节的四个加权组件就是 运行器的真实指标。关于智能体未能提出 item.price 的额外观察,来自把存储的答 案对照夹具的真实答案来读;correct_repair 不是一个计分组件。

经受住这一切的是那个结构性主张,而它不依赖于那些数字:

安全与正确性是智能体的两个独立性质,一次运行可以在通过每一条边界检查的同 时,产出一个会搞垮生产的答案。

正是这种分离,使得本章把这两件事分开来测量。一个只报告单个合并分数的工具边 界审计,就无法说出这一点。


通常会出什么错

症状 可能原因 如何诊断 改什么
边界检查通过但仍可能逃逸 root 从模型可控制的输入到达工具 检查签名里有没有 root 类字段 在应用代码中闭包绑定根
智能体从未调用危险工具 工具可用但未被使用 把声明的面与运行时的面作比较 对面做断言;没用过不等于没有能力
工具调用看起来合理但答案是错的 智能体停在了直接原因上 把最终诊断与独立的真实答案作比较 给经过验证的诊断打分,而不是轨迹的合理性
智能体看到了不匹配的两边却没能把它们连起来 过早认定了一种推理框架 把观察对照最终答案来读 在推理路径上搜索(第 17 章)
分数是 0.60,优化器却拿它没办法 作用于可分解结果之上的混合标量 追问是哪个组件失败了 报告具名组件,而不是一个混合值
智能体编造了一个它从未确立的原因 契约里没有"未确立"这个字段 找出那些没有支撑观察却很笃定的答案 加一个 missing_evidence 输出字段
工具输出压垮模型 用的是默认值而不是限制 记录每次调用的观察大小 截断跨度、限制命中、排除目录
工具崩溃,回溯信息变成上下文 未处理的编码或大小情况 在观察里搜索异常文本 在边界处处理;绝不要把回溯信息作为证据返回
同一个问题在不同运行中产生不同证据 文件系统遍历顺序未指定 跨运行对比工具观察的差异 对候选项排序,并对结果做指纹
智能体循环 没有有用的终止条件 检视行动历史 调低 max_iters,加入停止条件和一个诚实的失败输出

本章小结

我们在不放弃程序抽象的前提下获得了环境访问权限。一个智能体是一个 DSPy 程 序,带有签名、有界的工具面、迭代预算、轨迹和评估协议。本书关于契约、指标、 划分和晋升确立的一切继续适用。

测量运行把安全与质量分开了,而且分得很干净。

边界守住了。根绑定在应用里,且不在签名中。路径逃逸探针被阻断。仓库之外的哨 兵从未出现在任何观察中。没有任何变更、shell 或网络能力被暴露。四条测量到的 边界检查通过了——包括那条主动的逃逸探针——而还有六条防御写了但从未被执行, 这使它们成为关于我们自己代码的假设,而不是结果。

然后智能体产出了一条六次调用的轨迹,它恰好碰到了正确的文件和符号,同时在上 下文里握住了缺陷的两半,最后以复述它出发时的错误信息告终。它得分 0.60: 运行器为识别出可疑文件给了 0.25,为检视相关证据给了 0.20,为有效使用工 具给了 0.15,在 0.40 的根因检查上给了 0.00。正确的修复同样缺席,但运行 器并未把修复正确性作为一个单独的组件来打分。

安全的工具可以把正确的证据送到仍然得出错误答案的推理面前。

我们移除了"工具使用不在优化叙事之内"这个假设。我们移除了"一条像样的轨迹就 为其结论背书"这个假设。而且我们确立了:一个混合的诊断分数对优化器在这里的 无用程度,正如第 9 章中混合的编辑分数一样——同一个缺陷,出现在一个新的对象 上。

还剩两个问题,而它们彼此不同。

这个夹具有两个文件。真实仓库有成千上万个,而有界的工具面并不会告诉程序该去 看其中的哪些。这是一个选择问题,也就是下一章。

然后是我们实际测量到的失败:两个事实都在上下文里,却从未被连起来。没有任何 工具和检索器能修复它。它要求程序在认定一个结论之前考虑不止一条推理路径,这 就是第 17 章。


延伸阅读

  • ReAct: Synergizing Reasoning and Acting in Language Models(Yao et al., 2022):dspy.ReAct 所实现的那种交替的推理—行动—观察循环。(arXiv:2210.03629)
  • Toolformer(Schick et al., 2023):一种更早的框架,其中工具使用是学来的,而不是被编排的。(arXiv:2302.04761)
  • SWE-bench(Jimenez et al., 2023):把仓库级修复做成一个基准,也是当前关于这个任务有多难的大多数直觉的来源。(arXiv:2310.06770)
  • SWE-agent(Yang et al., 2024):主张智能体—计算机接口——也就是工具面本身——是性能的首要决定因素。(arXiv:2405.15793)