《AI Agent 产品开发·任务定义与能力边界》4.3 过期数据与冲突数据的处理口径

过期数据和冲突数据不能靠模型临场判断。本节给出 source、fetchedAt、validUntil、authority 四个时效标注字段,区分新鲜、过期、未知三种状态,说明择新、择权威、悬置三种冲突处理,并用 C Runner 的价格数据演示为什么悬置比猜一个数更安全。

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

上下文预算解决的是「装不下」,时效与冲突解决的是「装得下但不能直接用」。一个 Agent 可能在预算内看到两条互相矛盾的价格,也可能看到一条格式完整、来源清楚、但已经过期的库存。这时它最危险的行为不是报错,而是挑一个看起来合理的数字继续往下走。

模型没有能力判断「这条数据是不是今天的」,除非产品把时间写进数据里。模型也没有能力判断「两个系统谁更权威」,除非产品把权威级别写进数据里。本节要做的,就是把这两个判断从模型的临场推理,变成输入契约的一部分。

时效不是一个布尔值

很多系统只给数据打一个 updated_at,然后默认「最近更新过就是新的」。这个默认在两种情况下会失效:一是数据更新了但没有生效,比如价格改了发布时间还没到;二是数据很久没更新,但系统仍然返回它,看起来像一条正常记录。前一种需要「生效时间」,后一种需要「有效期」。

所以时效标注至少要有四个字段,而不是一个时间戳。

字段回答的问题缺失时的后果
source这条数据来自哪个系统或哪次人工录入冲突时无法判断谁是权威
fetchedAt这次读取发生在什么时候无法区分「数据旧」和「读得晚」
validUntil这条数据在什么时间之前仍然有效过期数据会被当成当前事实
authority同一指标上,这个来源的优先级冲突时只能按先后顺序猜

source 和 fetchedAt 解决「来路」,validUntil 解决「还能不能用」,authority 解决「两个都能用时听谁的」。四个字段缺一个,冲突处理就会退化成某条硬编码规则。

时效标注不是给工程看的元数据,它应该出现在用户能看到的地方。至少在产品界面或输出里,用户要能回答:这个数字是什么时候的、从哪个系统来的、现在还能不能用。对客报告尤其如此,一份报告里的数字如果没有时间口径,客户无法判断它是本月实际、上月回顾还是年度累计。

三种状态:新鲜、过期、未知

有了四个字段,一条读数在某个决策时刻只有三种状态。

新鲜:fetchedAt 不晚于决策时刻,validUntil 不早于决策时刻,时间字段都能解析。只有新鲜数据可以进入自动决策。

过期:时间字段能解析,但决策时刻已经超过 validUntil。过期数据不是「稍微旧一点也能用」,它已经越过了产品承诺的有效窗口。对价格、库存、额度这类会变化的指标,过期就意味着不能作为当前值使用。

未知:时间字段缺失、格式错误,或者 fetchedAt 晚于决策时刻。未知不等于过期,也不等于新鲜;它表示这条数据的时间口径本身不可信。对未知数据,正确动作是补全或跳过,而不是按「大概是新的」处理。

三种状态的判定顺序应该是:先判未知,再判过期,最后才是新鲜。因为一条格式错误的数据如果先被当成新鲜,后面的判断都会建立在错误前提上。这个顺序看起来是工程细节,实际上决定了产品在异常数据面前是停手还是继续。

冲突时的三种处理:择新、择权威、悬置

两条或多条新鲜读数给出不同值时,产品必须选一种处理口径。常见的有三种,每一种都对应不同的适用场景。

处理规则适用场景风险
择新取 fetchedAt 最新的一条数据变化快、来源之间没有明确上下级最新的不一定最权威,可能是一次错误写入
择权威取 authority 最高的一条有明确主数据源,其他来源是副本或缓存权威源本身可能延迟或故障
悬置不选,交给人工或等待刷新冲突会影响资金、客户承诺或不可回滚动作增加人工负担,降低自动完成率

三种处理没有绝对优劣,但必须有明确的产品选择。最糟糕的做法是「让模型自己判断」:模型没有权威级别的概念,也没有组织授权,它只会根据文本里哪个数字更显眼来选。

择新适合什么?适合那些「越新越接近事实」的指标,比如页面浏览量、临时库存快照。它的前提是来源之间没有主从关系,且写入错误能被及时发现。如果最新数据可能来自一次错误写入,择新就会把错误放大。

择权威适合什么?适合有主数据源的场景,比如商品价格以定价系统为准,促销价以促销系统为准。它的前提是权威级别由组织明确授予,而不是由产品经理在代码里随手排一个顺序。权威源也会有延迟,所以择权威通常要和时效判断一起用:权威源的数据过期时,不能因为「它最权威」就继续用。

悬置适合什么?适合冲突会影响资金、客户承诺或不可回滚动作的场景。C Runner 的价格调整就属于这一类:改错价格可能直接产生资金损失,而价格错误中有一部分不可回滚。对这类动作,宁可停下来让人确认,也不要在两个价格之间猜一个。

C Runner 的价格冲突

C Runner(Kettle 的电商运营任务执行 Agent)每月处理 13,200 个任务,人工基线是 18 分钟一个。它的任务包括上下架检查、价格异常和库存跟进,其中价格异常会直接触发改价动作。假设在某个决策时刻,它看到两条关于同一个商品的价格读数:

来源价格读取时间有效期至权威级别
商品目录39.909:20次日 09:002
促销系统35.909:10次日 00:003

两条读数在 09:30 都是新鲜的。如果按「择新」,商品目录更晚,Agent 会选 39.9;如果按「择权威」,促销系统的级别更高,Agent 会选 35.9。同一组数据,两种口径给出两个结果,差 4.0。这不是模型算错了,而是产品没有提前决定听谁的。

对 C 来说,正确口径应该是「择权威」:促销系统是促销价的发布源,商品目录可能只是同步了基础价。但「择权威」不能单独使用,还要加一条:如果权威源的数据已经过期,就不能继续按权威处理,而应该悬置。假设商品目录仍然是 09:20 读取,但促销系统的 validUntil 是 09:00,那么 09:30 时促销数据已经过期,此时只剩商品目录一条新鲜读数,Agent 可以用它,但要在审计日志里记录「促销价已过期,本次按目录价判断」。

如果两条读数都过期,正确动作是悬置,不是挑一条「看起来更合理」的。C 的审计抽检比例是 8%,单次复核 12 分钟,折合每个任务 0.96 分钟;它的错误率是 1.7%,其中 86% 可回滚,不可回滚错误率是 0.238%。这些数字说明一件事:C 的大部分错误可以挽回,但有一小部分不能。价格冲突如果落在那 0.238% 里,省下来的自动完成时间会被一次事故抵消。

悬置不是失败,是产品动作

很多团队把「悬置」当成系统故障:Agent 没算出来,所以转人工。这个理解会让你错过悬置真正的产品价值。悬置是一个明确的输出:它告诉用户「现在不能安全地决定,原因是什么,下一步该做什么」。

一个合格的悬置至少要包含三部分:

  1. 冲突的事实。 哪些来源、什么值、各自的时间与权威级别。用户不需要看原始 JSON,但需要看到关键差异。
  2. 悬置的原因。 是全部过期、权威级别打平,还是策略要求不自动选。原因不同,处理动作不同。
  3. 下一步。 是刷新数据、人工指定,还是走审批。不能只显示「处理失败」。

C 的转人工比例是 22%,转人工平均耗时 14 分钟,折合每个任务 3.08 分钟。这个成本必须计入 C 的人工账:0.96 分钟审计加 3.08 分钟转人工,实际人工是 4.04 分钟,月人工 888.8 小时,月人工成本 26,664 美元。如果只算审计不算转人工,C 的月总成本会被低估,节省率会被高估。悬置不是免费的,它的成本就藏在转人工里。

反过来,悬置也不能滥用。如果每两条读数不一致就转人工,C 的自动完成率会从 78% 掉下去,人工成本会迅速吞掉节省。产品要区分「影响资金或不可回滚动作的冲突」和「只影响展示顺序的冲突」:前者悬置,后者可以按权威或按新择一,并记录选择。

把时效与冲突写成模型

下面这个模型把四个标注字段、三种时效状态和三种冲突策略做成可运行的判定。它不替产品决定用哪种策略,而是把每种策略的结果显式返回,方便在评审时对照。

// file: src/task/04-3-stale-conflict.ts
// tier: L2
// verify: node --test test/task/04-3-stale-conflict.test.ts

// 数据时效与冲突:先标注,再决策,无法决策就悬置。
// 宁可说不知道,不可用旧数据或来路不明的数据假装知道。

export const STAMP_FIELDS = [
  "source",
  "fetchedAt",
  "validUntil",
  "authority",
] as const;

export type SourceStamp = {
  readonly source: string;
  readonly fetchedAt: string;
  readonly validUntil: string;
  readonly authority: number;
};

export type Reading = {
  readonly metric: string;
  readonly value: number;
  readonly stamp: SourceStamp;
};

export type Freshness = "fresh" | "stale" | "unknown";

export function annotate(reading: Reading, asOf: string): Freshness {
  const fetched = Date.parse(reading.stamp.fetchedAt);
  const valid = Date.parse(reading.stamp.validUntil);
  const now = Date.parse(asOf);
  if (Number.isNaN(fetched) || Number.isNaN(valid) || Number.isNaN(now)) {
    return "unknown";
  }
  if (now < fetched) return "unknown";
  return now <= valid ? "fresh" : "stale";
}

export type ConflictPolicy = "newest" | "authority" | "suspend";

export type Resolution =
  | {
      readonly decision: "use";
      readonly value: number;
      readonly source: string;
      readonly rule: "single" | "newest" | "authority";
    }
  | {
      readonly decision: "suspend";
      readonly reason: "all-stale" | "conflict" | "tie";
    };

export function resolve(
  readings: readonly Reading[],
  asOf: string,
  policy: ConflictPolicy = "authority",
): Resolution {
  const fresh = readings.filter((item) => annotate(item, asOf) === "fresh");
  if (fresh.length === 0) return { decision: "suspend", reason: "all-stale" };
  if (fresh.length === 1) {
    return {
      decision: "use",
      value: fresh[0].value,
      source: fresh[0].stamp.source,
      rule: "single",
    };
  }
  if (policy === "suspend") return { decision: "suspend", reason: "conflict" };

  if (policy === "authority") {
    const top = Math.max(...fresh.map((item) => item.stamp.authority));
    const winners = fresh.filter((item) => item.stamp.authority === top);
    if (winners.length !== 1) return { decision: "suspend", reason: "tie" };
    return {
      decision: "use",
      value: winners[0].value,
      source: winners[0].stamp.source,
      rule: "authority",
    };
  }

  const newest = fresh.reduce((a, b) =>
    Date.parse(b.stamp.fetchedAt) > Date.parse(a.stamp.fetchedAt) ? b : a,
  );
  const tied = fresh.filter(
    (item) => Date.parse(item.stamp.fetchedAt) === Date.parse(newest.stamp.fetchedAt),
  );
  if (tied.length !== 1) return { decision: "suspend", reason: "tie" };
  return {
    decision: "use",
    value: newest.value,
    source: newest.stamp.source,
    rule: "newest",
  };
}

export const AS_OF = "2026-11-04T09:30:00+08:00";

// C Runner 的价格冲突:目录价抓得更晚,但促销系统权限更高。
export const RUNNER_PRICES: readonly Reading[] = [
  {
    metric: "sku-1042",
    value: 39.9,
    stamp: {
      source: "catalog",
      fetchedAt: "2026-11-04T09:20:00+08:00",
      validUntil: "2026-11-05T09:00:00+08:00",
      authority: 2,
    },
  },
  {
    metric: "sku-1042",
    value: 35.9,
    stamp: {
      source: "promotion",
      fetchedAt: "2026-11-04T09:10:00+08:00",
      validUntil: "2026-11-06T00:00:00+08:00",
      authority: 3,
    },
  },
];

// 目录数据在决策时刻已经过期:只剩促销价一条新鲜读数。
export const RUNNER_PRICES_STALE_CATALOG: readonly Reading[] = [
  {
    metric: "sku-1042",
    value: 39.9,
    stamp: {
      source: "catalog",
      fetchedAt: "2026-11-04T08:50:00+08:00",
      validUntil: "2026-11-04T09:15:00+08:00",
      authority: 2,
    },
  },
  RUNNER_PRICES[1],
];

export function suspendMessage(resolution: Resolution): string | null {
  if (resolution.decision !== "suspend") return null;
  switch (resolution.reason) {
    case "all-stale":
      return "No fresh reading; ask the owner to refresh the source before acting.";
    case "conflict":
      return "Fresh readings disagree and the policy says not to pick one.";
    case "tie":
      return "Fresh readings tie on the deciding rule; escalate instead of guessing.";
  }
}

annotate 先判未知、再判过期、最后判新鲜。resolve 先过滤掉非新鲜读数:一条都不剩就悬置,只剩一条就直接用,剩下多条才进入策略分支。authority 策略在最高权威出现并列时悬置,newest 策略在最新时间出现并列时也悬置;这两种并列都不是「随便选一个」的理由。

RUNNER_PRICES 故意让「择新」和「择权威」给出不同结果:商品目录读得更晚,但促销系统的权威级别更高。RUNNER_PRICES_STALE_CATALOG 则让商品目录过期,只剩促销价一条新鲜读数,用来演示「权威源过期后不能继续按权威处理」。这两个样例可以直接放进评审材料,让业务方看到口径差异,而不是只看一段抽象规则。

STAMP_FIELDS 是标注规范的最小集合。任何一条进入决策的数据,都应该能填满这四个字段;填不满的,按未知处理,不进入自动决策。

小结

  • 时效不是一个时间戳,而是 source、fetchedAt、validUntil、authority 四个字段共同构成的标注。
  • 一条读数只有三种状态:新鲜、过期、未知;判定顺序是先未知、再过期、最后新鲜。
  • 冲突处理有三种口径:择新、择权威、悬置;选哪种是产品决策,不能留给模型临场判断。
  • 择新适合没有主从关系、越新越接近事实的指标;它会把最新的一次错误写入放大。
  • 择权威适合有明确主数据源的场景;权威源过期时不能因为「它最权威」继续用。
  • 悬置适合影响资金、客户承诺或不可回滚动作的冲突;它是一种明确输出,不是系统故障。
  • C Runner 的价格冲突说明:同一组数据,择新与择权威可以给出不同结果,差 4.0;产品必须提前定口径。
  • 悬置的成本藏在转人工里:C 的 22% 转人工、14 分钟一次,折合 3.08 分钟,必须计入 4.04 分钟的人工账。

阅读导航:上一节:4.2 上下文预算的产品决策 · 下一节:5.1 答案、草稿、动作:三种输出形态 。

常见错误与边界

  1. 只存 updated_at,不存 validUntil。 更新时间不等于有效期;价格、库存、额度这类指标必须明确「到什么时候为止还能用」。
  2. 把未知数据当成新鲜数据。 时间字段缺失或格式错误时,正确动作是补全或跳过,不是按「大概是新的」继续。
  3. 让模型自己解决冲突。 模型没有权威级别和组织授权的概念,它只会根据文本显眼程度选一个数。
  4. 权威源过期后仍按权威处理。 权威级别解决「听谁的」,时效解决「还能不能用」;两者必须同时满足。
  5. 把悬置当成失败。 悬置要说明冲突事实、原因和下一步;只显示「处理失败」会让用户不知道该怎么办。
  6. 只算审计不算转人工。 C 的 0.96 分钟审计只是人工的一部分,3.08 分钟转人工同样要计入,否则节省率会被高估。

这一节回答「数据过期或冲突时怎么办」。第 5 章换一个方向:Agent 最终应该交回什么,答案、草稿还是动作。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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