当智能体是错误的设计时

阅读约需 31分钟 分钟,6节中含2个示例。

版次 2026.11.2 示例于 2026年11月20日 通过 64个示例中有64个通过 变化内容

AI 翻译。由人工以英文核验。 我们如何制作图书

译自英文版图书,版次 2026.11.2。 阅读原文

读完本章,你可以将本案例中的任意一项任务归入固定流水线、单次模型调用或带关卡的智能体三类之一,并说明记录下来的运行结果对该任务显示了什么。案例给出了第一个检验。任务 T-02 是对 unitcraft 的一处单行修复,本章按设计类型对这个库的任务进行分类:负数金额会丢失千位分隔符,因此 -1234.5 m 应当输出为 -1,234.50 m。第 3 章中使用工具集 v1 的那次记录运行(任务记录正是用该工具集制作的)始终没有完成这项任务。它用完了全部 16 步,却从未调用 finish。这一改动只是在一个函数中做一处替换,因此问题在于:智能体是否曾经是适合它的设计。

从固定流水线开始

针对 T-02,首先要问的是:当运行中没有任何事情需要判断时,它需要哪些步骤。读取格式化模块,替换构建数字文本的那一行,使负值保留分隔符,运行可见测试,最后用一句话描述这次改动。这些步骤都不必等待模型对文件的看法,因此都不需要模型。固定流水线就是这样一份清单,在运行开始之前以代码的形式写好。

Anthropic 的工程博客文章在讨论构建智能体时划了一条类似的界线。文章把通过预定义的代码路径来编排 LLM 与工具的系统称为工作流,把由 LLM 动态地主导自身流程和工具使用的系统称为智能体(Anthropic,"Building effective agents",发布于 2024 年 12 月 19 日)。按这个意义,工作流的各个步骤中仍然会运行模型。本章的流水线更进一步,因为它的任何步骤都不需要模型。同一篇文章还建议寻找尽可能简单的方案,只在必要时才增加复杂度。本章从这条建议中得出的规则是经验法则,而不是测量结果:如果这些步骤能在运行之前写下来,就先把它们写下来。

每条流水线都是一份精确编辑的清单加上一段总结,保存在 lib/pipeline.py 中。一次编辑会指明它要替换的文本和用来替换的文本,而且当旧文本在文件中没有恰好出现一次时,编辑即告失败。流水线通过工具集 v1 运行它的清单,因此每次调用的行为与智能体调用时相同,并按照同一条完成规则为结果打分。只写了三条流水线,分别对应 T-02、T-04 和 T-05。该示例运行这三条流水线,并把每一条与智能体在同一任务上已存储的运行结果并排打印出来。

fixed-pipeline-same-task.py Python 3.12.15 · pydantic 2.14.3 通过
"""The fixed pipeline on the tasks where one known edit works (T-02, T-04, T-05), with no model, beside the recordedagent's run on the same task. The point rests on two lines per run: the pipeline's actions and its model calls (0), andthe agent's steps, which are its model calls. The edits are written by a person; the scoring is the same for both."""from lib.case import load_tasksfrom lib.models import load_recordingfrom lib.pipeline import PIPELINES, Edit, Pipeline, agent_edit_results, run_pipelinefrom lib.tasks import scoremanifest, _ = load_recording("task-set")stored = {row["task"]: row for row in manifest["tasks"]}for task in load_tasks(only=sorted(PIPELINES)):    run = run_pipeline(task, PIPELINES[task.id])    done = score(task, run)    run.close()    agent = stored[task.id]    print(f"{task.id} pipeline ended: {run.ended}")    print(f"{task.id} pipeline done: {'yes' if done else 'no'}")    print(f"{task.id} pipeline actions: {run.tool_calls}")    print(f"{task.id} pipeline model calls: {run.steps}")    print(f"{task.id} pipeline prompt tokens: {run.prompt_tokens}")    print(f"{task.id} agent ended: {agent['ended']}")    print(f"{task.id} agent done: {'yes' if agent['done'] else 'no'}")    print(f"{task.id} agent steps: {agent['steps']}")    print(f"{task.id} agent tool calls: {agent['tool_calls']}")    print(f"{task.id} agent prompt tokens: {agent['prompt_tokens']}")    assert done and run.steps == 0 and run.tool_calls < agent["tool_calls"], task.id# The agent's T-02 run, replayed from the recording: the result the tools gave each of its edits and test runs.edits, tests = agent_edit_results("T-02")print(f"T-02 agent edits failed: {sum(e.startswith('error') for e in edits)} of {len(edits)}")print(f"T-02 agent test runs: {len(tests)}")print(f"T-02 agent first edit result: {edits[0]}")assert all(e.startswith("error") for e in edits) and not tests# The pipeline's own failure: its one edit names text the file does not hold, so the run stops at that step.task = load_tasks(only=["T-04"])[0]run = run_pipeline(task, Pipeline((Edit("unitcraft/units.py", "no such line", "x"),), "not run"))print(f"T-04 missing anchor ended: {run.ended}")print(f"T-04 missing anchor actions: {run.tool_calls}")print(f"T-04 missing anchor done: {'yes' if score(task, run) else 'no'}")print(f"T-04 missing anchor result: {run.stop_detail}")run.close()assert run.ended == "pipeline_stop" and run.tool_calls == 2
输出python fixed-pipeline-same-task.py
T-02 pipeline ended: finish
T-02 pipeline done: yes
T-02 pipeline actions: 4
T-02 pipeline model calls: 0
T-02 pipeline prompt tokens: 0
T-02 agent ended: step_cap
T-02 agent done: no
T-02 agent steps: 16
T-02 agent tool calls: 16
T-02 agent prompt tokens: 43904
T-04 pipeline ended: finish
T-04 pipeline done: yes
T-04 pipeline actions: 4
T-04 pipeline model calls: 0
T-04 pipeline prompt tokens: 0
T-04 agent ended: finish
T-04 agent done: yes
T-04 agent steps: 5
T-04 agent tool calls: 5
T-04 agent prompt tokens: 8809
T-05 pipeline ended: finish
T-05 pipeline done: yes
T-05 pipeline actions: 4
T-05 pipeline model calls: 0
T-05 pipeline prompt tokens: 0
T-05 agent ended: finish
T-05 agent done: yes
T-05 agent steps: 5
T-05 agent tool calls: 5
T-05 agent prompt tokens: 8494
T-02 agent edits failed: 9 of 9
T-02 agent test runs: 0
T-02 agent first edit result: error: old text not found in unitcraft/format.py
T-04 missing anchor ended: pipeline_stop
T-04 missing anchor actions: 2
T-04 missing anchor done: no
T-04 missing anchor result: error: old text not found in unitcraft/units.py

这条流水线完成了全部三个任务,而且没有发起任何模型调用。在本章中,与全书一致,一个步骤就是一次模型调用,所以流水线没有步骤。它有的是动作,也就是它的工具调用,对 T-02 而言,统计动作数的那一行是 4。T-02 上有记录的智能体发起了 16 次模型调用,每一步一次,其提示词词元合计为 43904。流水线则完全没有发送提示词。在 T-04 和 T-05 上,智能体完成了任务,但它发起的模型调用次数仍多于流水线的动作数,示例会为每个任务打印这两个计数。第 11 章解释了本书为什么以调用次数和词元数而不是金额来计量(以计数衡量成本)。

根据记录回放智能体在 T-02 上的运行,可以看到每次调用的结果。它的编辑失败了,9 of 9,每次的消息都相同:error: old text not found in unitcraft/format.py。智能体再次读取文件并重试,得到同样的错误,而且它从未运行测试:它的测试运行次数是 0。步骤上限终止了一次无法让改动与文件相匹配的运行。运行中没有任何环节检查改动是否生效,因此这个计数只说明智能体被卡住了多久,而无法说明原因。

流水线也有它自己的失败方式。它的最后一次运行给了它一条针对 T-04 的编辑,其旧文本并不出现在文件中,这正是固定清单下文件发生变化时会出现的情形。运行在该步骤结束,此前共有 2 个动作,并带着工具自己的消息:error: old text not found in unitcraft/units.py。流水线不会尝试另一个锚点,不会重新读取文件,也不会询问任何人。对于由人写下的编辑,停止是正确的反应,因为文件已经变化,应该由人来查看。

这次停止仍然需要有去处,而流水线无法把它交给子智能体,因为它没有子智能体。它可以把停止交给一个人,由此人阅读失败的步骤并决定怎么做。或者,它可以把任务交给一个智能体,并提供失败的步骤和文件当前的状态。混合方案,即先用流水线,只在出现 pipeline_stop 时才启用智能体,是顺理成章的做法。流水线完成无需判断的步骤,智能体只看到出问题的那一部分。这样做是让智能体从部分完成的状态开始,所以该智能体的运行需要与其他任何运行相同的关卡。当出问题的步骤涉及案例交由人来决定的事项时,我们建议交给人。当该步骤是一个已知的编辑、因锚点变化而停止时,我们建议交给智能体。本章不对混合方案做测量。

有三点限制了这条流水线所能说明的内容。每条编辑都由人写成,因此这一比较衡量的是这种设计的代价,而不是流水线单靠自己能发现什么。这三个任务是编辑可以在运行之前就确定的任务,对于其他任务会怎样,这里没有任何内容表明结果会如何。流水线还会比较编辑前后失败测试的 id,因为可见测试集在任何编辑之前就已经有失败项。

工作准则: 在把循环交给模型之前,先把步骤写出来,并写明每一步之后的检查。如果每一步都是已知的,并且有一项检查无需模型就能判定结果,就构建流水线并对它进行测量。在第一次运行之前,先决定它的停止交给谁:交给人,或者交给获得了失败步骤的智能体。

拆分工作何时有帮助

一旦单个智能体表现吃力,人们接下来想到的往往是再加一个智能体。拆分看起来像是更加谨慎,因此真正有用的问题是它在什么时候确实有帮助。两项研究给出的是条件,而不是定论。

Tran 和 Kiela 在多跳推理任务上比较了单个智能体与多个智能体,并保持推理词元数量相等(Tran and Kiela, arXiv:2604.02460)。单个智能体的表现与多智能体系统相当,或者更好。他们在摘要中预测,多智能体系统在两种条件下会变得有竞争力:单个智能体对上下文的有效利用下降时,以及投入更多计算时。

Kim 等人在 260 种配置和六个智能体基准上做了对照比较(Kim et al., arXiv:2512.08296)。他们在摘要中指出,架构与任务的匹配程度决定协作能否成功,而不匹配的协调会降低性能。有用的解读是有条件的:某种协调模式在一项任务上有帮助,在另一项任务上可能有害。这两项研究都只是单篇论文,其范围是推理和基准测试,而不是维护类代码库,因此应把它们当作测试设计的理由,而不是已经确定的结论。

可以用第一个条件来检验这个案例,即单个智能体无法容纳的上下文。记录中的上下文窗口为 8192 个词元。其中最大的单次请求包含 6556 个提示词元,这在窗口之内留有余量,在第 5 章为它设定的提示预算之内也留有余量。数据集中没有任何一次请求达到窗口上限,因此案例中没有任何任务的上下文会迫使我们拆分。第 8 章比较了两种拆分方式,并指出本书没有对拆分与单个循环做对比测量。因此,案例同样没有给出拆分的任何数字。下面的决策表以第一个条件作为是否拆分的检验标准,而没有任何一行满足它。

工作准则: 只有当你能说出使拆分有帮助的条件(例如单个智能体无法容纳的上下文),并且每个部分都有不依赖其他部分的检查时,才拆分任务。否则就保留一个智能体,或者不用智能体。

使用智能体时会出什么问题

智能体增加了运行可能出错的环节,其中大多数只会在运行记录中显现。

Cemri 等人先从 150 条经专家标注者细读的轨迹中构建分类法。随后,他们使用经过这些标注者校验的 LLM-as-a-judge 流程,为数据集中来自七个多智能体框架的 1,600 多条轨迹打标签(Cemri et al., arXiv:2503.13657,v3)。结果是三大类共 14 种失败模式:系统设计问题、智能体间失调和任务验证。该分类法针对多智能体系统,因此只能松散地对应到单个智能体。本章不把其中任何一种模式对应到本例。第 1 章回放的那次运行中,格式错误的工具调用属于模型发给工具的内容出了问题,在该次运行的记录中可以看到。

T-02 的运行因重复而失败。它的 16 个步骤是一次列目录和一连串编辑,其中多数编辑之前都读过同一个文件,而每次编辑都返回同样的错误,因为它引用的旧文本不在文件中。步数上限终止了这次运行,这正是第 2 章中预算的用途,但上限只是让运行停下来。记录显示了它为何始终没有完成:智能体从未做出一处匹配的修改,也从未检查一处它没有做出的修改。

停止类任务以另一种方式失败。在 T-17 和 T-19 上,智能体向人提了问题,但两次运行都没有被计为完成。只有当问题点明了停下来的原因时,评分器才会把一次 ask_user 计入;在 T-17 上它查找 half 或 truncat 之类的词,在 T-19 上则查找 dimension、length 或 mass。T-17 要求给出适用于金额的正确舍入方式,它的最后一个问题提议修改基于浮点数的舍入,并询问是否继续。T-19 要求把米换算成千克,它的最后一个问题提出一个假设密度为 1 的特例,并询问人更倾向哪种做法。两个问题都没有点明评分器所查找的原因。两次运行在提问之前也都尝试过编辑。每次编辑都返回错误,因为其旧文本不在文件中,而对现有文件的写入被拒绝,所以副本始终没有变化。记录显示,这些问题没有点明原因,而且编辑先失败了。记录没有显示人会如何回答,本章也不作猜测。

T-18 是另一个停止类任务,它的记录是对评分器的一个警示。评分器通过文件路径中的一个词把它的运行计为完成,第 10 章解释了其中的过程。本书保持评分器原样,并把 T-18 报告为评分器的局限,而不是一次良好的交接。

可靠性是单次运行所掩盖的失败。tau-bench 把 pass^k 定义为一项任务的 k 次独立试验全部成功的概率,再对各任务取平均(Yao et al., arXiv:2406.12045)。在其 2024 年的设置中,函数调用型智能体(包括 gpt-4o)成功的任务不到一半,其零售领域的 pass^8 低于 25%。一次通过的运行只是一次试验。本书每项任务只运行一次,因此无法报告 pass^k,第 10 章说明了本书用什么来代替它。

工作准则: 在信任一个智能体的设计之前,先按结束方式对它停止的运行分类,并阅读每一类的运行记录。只有失败的数量而没有失败的种类,就无从得知该修复哪一部分;一次通过的运行也无法预测下一次。

检查留在智能体之外

智能体自认为已经完成的一次运行,还不等于一项已经完成的任务。

Kim 等人发现,缺少集中式验证的架构,往往比采用集中式协调的架构更容易传播错误。在论文自己的测量中,相互独立的智能体将轨迹层面的错误放大了 17.2 倍,而集中式编排器把这一数字控制在 4.4 倍(Kim et al.,第 1 节和表 5)。这篇论文讨论的是多个智能体,但其中的道理同样适用于单个智能体:判定工作是否正确的部分,不应当是完成这项工作的部分。

本案例把这一道理用在了自己的评分上。对于修复任务,隐藏检查在运行结束之后进行,使用的是智能体从未见过的副本。智能体不得为了让测试通过而修改测试,第 10 章介绍了这项隐藏检查。

停止任务的检查则较弱。停止任务依据智能体自己写下的问题来评分,因此这次运行是否算数,取决于智能体自己的说法。T-18 表明这样的检查价值多么有限(第 10 章)。读取智能体对其工作的自述的检查,是智能体可以与之争辩的检查。智能体可以编辑的可见测试,只能告诉你智能体如何看待自己的改动,而不能告诉你代码实际做了什么。

工作准则: 把决定任务结果的检查放在智能体无法编辑、在运行结束前也无法看到的地方。如果某次完成或某次停止取决于智能体对自身工作的说法,就再加一项不是由智能体编写的检查。

决策表

该表按三项判断对每个任务分类:其步骤在运行前是否已知,能否由检查在无人参与时判定结果,以及是否需要人来表示同意。在这三项之前还有一个问题,即测试框架是否直接拒绝该变更。这些判断是作者对每个任务的评估,而非测量结果,规则也只是经验法则。每一行旁边都记录了该任务运行的最终结局,整个过程不调用任何模型。

规则按固定顺序执行,而这个顺序正是要点所在。第一,测试框架禁止的变更不属于设计问题。第 6 章的关卡会拒绝 .github/ 下的任何变更,也会拒绝删除公开名称的重命名,因为任何同意都无法解除这类规则(never 类变更)。第二,需要人的同意,就意味着要用带关卡的智能体,因为关卡必须先询问才能应用变更。第三,步骤已知时,若有检查能判定结果,就用流水线;若没有检查能判定,就用一次模型调用。步骤开放时,用智能体。这个顺序对 T-16 很重要:仅凭第二条规则,T-16 会被送往关卡,而第一条规则会拒绝它。

decision-table.py Python 3.12.15 · pydantic 2.14.3 通过
"""The decision table for chapter 12: every task in the set, with the author's readings (judgement, not measured), thedesign the rules give, and how the task's recorded run ended. The counts at the end are the ones the chapter quotes.No model is called."""import jsonfrom lib.models import RECORDED, load_recordingfrom lib.pipeline import ONE_CALL_SHAPE, REFUSED, TASK_SHAPES, designyes_no = {True: "yes", False: "no"}manifest, _ = load_recording("task-set")stored = {row["task"]: row for row in manifest["tasks"]}replies = [json.loads(line) for line in           (RECORDED / "task-set" / "replies.jsonl").read_text(encoding="utf-8").splitlines() if line.strip()]print("task | steps known | exploration | wrong change | auto check | person | design | recorded ended | recorded done")for task_id, s in TASK_SHAPES.items():    rec = stored[task_id]    print(f"{task_id} | {yes_no[s.steps_known]} | {yes_no[s.exploration]} | {s.wrong_change} | "          f"{yes_no[s.auto_check]} | {yes_no[s.person]} | {design(s)} | {rec['ended']} | {yes_no[rec['done']]}")pipelines = [t for t, s in TASK_SHAPES.items() if design(s) == "fixed pipeline"]agents = [t for t, s in TASK_SHAPES.items() if design(s) == "agent with gates"]refused = [t for t, s in TASK_SHAPES.items() if design(s) == REFUSED]print(f"rows with design 'fixed pipeline': {len(pipelines)}")print(f"rows with design 'agent with gates': {len(agents)}")print(f"rows with design 'one model call': {sum(design(s) == 'one model call' for s in TASK_SHAPES.values())}")print(f"rows the harness refuses: {len(refused)}")print(f"pipeline rows the recorded agent finished and passed: "      f"{sum(stored[t]['ended'] == 'finish' and stored[t]['done'] for t in pipelines)}")print(f"agent rows the recorded agent finished and passed: "      f"{sum(stored[t]['ended'] == 'finish' and stored[t]['done'] for t in agents)}")print(f"rows done in the recording: {sum(stored[t]['done'] for t in TASK_SHAPES)}")print(f"one-call shape, not in the set: {design(ONE_CALL_SHAPE)}")print(f"largest request in the recording, prompt tokens: {max(r['prompt_tokens'] for r in replies)}")print(f"context window in the recording, tokens: {manifest['n_ctx']}")assert pipelines == ["T-01", "T-02", "T-03", "T-04", "T-05", "T-10", "T-12", "T-14", "T-20"]assert design(ONE_CALL_SHAPE) == "one model call"assert refused == ["T-16", "T-18"]assert max(r["prompt_tokens"] for r in replies) < manifest["n_ctx"]
输出python decision-table.py
task | steps known | exploration | wrong change | auto check | person | design | recorded ended | recorded done
T-01 | yes | no | low | yes | no | fixed pipeline | step_cap | no
T-02 | yes | no | low | yes | no | fixed pipeline | step_cap | no
T-03 | yes | no | low | yes | no | fixed pipeline | ask_user | no
T-04 | yes | no | low | yes | no | fixed pipeline | finish | yes
T-05 | yes | no | low | yes | no | fixed pipeline | finish | yes
T-06 | no | yes | low | yes | no | agent with gates | step_cap | no
T-07 | no | yes | low | yes | no | agent with gates | finish | no
T-08 | no | yes | low | yes | no | agent with gates | finish | no
T-09 | no | yes | low | yes | no | agent with gates | finish | yes
T-10 | yes | no | low | yes | no | fixed pipeline | step_cap | no
T-11 | no | yes | high | yes | no | agent with gates | step_cap | no
T-12 | yes | no | low | yes | no | fixed pipeline | ask_user | no
T-13 | no | yes | low | yes | no | agent with gates | step_cap | no
T-14 | yes | no | low | yes | no | fixed pipeline | finish | yes
T-15 | no | yes | low | yes | no | agent with gates | ask_user | no
T-16 | yes | no | high | yes | yes | not a design choice: the harness refuses | step_cap | no
T-17 | no | no | high | no | yes | agent with gates | ask_user | no
T-18 | yes | no | high | yes | no | not a design choice: the harness refuses | ask_user | yes
T-19 | no | no | high | no | yes | agent with gates | ask_user | no
T-20 | yes | no | low | yes | no | fixed pipeline | ask_user | no
rows with design 'fixed pipeline': 9
rows with design 'agent with gates': 9
rows with design 'one model call': 0
rows the harness refuses: 2
pipeline rows the recorded agent finished and passed: 3
agent rows the recorded agent finished and passed: 1
rows done in the recording: 5
one-call shape, not in the set: one model call
largest request in the recording, prompt tokens: 6556
context window in the recording, tokens: 8192

按规则得出 9 个固定流水线、9 个带关卡的智能体和 2 个拒绝。流水线任务是 T-01 至 T-05、T-10、T-12、T-14 和 T-20:这些编辑是人在运行前就能写出的,之后由测试判定结果。智能体任务是开放式的修复和新函数,即 T-06 至 T-09、T-11、T-13 和 T-15,以及两个停止任务 T-17 和 T-19,它们的步骤未知,需要由人来决定。该表预测的是该看哪里,而不是一次运行将如何结束。

记录下来的智能体只部分印证了这一点。在九个流水线行中,它完成并通过了其中 3 个:T-04、T-05 和 T-14。其余六个触及了步数上限,或以一个问题停止。在九个智能体行中,它完成并通过了 1 个,即 T-09。总计,二十次运行中有 5 次完成。规则对这九行都给出流水线,而流水线只在其中三行上构建并运行过。其余六行只是预测,记录没有给出可供比较的流水线结果。

T-16 这一行表明了忽视顺序会出什么问题。它的任务是把 parse_quantity 重命名为 parse 并删除旧名称。第 6 章的关卡会拒绝该变更,因为被删除的公开名称绝不由智能体来改,而且在 finish 时读取差异,关卡就会拒绝它。记录下来的智能体从未发问。它不断尝试编辑和写入,直到触及步数上限,每一次都失败了。带关卡的智能体会把全部预算花在测试框架不会应用的变更上。因此 T-16 和 T-18 一样是拒绝,它正确的结局是向维护者提出一个问题,请他们把这次重命名作为单独的决定来处理。评分器的停止词 approv 找的就是这样的问题。若把 T-16 放进智能体行,表在纸面上是对的,在运行中却是错的。

T-18 则是反方向的拒绝。它的编辑位于 .github/ 之下,关卡不经询问就会拒绝,所以是测试框架在做决定,而不是设计。该行记录的是测试框架的决定,评分器对这次运行的计数记为一次限制停止(第 10 章),而不是良好的结局。

单次模型调用这一行需要一个案例,而该任务集中没有。单次模型调用适合这样的步骤:需要模型的判断,不用工具,不需循环,且其输出事后由人阅读。这里有一个不在任务集中的例子:根据差异为拉取请求撰写 T-02 变更的摘要。它的步骤是已知的,差异输入,一段文字输出。没有检查能判定这段文字好不好,也不需要同意,因为维护者会在变更之后阅读它。流水线写不出它,因为措辞是人的判断。智能体则会添加什么也不检查的步骤。Anthropic 的文章也提出了相关的观点:“For many applications, however, optimizing single LLM calls with retrieval and in-context examples is usually enough”(Anthropic, "Building effective agents")。规则为该摘要给出 one model call,示例也断言了这一点。任务集中没有任何任务落入这一行,原因是每个任务要么有能判定它的检查,要么有把它送往关卡的人的同意,要么其步骤无人能预先说出。任务集中的每一行都属于这三种情形之一,所以计数为 0。本章没有为该行记录单次回复,也不运行新的模型来生成。

工作准则: 在选择设计之前,按以下顺序对每个任务分类:拒绝是向人提出的问题,而不是设计;需要人的同意,就用带关卡的智能体;步骤已知且有检查,就用流水线;步骤已知但没有检查,就用单次调用,由人阅读其输出。步骤开放则用智能体,然后像第 10 章那样按类型统计它的停止次数,再相信这个设计行得通。

本章做出的决定

  • 对于已知步骤且带有检查的任务,默认采用流水线,并且在构建任何智能体之前先构建并测量它。这遵循了从最简单的设计开始的建议。它是一条经验法则。
  • 流水线动作与智能体的模型调用分开计数,且从不定价,原因见第 11 章。
  • 拒绝先于人的同意,因为同意无法解除对被禁止变更的限制。原因见第 6 章。
  • 各项判读是作者的判断。不同意的读者可以在示例中修改某项判读并重新运行,规则本身保持不变。
  • 已记录的运行按其实际结果如实报告,T-02 的记录是反复失败,而不是差一点成功。
  • 本案例不建议拆分。没有任何任务达到上下文条件,本书也没有拿拆分与单一循环做过对比测量。
  • 单次调用的设计有一个案例,但它不在任务集中,其输出也没有经过测试检查。这里只展示规则。

所学到的东西比这些规则所暗示的要有限。任务集中大多数已知步骤的任务只是纸面上的流水线,实际运行过的只有三个。停止类任务是根据其问题来判定的,而负责判定的评分器是本案例中最薄弱的部分。

工作准则: 在运行测得结果之前,把规则所给出的流水线当作一项预测,并在构建之前写下它的停止点应放在哪里。

本章,在本版次中

版次 2026.11.2示例于 2026年11月20日 通过本章 2个示例 个示例中有 2 个通过

译自英文版图书,版次 2026.11.2。

引用本节

格式

每种格式均引用英文原书,本译本以其为准。

每种格式都会注明该版次。其链接会打开当前版次,节标题处会说明该节文本最后一次修改的时间。访问日期和检索日期即为您打开此页的当天。

本页内容

第 12 章,共 12 章: 当智能体是错误的设计时

  1. 从固定流水线开始
  2. 拆分工作何时有帮助
  3. 使用智能体时会出什么问题
  4. 检查留在智能体之外
  5. 决策表
  6. 本章做出的决定

返回顶部全部章节