《AI Agent 产品开发·交互、信任与上线》9.3 冲突与覆盖

两个人同时改同一份报告,或者人与 Agent 同时改,冲突不会因为界面没提示就不存在。本节把冲突策略拆成后写赢、加锁、合并三种,给出选择依据与人的编辑优先规则,用 B Quill 的协同编辑说明 Agent 参与的隐性覆盖,并给出可运行的冲突判定与合并模型。

以下人物、公司与数字均为教学假设,不构成对任何真实产品的评价。

多人共用一个 Agent,冲突迟早会发生:两个咨询顾问同时改同一份报告,一个坐席在看建议时另一个坐席点了采纳,Agent 在人生成到一半时重新生成了一章。冲突本身不可怕,可怕的是产品没有告诉任何人「谁覆盖了谁」。

这一节讨论三种冲突策略的适用条件,以及一个更隐蔽的问题:Agent 参与的冲突,往往不会出现在编辑器的冲突提示里。

三种策略,各有各的代价

冲突策略看起来很多,归根到底只有三种。

策略做法适合代价
后写赢以最后一次提交为准同一作者、可回退、低风险字段静默丢失前一次修改
加锁同一时间只允许一个人改高风险字段、发布前、不可逆动作等待、阻塞、锁忘记释放
合并不同字段各取所值,同字段标冲突章节独立、字段不重叠需要字段级版本与人工裁决

三种策略没有绝对优劣,只有适用条件。后写赢最省事,但它的代价是「丢失」:前一个人的修改不会报错,只会消失。加锁最安全,但它的代价是「阻塞」:一个人改的时候,其他人只能等。合并最灵活,但它的代价是「复杂」:需要知道每个字段的版本,还要有人处理冲突。

产品常见的错误,是把三种策略混成一个默认值。比如所有字段都用后写赢,理由是「简单」;等到一份报告被覆盖了三次,才发现简单的是实现,不是后果。

选择依据:四个问题

选择策略时,可以按四个问题走。

第一问:两次改动是不是落在同一个字段上? 不是,就合并。章节之间、字段之间互不影响,没有理由让它们互相阻塞。

第二问:是不是同一个作者? 是,后写赢通常可以接受,因为作者知道自己改了什么。不是,就要看第三问。

第三问:这个字段需不需要人工复核? 需要,就加锁。发布前的关键结论、对外承诺、金额字段,都属于这一类。

第四问:改动可不可逆? 不可逆,就加锁。可逆的字段可以后写赢,因为丢了还能找回来;不可逆的字段一旦覆盖,代价不是「重做」,而是「无法复原」。

四个问题不是并列打分,而是按顺序排除:先看字段是否重叠,再看作者是否相同,再看是否需复核,最后看是否可逆。顺序本身就是优先级:字段不重叠时,后面三问都不用问。

B Quill 的协同编辑

B Quill 是 Meridian 的客户报告起草 Agent,月报告量 606 份,咨询团队 15 人。人工基线是每份 4.2 小时,Agent 介入后人工审改 1.6 小时。一次采纳率 63%,小改率 28%,返工率 9%。

这组数字说明 B 的产出大部分需要人动,但动的是细节,不是重写。协同编辑的冲突,通常也发生在细节上:一个顾问改了摘要的措辞,另一个顾问改了指标口径,Agent 又在同一时间重新生成了整章。

如果三个人改的是不同章节,合并就够了。如果两个顾问改的是同一段摘要,就需要加锁或人工裁决。如果 Agent 重新生成的章节基于旧版本,而人已经改过这一章,冲突就更隐蔽:编辑器里不会出现「有人正在修改」的提示,因为 Agent 不是一个可见的协作者。

B 的审改时长按三档加权:63% 采纳档 1.25 小时,28% 小改档 1.95 小时,9% 返工档 3.0 小时,加权结果是 1.6035 小时,约 1.6 小时。这个数字背后是大量的局部修改,而局部修改正是冲突的高发区。

Agent 参与的冲突更隐蔽

人和人之间的冲突,至少有界面提示:光标、锁定、冲突标记。Agent 参与的冲突,往往没有这些信号。

Agent 的典型工作方式是:读取一个版本的输入,生成一份新内容,然后提交。如果它读取的是旧版本,提交时又覆盖了新版本,就发生了「过期写入」。在界面上,这看起来不像冲突,而像「Agent 刚刚生成了一版」,人甚至可能以为自己的修改已经被包含进去。

过期写入有三个特征:

  • 没有并发提示。 Agent 不是一个在线协作者,界面不会显示「它正在改」。
  • 覆盖是整段发生的。 人改的是一个句子,Agent 覆盖的是整章,冲突范围被放大。
  • 时间差不容易察觉。 人生成到一半去开会,回来看到的是 Agent 的新版本,很难判断自己的修改还在不在。

因此,Agent 的写入必须带版本号。它提交时,产品要比较「它读取的版本」和「当前版本」;不一致就拒绝写入,或者把差异交给人工裁决,而不是默默覆盖。

人的编辑永远优先

在内容类任务里,有一条规则应该写死:人的编辑优先于 Agent 的草稿。

原因不是「人更聪明」,而是责任分配。B 的自主档是草稿,Agent 承担生成,不承担发布;人承担审改与发布,也就承担了内容的最终责任。既然责任在人,控制权就必须在人。

这条规则要落到三个动作上:

  • 人改过的字段,Agent 不能自动覆盖。 重新生成时,跳过被人改过的段落,或者把人的版本作为新基线。
  • Agent 的修改必须可识别。 界面上要能看出哪一段是 Agent 生成的、哪一段是人改的,否则审改时无法判断。
  • 冲突要留记录。 谁在什么时候覆盖了谁、基于哪个版本,都要能查。记录不是为了追责,而是为了下次避免同样的覆盖。

人的编辑优先,不等于 Agent 的修改没有价值。它只是说明:在责任没有转移之前,控制权不能转移。

合并、加锁与后写赢的落地

三种策略落到产品上,对应三种交互。

合并适合章节独立的报告。每个章节有独立的版本号,提交时只比较本章节;不同章节的修改互不阻塞,同章节的冲突进入人工裁决列表。B 的 12–20 页报告天然适合按章节合并。

加锁适合发布前的关键字段。报告标题、核心结论、对外承诺的金额,在同一时间只允许一个人改。锁要有超时,避免有人忘记释放;锁的范围要小,避免一个人锁住整份报告。

后写赢适合同一作者的低风险字段。比如顾问自己调整措辞,改两次只保留最后一次,符合直觉。但后写赢必须限定在「同一作者 + 可逆字段」,跨作者或不可逆字段不能使用。

三种策略可以共存于同一份报告,关键是按字段类型分配,而不是按整份文档分配。整份文档用一个策略,要么太松,要么太紧。

把冲突判断写成模型

下面这个模型把策略选择、字段级裁决、过期写入检测和章节合并写在一起。chooseStrategy 决定用哪种策略,resolveField 决定同字段谁赢,isStaleAgentDraft 检测 Agent 是否拿着旧底稿重写。

// file: src/trust/09-3-conflict-resolution.ts
// tier: L2
// verify: node --test test/trust/09-3-conflict-resolution.test.ts

// 两个人同时改,或者人与 Agent 同时改,冲突的解法不是「谁后写谁赢」,
// 而是先判断两次改动是不是落在同一个字段上。

import { QUILL } from "../cases.ts";

export type Author = "human" | "agent";
export type Strategy = "last-write-wins" | "lock" | "merge";

export type Change = {
  readonly sameField: boolean;
  readonly sameAuthor: boolean;
  readonly reversible: boolean;
  readonly needsHumanReview: boolean;
};

export function chooseStrategy(change: Change): Strategy {
  if (!change.sameField) return "merge";
  if (!change.sameAuthor && change.needsHumanReview) return "lock";
  if (!change.sameAuthor) return "last-write-wins";
  if (!change.reversible) return "lock";
  return "last-write-wins";
}

export type Stamped<T> = {
  readonly value: T;
  readonly version: number;
  readonly by: Author;
};

export type Resolution<T> = {
  readonly winner: Stamped<T>;
  readonly conflict: boolean;
  readonly reason: string;
};

// 冲突优先级:过期写入让位,人的编辑压过 Agent 草稿,
// 同版本不同值保留当前值并标记冲突,其余取新版本。
export function resolveField<T>(
  current: Stamped<T>,
  incoming: Stamped<T>,
): Resolution<T> {
  if (incoming.version < current.version) {
    return { winner: current, conflict: true, reason: "stale-write" };
  }
  if (incoming.by === "agent" && current.by === "human") {
    return { winner: current, conflict: true, reason: "human-priority" };
  }
  if (incoming.by === "human" && current.by === "agent") {
    return {
      winner: incoming,
      conflict: false,
      reason: "human-overrides-agent",
    };
  }
  if (incoming.version === current.version && incoming.value !== current.value) {
    return { winner: current, conflict: true, reason: "same-version-diverge" };
  }
  return { winner: incoming, conflict: false, reason: "latest-version" };
}

export type AgentDraft = {
  readonly section: string;
  readonly baseVersion: number;
  readonly currentVersion: number;
};

// Agent 参与的冲突更隐蔽:它不会同时出现在编辑器里,
// 而是拿着一份旧底稿重写,把人的改动悄悄覆盖掉。
export function isStaleAgentDraft(draft: AgentDraft): boolean {
  return draft.baseVersion < draft.currentVersion;
}

export function staleSections(
  drafts: readonly AgentDraft[],
): readonly string[] {
  return drafts.filter(isStaleAgentDraft).map((draft) => draft.section);
}

export type SectionMap = Readonly<Record<string, Stamped<string>>>;

export type MergeResult = {
  readonly merged: SectionMap;
  readonly conflicts: readonly string[];
};

export function mergeSections(
  current: SectionMap,
  incoming: SectionMap,
): MergeResult {
  const merged: Record<string, Stamped<string>> = { ...current };
  const conflicts: string[] = [];
  for (const [key, value] of Object.entries(incoming)) {
    const existing = merged[key];
    if (!existing) {
      merged[key] = value;
      continue;
    }
    const result = resolveField(existing, value);
    merged[key] = result.winner;
    if (result.conflict) conflicts.push(key);
  }
  return { merged, conflicts };
}

// B Quill 的协同场景:摘要段被人改过,指标段没人动。
export const QUILL_DRAFTS: readonly AgentDraft[] = [
  { section: "summary", baseVersion: 3, currentVersion: 5 },
  { section: "metrics", baseVersion: 4, currentVersion: 4 },
  { section: "outlook", baseVersion: 2, currentVersion: 4 },
];

export const QUILL_REVIEW = {
  monthlyReports: QUILL.monthlyTasks,
  humanHours: QUILL.humanMinutes / 60,
} as const;

chooseStrategy 的顺序是:字段不重叠就合并;跨作者且需要人工复核就加锁;跨作者但可接受覆盖就后写赢;同作者且不可逆就加锁;其余后写赢。这个顺序把「安全」放在「省事」前面,代价是更多场景会走加锁或合并。

resolveField 处理同字段裁决,优先级是:过期写入让位、人的编辑压过 Agent 草稿、同版本不同值保留当前并标记冲突、其余取新版本。注意「人的编辑压过 Agent」发生在版本比较之后:如果 Agent 的版本更旧,它先因为过期被拒绝,而不是因为作者身份。

isStaleAgentDraft 是隐性冲突的探针。它只比较「Agent 读取的版本」和「当前版本」,不关心内容。只要读取版本落后,就说明这份草稿不能直接提交,必须先做差异比对。这个判断很便宜,但能挡住大部分静默覆盖。

mergeSections 把章节级合并写成循环:没有冲突的键直接写入,有冲突的键走 resolveField,冲突键收集到 conflicts 数组。产品可以直接用这个数组生成人工裁决列表,而不是让用户自己在整份报告里找差异。

冲突设计的检查清单

  1. Agent 的每次写入是否带「读取版本」?没有版本,就无法判断是否过期。
  2. 人改过的字段,Agent 重新生成时会不会跳过?不跳过,人的修改就会被覆盖。
  3. 同一份文档是否按字段分配策略?整份文档一个策略,通常不是太松就是太紧。
  4. 冲突是否有可见的人工裁决入口?只记录不展示,冲突会变成沉默的丢失。
  5. 加锁是否有超时与范围限制?没有超时的锁,迟早会锁住整个团队。

五个问题里,第一和第二个最容易被忽略,因为它们不影响「生成成功」,只影响「修改还在不在」。冲突设计的质量,往往不是看它能不能合并,而是看它能不能让人发现自己被覆盖了。

小结

  • 冲突策略只有三种:后写赢、加锁、合并,各有适用条件与代价。
  • 选择顺序:先看字段是否重叠,再看作者是否相同,再看是否需复核,最后看是否可逆。
  • 后写赢只适合同一作者的可逆字段;跨作者或不可逆字段应加锁或合并。
  • B Quill 的 606 份月报、1.6 小时审改,说明冲突高发在局部修改,而不是整篇重写。
  • Agent 参与的冲突更隐蔽:没有并发提示、整段覆盖、时间差难察觉。
  • Agent 写入必须带版本号,过期写入应拒绝或交给人工裁决,不能静默覆盖。
  • 人的编辑永远优先于 Agent 草稿,因为责任在人,控制权就必须在人。
  • 合并、加锁、后写赢可以共存,关键是按字段类型分配,而不是按整份文档分配。

阅读导航:上一节:9.2 谁能看见谁的操作 · 下一节:10.1 影子模式:只记录不执行 。

常见错误与边界

  1. 整份文档只用后写赢。 后写赢会静默丢失修改,跨作者或不可逆字段不能使用;至少要按字段分配策略。
  2. 把 Agent 当成普通协作者。 Agent 不会出现在光标和锁提示里,必须用版本号显式检测过期写入。
  3. 人改过的段落仍被自动重写。 这是最伤信任的覆盖;重新生成应跳过人工修改,或把人的版本作为新基线。
  4. 冲突只记录不展示。 没有人工裁决入口,冲突就变成沉默的数据丢失,用户甚至不知道发生过。
  5. 加锁没有超时。 锁忘记释放会让整份文档无法编辑;锁的范围也要小,避免一人锁住全部。
  6. 把「合并成功」当成「没有冲突」。 合并只处理字段不重叠的情况;同字段冲突仍需人判断,不能自动抹平。

冲突处理完,协作的基本面就齐了:记忆有归属、操作有可见性、修改有裁决。下一章进入上线阶段,先看影子模式如何在不动生产的情况下拿到反事实证据。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图