第 6 篇加了重试、降级和预算之后,选题助手终于不再卡死了。于是我放心地给它加了一个功能:整理 outputs/ 目录。
起因很普通。我在 outputs/2026-10-05-agent-topics.md 里手动改过一版——哪几个选题我想写、哪个暂时不写、有一条的角度我觉得不成立,全用批注标在文件里。然后我对它说了一句:
帮我把上周生成的那些选题整理成一个清单。
它做得很好。生成了一份干净的清单,格式正确,去重了,还按标签分了组。我扫了一眼,觉得不错。
三天后我去找那几条批注,发现它们没了。
准确地说,文件还在,但内容已经换成了它三天前生成的那份清单——我那几条批注一个字都没剩。
我打开 trace,只有一条 save_topics,参数、耗时、token 全都在,执行得完全正确。它就是不该做这件事。
这次事故同时暴露了四件事:
- 它没问过我。 我嘴里的"整理"是"读一遍给我一份清单",它那边是"整理并写回"。
- 它凭什么能写? 第 3 篇做的分层装载只是"读阶段看不到写工具"——一旦进了 write 阶段,写工具就是全开的。没有任何东西在问"这次运行到底该不该有写权限"。
- 我查不到。 trace 记了它想了什么,没记它对文件做了什么;我甚至不确定是哪次运行改的。
- 我退不回来。 没有备份、没有版本,那几条批注只存在于被覆盖的那一版里。
这四件,正好是本篇的四个词:确认、权限、审计、回滚。
而且它们不是四件并列的事,是一条链。先给结论:
你能给它多大权限,取决于你能查得多细、退得多干净。
这句话决定了后面所有内容的结构:权限是目的,另外三个是它的成本。 你想要更大的自主权,就得先付审计和回滚的钱。
还有一句是本篇最想反驳的:
在提示词里写「删除前请确认」,不是权限控制,是祈使句。
阅读提示:本文是「Agent 工程进阶」系列的第 7 篇(收尾篇),面向已经有一个跑得起来的 Agent、并且它开始接触真实文件或外部系统的读者。如果你还没做过第一个 Agent,建议先看新手系列的让 Agent 更像项目:工具、记忆、文件读写和简单界面。如果你想要一张整体地图,可以看第 0 篇从 Demo 到可交付:如何做一个 Agent 项目。
一、先别问「危不危险」,问「能不能退回来」
“危险"是一种感觉,没法拿来做工程决策。换成两个能算的维度:
- 可逆性:做错了,能不能恢复原样?要多大的成本?
- 影响面:影响的是它自己的产物,还是别人的资产?
按这两个维度分四级:
| 级别 | 例子 | 可逆? | 影响面 | 默认该怎么做 |
|---|---|---|---|---|
| L0 只读 | 检索、读文件、列目录 | 天然可逆(什么都没改) | 无 | 直接给,不用问 |
| L1 可逆写 | 写自己 outputs/ 下的新文件、写草稿、记录采纳 | 可(有快照或可重建) | 只有自己 | 自动执行 + 审计 |
| L2 难逆写 | 覆盖/删除已有文件、改配置、写长期记忆 | 难(要靠备份) | 自己 + 协作者 | 给 diff 确认 |
| L3 外部动作 | 发邮件、发消息、提 PR、下订单、改生产库 | 基本不可逆,只能补偿 | 他人 / 外部系统 | 必须确认,且要有补偿预案 |
本节最有价值的一句是这个:
可逆性不是动作的属性,是系统的属性——它是可以被工程改造的。
save_topics 覆盖一个已有文件,按表算是 L2,该问。但如果你在它内部加一句"写之前先把原文件复制进 .snapshots/",它就变成了 L1,不用问。同一个动作,从"必须确认"变成了"可以放心去做”。
由此得出本篇最实用的一条:
先做可逆,再谈授权。
与其纠结"这个动作要不要弹确认",不如先花十分钟把它做成可逆的——那样你既不用弹窗,也真的更安全。这是本篇四件事里唯一一件能同时降低另外三件压力的:有了快照,很多动作就从"必须问"变成了"不用问";就算没问,审计里也留着 before;就算审计漏了,人还能退回去。
反过来的那半句同样重要:
不可逆的动作,无论多小都要确认。 一条 100 字的消息发出去,就是发出去了。
两个容易漏的点。
影响面比危险程度更容易被低估。 我在自己的 outputs/ 里写文件,看起来影响面只有我自己。但那份清单我可能会发给别人、可能已经被别的地方引用了。「这是我自己的目录」不等于「影响面只有我」。
记忆写入属于 L2,而且比文件写入更难发现。 一条被写错的 preference 会污染之后所有的输出(第 2 篇的三道防污染防线),但它不像一个被覆盖的文件那样有明显症状——它只是让输出慢慢地、说不清地偏掉。所以记忆写入至少要跟文件写入同级对待,我自己的标准是更严一档。
二、权限分级:载体是 capability,不是提示词
第 3 篇做过"分层装载":读阶段看不到写工具。那一招解决的是"它在思考的时候,旁边摆着一个保存按钮"。
但它没解决另一个问题:这次运行,到底该不该有写权限?
“帮我整理一下"和"帮我整理并保存”,在我嘴里可能是同一句话,在系统眼里必须是两种完全不同的 capability。而"按阶段授予"做不到这一点——两条请求走的是同一条 pipeline,进到 write 阶段就都一样了。
四条原则。
1. 权限写在代码里,不写在提示词里
提示词里写"你没有写权限",模型大概率会遵守。但大概率不是保证,而且它恰恰会在你最需要它生效的时候失效——当它判断"用户显然是想让我保存的"时,那句提示词就被它自己的推理盖过去了。
真正管用的是两条:写工具根本不在它的 tools 列表里(第 3 篇),或者调用了会被 registry 拦下来(本篇第六节)。两者的共同点是:模型没有"遵守与否"的选择权。
2. 按运行授予,不按阶段授予
第 4 篇把权限按阶段分(research 只读、write 可写),已经是很大的进步。更细的一层是:在本次运行开始时,根据这次请求的性质决定授予什么。
用户说的是"帮我看看",那就整次运行全程没有 capability——哪怕流程走到了 write 阶段。
3. 模型不能给自己提权,只能申请
一个很常见的反面设计:给模型一个 request_permission("write") 工具。这等于把权限系统降级成了一个建议系统——它自己申请,然后自己判断申请是否被批准。
正确做法是:模型只能产出一个待批准动作,由编排层挂起、交给人;人批准之后,由代码带着新的 capability 重新发起这一段,而不是让模型"获得权限"。区别在于:批准发生在模型之外,而且批准的那一次执行是确定的、可审计的。
4. 外部动作单独一道
发消息、花钱、改别人的东西,不要跟文件写共用一套 capability。因为它们不可逆(下一节讲补偿),而且影响的是第三方——影响面这一项就足以让它独立成级。
顺便把第 4 篇留下的那句"权限隔离是拆多 Agent 的正当理由"说得更精确些:真正需要隔离的不是"角色",是"动作的风险等级"。 让一个只有只读 capability 的阶段去生成、让一个有写 capability 的阶段去落盘——这跟是不是多 Agent 没关系,单个 Agent 换能力集一样做得到。用拆 Agent 来实现权限隔离,通常是把一件十行代码的事变成了一个架构。
三、确认:什么时候该问,怎么问才有人看
先说不该怎么问。
确认疲劳是真实存在的,而且它比没有确认更危险。 一个每次都弹窗的系统,用户会在第三次就开始无脑点掉——那时候你的确认不但没提供保护,还额外提供了一个"我已经确认过了"的免责错觉。
每次都问 = 每次都没问。
三条该问的判据
- 不可逆:L3,以及没有备份兜底的 L2。
- 影响他人或外部系统:发消息、花钱、改共享资源。哪怕技术上可逆。
- 模型自己判不了:它拿不准要不要做。这一条要靠一个显式信号,不能靠"它说它不确定"——具体做法是允许它产出
needs_confirmation,并且不给它"猜着做完"的选项。
确认要给 diff,不要给意图
这是本节最重要的一句:
确认要给人 diff,不要给人意图。
对比一下:
❌ "我要更新 outputs/2026-10-05-agent-topics.md,可以吗?"
✅ "将覆盖 outputs/2026-10-05-agent-topics.md
原文件:1.8KB,3 天前手动改过(非本次生成)
变更为:2.4KB(本次生成)
原文件已备份至 .snapshots/run-7f3a/,可一键恢复
[允许] [只允许新增,不覆盖] [取消]"
三要素:改什么(具体到路径和量级)、原来是什么(说明这是你的东西,不是它自己的产物)、退路在哪(快照路径或补偿方案)。
缺了第二个要素,用户看到的只是一个文件名,他根本想不起来那里面有什么——所以他只能点"允许"。大部分被无脑点掉的确认,都是因为确认框里没有足够的信息让人做出判断。
另外三条
给选项,不只给「是/否」。 上面那个"只允许新增,不覆盖"往往才是真实需求。用户通常不是要拒绝,是要一个更保守的版本——你不给他这个选项,他就只能在"允许"和"打断整个流程"之间选。
超时 = 不执行。 这是 fail-safe 的基本功。人没回应的时候,默认动作必须是"什么都不做",而不是"照原计划做"。反过来设计的系统,会在人去开会的时候自己把事办了。
确认要记进 trace。 谁批准的、什么时候、当时看到的 diff 摘要是什么。回第 5 篇:边界集里"该问的问了吗"这一类用例,靠的就是这个字段。
一个反直觉的结论
减少确认的正确方式不是提高自动化程度,是提高可逆性。
很多人为了少弹窗去放宽确认条件,那是拿安全换流畅。正确的顺序是:先把动作做成可逆的(快照、dry-run、软删除),然后它自然就不再需要确认——因为你已经把"问"换成了"能退"。
四、审计:trace 不是审计日志
这个混淆太常见了,值得单列一节。
第 5 篇建立的 trace 回答的是:它是怎么想的。 每一步的输入摘要、工具调用、token、耗时、gate 错误。
审计日志回答的是另一个问题:它对世界做了什么。
两者都要,但不能互相替代。trace 上没有"文件被改成了什么",审计日志上没有"它当时为什么那么做"。我那次事故里,trace 是完整的——完整到我能看到它调了 save_topics、参数都对、耗时 340ms——但它一个字都没告诉我文件原来长什么样。
一条审计记录至少要有这些字段:
| 字段 | 为什么要有 |
|---|---|
run_id / step_id | 能连回 trace,回答"它为什么这么做" |
actor | 是 Agent 自动做的,还是人批准的 |
action | save / delete / send / pay——动词,不是工具名 |
target | 具体路径、收件人、金额 |
before / after | 前后状态或 hash。没有 before 就没有回滚 |
authority | 这次动作凭什么被允许:capability 名 + 批准人 + 时间 |
reversible | L1 / L2 / L3,以及退路是什么(快照路径 / 补偿动作) |
result | 成功 / 失败 / 被拒绝 |
三条硬要求。
1. 只增不改(append-only)。 审计日志存在的全部意义是"事后能查",一条能被修改的日志不叫日志。JSONL 追加写,或者写进一张不允许 update 的表。
2. 失败和被拒绝的动作也要记。 这一条最容易被漏,也最有价值:
被拦下的尝试,是整套系统里信噪比最高的信号。
它同时说明三件事:模型想做一件它不该做的事(说明工具描述或权限设置有问题)、你的护栏确实生效了、以及这个角落将来可能会出事。回第 5 篇——边界集里"该拒答"的那类用例,最好的来源就是审计日志里的 result=denied,因为它们是真实发生过的企图,不是你想出来的刁难。
3. 人要能查到。 不要只存在于日志平台里。给一个最简单的命令或者一个 md 文件,让人能回答"过去一周它改过哪些文件"。这一条的验收标准很朴素:
凌晨两点,你能在三分钟内查出来吗?
查不出来的审计日志,等于把答案锁在一个你出事时才想不起密码的柜子里。
五、回滚:先想好怎么退,再决定要不要走
三种粒度,从轻到重:
| 粒度 | 适用 | 做法 |
|---|---|---|
| 撤销一次写 | 单个文件被覆盖/改坏 | 从 .snapshots/ 恢复那一个文件 |
| 回到检查点 | 一次运行改了好几个东西 | 第 4 篇的 step_id + 该次运行的全部 before 快照 |
| 补偿动作 | L3 外部动作 | 没有 undo,只能做一件反向的事 |
本节最硬的一条:
外部动作没有 undo,只有补偿。而且补偿往往比原动作更贵、更难堪。
一条已经发出去的群消息,撤回功能不是你能依赖的东西;一封已经发出去的邮件,只能再发一封"上一封作废"。所以 L3 动作的正确做法不是"事后想办法",是事先就把补偿动作写好,并且让它跟原动作定义在同一个地方——而不是散落在某次复盘里。
备份写在写工具内部,不要写在流程外面
这是我在那次事故里学到的最具体的一条。
如果你把备份写在 pipeline.py 里,那么任何绕过 pipeline 的调用——手动脚本、另一个入口、Agent 自己找到的某条路——都没有备份。写进 save_topics 内部,它就变成了这个工具的一个属性,像第 3 篇的 atomic_write 一样,谁调用都躲不掉。
dry-run / 影子模式先跑一遍
对任何新的写能力,先让它跑一周"只记录不执行":所有动作照常生成、照常进审计日志(标记 dry_run: true),但不落盘。
一周后你看日志,就知道它想做多少事、其中有多少是你会批准的、有多少连它自己都不确定。这比在脑子里评估"它可不可靠"有用得多,而且它零风险——这是本篇唯一一个可以先于所有其他机制上线的东西。
回滚演练
一句很难听但很真的话:
没被演练过的回滚,等于没有回滚。
快照目录权限不对、被 .gitignore 一起忽略掉了、恢复脚本三个月前因为改目录结构失效了——这些都是常态,而且它们全都是"看起来一直有备份,直到你要用的那天"。
做法很轻:每加一种新的写能力,手动恢复一次。 就一次。
两个前置依赖
回滚的前提是幂等 + 前后状态记录:没有 idempotency_key 就没有"重做一次",没有 before 快照就没有"退回去"(第 3 篇)。你在第 3 篇为幂等花的力气,在这一篇变成了回滚能力。
还有一条跟第 6 篇的接缝:L5 降级交给人之后,人接手做的那部分也该进审计——所以 actor 字段不能只有 “agent” 一个值。第 6 篇说交接时要带"state + 已尝试记录 + 失败分类",本篇补上半句:交接之后发生的事,也要能被查到。
六、动手改一遍:给选题助手加一层边界
目标很具体:同样是"帮我整理一下",从"直接覆盖我手动改过的文件"变成"要么不写、要么带着 diff 问我,而我随时能退回来"。
目录
src/
pipeline.py
guard/
risk.py # 工具 -> 风险等级(L0/L1/L2/L3)
capability.py # 这次运行被授予了什么
confirm.py # 挂起 + diff + 超时不执行
audit.py # append-only 审计日志
snapshot.py # 写前快照 + 恢复
tools/
registry.py # 第 3 篇的,加一道 capability 检查
save.py # 内部自带快照
audit/
actions.jsonl
改之前
第 4 篇留下的那段(留着当对照组):
# src/pipeline.py —— 改之前
result = write.run(st, tools=registry.active_tools("write"))
if not gates.check_saved(result):
return handoff_to_human(st, "保存结果校验失败")
return result
四个问题:没问过我(“整理"被当成"整理并保存”)、写权限是阶段默认给的(进了 write 阶段就全开)、改了什么没有独立记录(trace 里有 save_topics,但没有 before/after)、退不回来(没有快照)。
第一步:给工具标风险等级
# src/guard/risk.py
RISK = {
"list_topics": "L0", # 只读
"suggest_topics": "L0",
"save_topics": "L2", # 会覆盖已有文件 -> 要确认(除非有快照)
"record_adoption": "L1", # 自己的产物,可重建
"update_memory": "L2", # 写错了会污染之后所有输出(第 2 篇)
"delete_file": "L2",
"send_email": "L3", # 外部动作,只能补偿
}
def level(tool: str) -> str:
return RISK.get(tool, "L2") # 未知工具按 L2,不按 L0
请注意最后一行:未知按严,不按松。 新加的工具忘了标,它应该被当成 L2 拦下来提醒你,而不是被当成 L0 悄悄放过去。
第二步:capability 按运行授予
# src/guard/capability.py
@dataclass
class Capability:
can_write: bool = False # 默认没有写权限
allowed_dirs: tuple = ()
approved_by: str | None = None
approved_at: float | None = None
def grant_for(user_input: str) -> Capability:
"""按这次请求的性质授予,不按阶段授予"""
if mentions(user_input, "保存", "写入", "存到", "写到"):
return Capability(can_write=True, allowed_dirs=("outputs",))
return Capability() # 包括"整理一下/帮我看看/分析一下"
最后那行是关键:判不了就不给。 权限系统的默认态必须是"没有",而不是"尽量满足"。
然后在第 3 篇那个 call 里加一道:
# src/tools/registry.py —— 加一道
def call(name, args, *, mode="read", cap: Capability = None):
if name in WRITE and not (cap and cap.can_write):
audit.log(run_id=current_run(), action="denied_write", target=name,
authority="none", result="denied") # 被拒绝的也要记
return Result.fail("permission_denied", f"{name} 需要写权限",
hint="这次运行未被授予写权限。如需保存,请向用户确认后重新发起")
...
第三步:要确认时挂起,给 diff,超时不执行
# src/guard/confirm.py
def ask_if_needed(tool: str, args: dict, cap: Capability, *, timeout=120) -> bool:
lvl = risk.level(tool)
if lvl == "L0" or (lvl == "L1" and cap.can_write):
return True # 只读,或可逆且已授权 -> 不问
diff = build_diff(tool, args) # 路径 / 原大小 / 是否手动改过 / 备份位置
req = pending.put(run_id=current_run(), tool=tool, args=args,
diff=diff, level=lvl)
verdict = wait_for_human(req.id, timeout=timeout)
audit.log(actor="human", authority=f"{verdict.by}@{verdict.at}" if verdict else None,
action=tool, target=args.get("path"), result="approved" if verdict else "timeout")
return verdict is not None and verdict.allow # 超时 -> None -> 不执行
那句 verdict is not None 就是「超时 = 不执行」的落地。它看起来只是一行,写反了的话,你的系统会在人去开会的时候自己动手。
build_diff 产出的就是第三节 ✅ 那一段:改什么、原来是什么、退路在哪,外加一个更保守的选项。
第四步:审计日志
# src/guard/audit.py
def log(*, run_id, step_id=None, actor, action, target,
before=None, after=None, authority=None, reversible=None, result):
rec = {"ts": time.time(), "run_id": run_id, "step_id": step_id,
"actor": actor, "action": action, "target": target,
"before": before, "after": after, # 没有 before 就没有回滚
"authority": authority, "reversible": reversible, "result": result}
with open("audit/actions.jsonl", "a", encoding="utf-8") as f:
f.write(json.dumps(rec, ensure_ascii=False) + "\n") # append-only
配套一个查询命令,满足第四节第 3 条「人要能查到」:
$ python -m guard.audit --since 7d --action save
2026-10-05 14:22 run-7f3a save_topics
target outputs/2026-10-05-agent-topics.md
before 1.8KB sha=a91f2c -> after 2.4KB sha=77e0b1
authority capability(write) by kevin@14:21
reversible L1 .snapshots/run-7f3a/
[restore]
第五步:快照,写在写工具内部
# src/tools/save.py
def save_topics(*, title, angle, outline, tags, path):
snap = snapshot.take(path, run_id=current_run()) if os.path.exists(path) else None
atomic_write(path, render(title, angle, outline, tags))
return Result.ok(
path=path, snapshot=snap,
reversible="L1", # 有快照 => 从 L2 变 L1
msg=f"已写入 {path}" + (f",原文件已备份到 {snap}" if snap else ""),
)
reversible="L1" 这一行就是第一节那句「可逆性是可以被工程改造的」的落地:同一个 save_topics,加了快照之后从"要问"变成"不用问"。这是整个改造里性价比最高的一处——十行代码,换来确认次数和事故半径同时下降。
# src/guard/snapshot.py
def restore(run_id: str):
"""每加一种新的写能力,至少手动跑一次这个函数"""
for rec in audit.query(run_id=run_id, result="ok"):
if rec.get("before"):
shutil.copy(rec["snapshot_path"], rec["target"])
audit.log(run_id=run_id, actor="human", action="restore",
target=rec["target"], authority="manual", result="ok")
第六步:编排层接起来
# src/pipeline.py —— 改之后(节选)
def run_pipeline(user_input: str):
st = init_state(user_input)
cap = grant_for(user_input) # 按这次请求授予,全程不变
... # research 阶段(L0,照旧)
if not cap.can_write: # "整理一下" 到这里就结束了
return Draft(result, notice="本次未授予写权限,以下是草稿,未落盘")
plan = write.plan(st) # 先只规划,不执行
for act in plan:
if not confirm.ask_if_needed(act.tool, act.args, cap):
audit.log(run_id=st.run_id, actor="agent", action=act.tool,
target=act.args.get("path"), result="denied")
continue
out = registry.call(act.tool, act.args, mode="write", cap=cap)
audit.log(run_id=st.run_id, step_id=st.step_id, actor="agent",
action=act.tool, target=out.get("path"),
before=out.get("snapshot"), after=out.get("hash"),
authority=f"capability(write) by {cap.approved_by}",
reversible=out.get("reversible"), result="ok")
return result
改完之后的对比
| 改之前(阶段默认给写权限) | 改之后(capability + 确认 + 审计 + 快照) | |
|---|---|---|
| 用户说「整理一下」 | 进 write 阶段后直接写 | 判定为只读意图,出草稿不落盘 |
| 覆盖已有文件 | 直接覆盖,无记录 | 先快照,前后 hash 都进审计 |
| 该不该问人 | 从来不问 | L2/L3 给 diff 确认;L1(有快照)不问 |
| 人没回应 | 不存在这个情况(它不等人) | 超时 = 不执行 |
| 被拦下的动作 | 无从得知 | result=denied 进审计,是边界集的用例来源 |
| 「上周它改了哪些文件」 | 查不到 | 一条命令,带 before/after 和恢复入口 |
| 恢复 | 手动重写 | restore(run_id),一键 |
| 新工具忘了标风险 | 默默可用 | 默认 L2,被拦下来提醒 |
| 发邮件这类外部动作 | 与文件写同级 | L3,单独一道 + 必须写补偿动作 |
| 记忆写入 | 无人看管 | 按 L2 对待,更新也要留 before |
七、一份可以直接照着自查的清单
关于权限
- 你的写权限是按阶段给的,还是按这次请求给的?
- 用户说「帮我看看」的时候,这次运行有没有写能力?
- 权限是写在提示词里还是代码里?把那句"你没有写权限"从 prompt 里删掉,系统行为会变吗?(会变,就说明你靠的是概率)
- 模型能不能给自己提权?有没有
request_permission这类工具? - 新加的工具忘了标风险等级,默认是放行还是拦下?
关于确认
- 最近一周,你的确认被无脑点掉过几次?
- 确认框里给的是意图(“我要更新文件”)还是 diff(路径、原大小、是不是你手动改过的、备份在哪)?
- 人没回应的时候,默认动作是执行还是不执行?
- 除了「是/否」,有没有第三个更保守的选项?
- 批准人和批准时间有没有记进 trace?
- L3 动作之前,补偿动作写好了吗?跟原动作在同一个地方吗?
关于审计
- trace 和审计日志是不是同一份东西?(它们回答的是两个问题)
- 审计记录里有没有
before?没有 before 就没有回滚。 - 被拒绝的动作记不记?
- 能不能在三步之内查到"过去一周它改了哪些文件"?
- 日志是 append-only 吗?有没有人(或它自己)能改?
关于回滚
- 每加一种新的写能力,你手动恢复过一次吗?
- 备份是写在写工具内部,还是写在流程外面?绕过主流程的调用有备份吗?
- 快照目录有没有被
.gitignore一起忽略掉? - L3 动作的补偿方案写在哪?跟原动作在同一个地方吗?
- 新的写能力有没有先跑过 dry-run?
常见误区
误区一:在提示词里写「操作前请确认」就是权限控制。 不是,那是祈使句。模型大概率会遵守,但概率不是保证,而且它恰恰会在"它判断用户显然想要"的时候失效——也就是你最需要它生效的时候。
误区二:确认越频繁越安全。 正好相反。每次都问,用户第三次就开始无脑点掉,那时候你不但没有保护,还多了一个"已确认"的免责错觉。减少确认的正确方式是提高可逆性,不是放宽确认条件。
误区三:权限按角色或阶段分就够了。 阶段是静态的,请求是动态的。“帮我看看"和"帮我保存"走同一条 pipeline,却应该有完全不同的 capability。
误区四:有 trace 就够了,不用单独做审计。 trace 记的是"它怎么想的”,审计记的是"它对世界做了什么"。前者没有 before/after,后者没有推理过程。出事的时候你两个都要——我那次事故的 trace 是完整的,但它回答不了"文件原来是什么"。
误区五:只记成功的动作。 被拒绝的动作是信噪比最高的信号:它同时说明模型想越界、你的护栏生效了、以及这个角落将来可能出事。它还是第 5 篇边界集里"该拒答"用例的现成来源。
误区六:备份写在主流程里就行。 绕过主流程的调用(手动脚本、别的入口、Agent 自己找到的路)就没有备份。写进工具内部,它才变成这个工具的属性。
误区七:回滚方案写下来就算有了。 没演练过的回滚等于没有。快照目录被 gitignore 掉、恢复脚本因目录重构失效——这些都是常态,而且全都是"看起来一直有备份,直到你要用的那天"。
人机边界在整套系统里的位置
本篇是保障层的最后一块,也是唯一一块前面六篇的产出都会流进来的地方:
- 上下文工程(第 1 篇):确认请求本身也是上下文——它会被塞进历史里,所以 diff 要短、要结构化,否则多问几次,上下文就被确认记录污染了。反过来,权限隔离也是「隔」的一种:看不见的工具不会污染判断。
- 记忆系统(第 2 篇):记忆写入按 L2 对待,一条写错的
preference会污染之后所有输出而且症状不明显。另外那里提到的「用户能不能查看、要求删除」,落到这里就是两条具体能力:审计里能筛出所有action=update_memory的记录,以及restore能按记忆 id 精确回滚。 - 工具设计(第 3 篇):分层装载是本篇 capability 的前身——那里是"不同阶段看到不同工具",这里是"不同运行拿到不同能力"。而
idempotency_key与atomic_write是回滚的前提。第 3 篇是本篇的地基。 - 编排(第 4 篇):确认点就是编排里的挂起;gate 是确定性的那道检查,确认是人的那道 gate。而
step_id是审计记录的锚点——没有它,审计只能记到"某次运行",记不到"某一步"。 - 评估(第 5 篇):边界集里"该拒答"的用例,最好的来源是审计中的
result=denied;而"该问的问了吗"要靠确认记录进 trace 才能测。人工接管率(第 5 篇说过的那个在线指标)就是本篇确认系统的直接产物。 - 可靠性(第 6 篇):L5 降级(交给人)就是本篇的入口。第 6 篇说交接时要带"state + 已尝试记录 + 失败分类",本篇补上后半句:人接手之后做的那部分,也要进审计,
actor不能只有一个值。
七篇写下来,其实在讲同一件事的不同侧面:
让模型做它擅长的判断,让代码守住那些不能靠概率的边界。
第 1 篇管上下文,第 2 篇管记忆,第 3 篇管手,第 4 篇管顺序,第 5 篇管测量,第 6 篇管失败,第 7 篇管边界。七篇里被反复强调的其实只有一条:能用代码固定的,就不要交给模型去"想起来"。
权限如此,确认如此,审计如此,回滚更是如此。
回到开头那几条批注
那几条批注我最后没有找回来。它们只存在于我手动改过的那一版里,而那一版被覆盖了,没有备份。
现在同样的场景是这样跑的:我说"整理一下",grant_for 判定这是只读意图,整次运行没有 capability。它读完给我一份清单,不落盘。
如果我说的是"整理一下,存到 outputs/",它会拿到写 capability,走进 write 阶段;save_topics 发现目标文件已存在,先拍一份快照,写完返回 reversible: L1;审计日志多一行 before/after 和 authority。三天后我要找批注,一条命令列出那次改动,restore(run-7f3a) 一键拿回来。
两个版本的差别,不在于"它更聪明了"——它一样会把"整理"理解成"整理并保存"。差别在于:这次就算它理解错了,也只是多了一份我不需要的草稿。
人机边界的终点不是让人盯着每一个动作,是让人在任何时候都能回答三个问题:它做了什么?凭什么能做?能不能退回去?
在那之前,先做最小的一步:打开你的写工具,看一眼它有没有在覆盖已有文件之前留一份快照。
这一步大概十行代码,而且它是本篇四件事里唯一一件能立刻把另外三件的压力都降下来的——因为有了它,很多动作就从"必须问"变成了"不用问";就算没问,审计里也留着 before;就算审计漏了,你还能退回去。
先做可逆,再谈授权。
本系列目录
这是「Agent 工程进阶」系列的第 7 篇(收尾篇)。
- 第 0 篇(地图):从 Demo 到可交付:如何做一个 Agent 项目
- 第 1 篇:上下文工程:为什么你的 Agent 越聊越笨
- 第 2 篇:记忆系统:Agent 怎么记住该记的,忘掉该忘的
- 第 3 篇:工具设计深水区:粒度、错误语义、幂等与 MCP
- 第 4 篇:编排与多 Agent:什么时候该拆,什么时候千万别拆
- 第 5 篇:评估体系:怎么知道你的 Agent 变差了
- 第 6 篇:可靠性与成本:什么时候该重试,什么时候该放弃
- 第 7 篇:人机边界:什么时候该问人,什么时候该放心让它做(当前篇)
新手系列入口(偏入门,建议先跑通第一个 Agent):先听懂:AI、LLM、Prompt、Agent、RAG、Tool、Memory 到底是什么
