《AI Agent 产品开发·交互、信任与上线》8.1 通知预算

通知不是免费的,它花的是用户当天的注意力。本节把通知做成按人按天的预算:按紧急度分档、给出超预算时的具体合并与降级规则、用 C Runner 每天 150 个库存任务的告警说明为什么要合并同类项,并写出一个不静默丢弃任何通知的完整预算函数。

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

通知是 Agent 产品里最容易被当成免费资源的东西。任务跑完了,发一条;发现异常了,发一条;用户三天没回来,再发一条。每一条单独看都有理由,合起来就变成用户手机上的噪音。噪音的后果不是「用户有点烦」,而是用户把整个渠道静音;渠道一旦被静音,真正紧急的通知也送不到。

这一节的主判断是:通知预算按人按天算,超出必须合并或降级。预算不是一个技术限流器,而是一个产品承诺:产品答应用户,今天最多用几次注意力,超出部分会等到下一个合适的窗口,而不是继续响。

通知不是功能,是预算

把通知当成功能,产品会问「这个事件要不要通知」;把通知当成预算,产品会问「这个事件值不值得花掉用户今天的一次注意力」。前一个问题没有上限,后一个问题有。

视角问题结果
功能视角这个事件重要吗重要就发,越加越多
预算视角这个事件值得花一次配额吗有配额就发,没配额就合并或降级

A Relay 没有这个问题,因为它的通知渠道是「无」:工单在侧栏里同步给出建议,人当场确认,不需要把用户从别处叫回来。B Quill 每份报告只通知 1 次,因为用户本来就在报告编辑器里,通知只是「初稿好了」的提示。C Runner 每批次通知 1 次,异常另计,因为批次是运营人员的工作单位。

这三个案例的渠道和预算都不是随手定的,它们和交互形态绑定:A 嵌入同步,所以不需要通知;B 嵌入异步,所以只需要应用内一次;C 后台批次,所以需要应用内加邮件,并且必须按批次合并。通知预算的第一个约束不是「用户能接受几条」,而是「这个产品本来就在用户眼前吗」。

为什么按人按天算

按任务算预算,会得到一个荒谬的结论:任务越多,通知越多。C Runner 月任务量 13,200 个,日任务量 600 个,如果每个异常都通知,运营人员一天会收到几十条消息;这些消息里的绝大多数可以在批次结束时合并成一条。

按人按天算,预算才有意义。它约束的是「一个人今天被打断几次」,而不是「一个系统今天发了多少条」。同一条通知发给 24 个人,消耗的是 24 份注意力,不是 1 份;反过来,一条合并后的批次摘要发给 1 个值班人,只消耗 1 份。

计算口径分子分母结果
按任务通知数任务数任务越多,通知越多,没有上限
按渠道通知数渠道数多渠道等于多预算,鼓励加渠道
按人按天通知数人 × 天每个人每天有固定配额,超出必须处理

按人按天算还有一个好处:它逼产品回答「这条通知该发给谁」。共享收件箱看起来省事,实际上是把预算转嫁给一个没有人负责的池子;池子里的通知要么被所有人忽略,要么被某个人重复处理。预算必须落到具体的人或具体的值班角色上。

按紧急度分档的预算表

预算不能只有一个总数,因为不同紧急度的通知价值不同。一条「价格倒挂」和一条「周报摘要」都花一次注意力,但前者值得打断,后者不值得。下面是一张初始预算表,数值是产品设计值,不是案例事实;上线后应按团队反馈调整。

档位典型事件每日上限默认渠道超出处理
紧急资金损失、客户数据错误、不可回滚动作3应用内 + 邮件同主题合并,不同主题仍发
高SLA 将超时、审批待处理、批次失败3应用内降级为摘要
普通单条异常、低置信度建议2应用内合并为摘要
低周报、趋势、回顾0邮件摘要只进摘要,不单独发

这张表里最值得注意的是「低」的上限是 0。这不是说低优先级信息不重要,而是说它不应该以「通知」的形式出现;它应该进摘要,等用户主动看。很多产品把「低」也做成推送,理由是「万一用户想看呢」,结果是低优先级信息把高优先级信息的配额吃掉了。

「紧急」的上限是 3,但超过 3 条也不是直接丢弃。同主题的紧急通知可以合并,比如同一个商品的 5 条库存告警合并成 1 条;不同主题的紧急通知仍然要发,因为漏掉一条可能造成资金损失。预算对紧急档是「软上限」,对其他档是「硬上限」。

超预算怎么办:合并、降级、推迟

超预算的处理只有三种合法动作:合并、降级、推迟。第四种动作「静默丢弃」不合法,因为它让用户以为没有发生,而实际上发生了。

动作做法适用用户看到什么
合并同一主题或同一批次的多条通知合成一条紧急、高、普通「本批 9 个异常,其中 3 个价格、6 个库存」
降级从即时渠道降到摘要渠道高、普通「已放入今日摘要」
推迟移到下一个通知窗口普通、低「明早 9 点汇总」
静默丢弃不发也不记录不合法什么都不看到,事故后才发现

合并的关键是「同主题」而不是「同时间」。同一个商品的 5 条库存告警,合并成 1 条「该商品库存连续 5 次低于阈值」,用户能看懂;把 5 个不同商品的告警合并成「5 个商品有异常」,用户还得逐条点开,合并没有降低负担。

降级的关键是「用户还能找到」。从应用内降到邮件摘要,用户至少能在摘要里看到;从邮件降到「不通知」,用户就找不到了。降级可以降低打扰,但不能降低可发现性。

推迟的关键是「有明确的下一窗口」。说「稍后通知」等于没说;说「明早 9 点汇总」才是承诺。C Runner 的批次可能在夜间结束,夜间不适合发即时通知,但第二天早上的批次摘要必须准时到。

C Runner 的库存告警

C Runner 每天 600 个任务,其中库存跟进占 25%,也就是 150 个/天。假设这 150 个任务里有 9 个异常:3 个价格倒挂、6 个库存低于安全线。如果每个异常发一条通知,值班人员一天会收到 9 条;如果每个任务都发一条,会收到 150 条。

一个合理的通知方案是:

  • 批次开始时发 1 条「本批 150 个库存任务已开始」,这是批次回执,不是异常通知。
  • 批次结束时发 1 条「本批完成:137 个正常、9 个异常、4 个转人工」。
  • 9 个异常里,3 个价格倒挂属于紧急档,合并成 1 条「3 个商品价格倒挂」;6 个库存低于安全线属于普通档,合并进摘要。
  • 如果同一个商品连续出现 5 次库存告警,再合并成 1 条「该商品库存持续低于阈值」。

这样,值班人员一天收到的库存相关通知不超过 4 条,而不是 150 条。信息没有丢:异常数量、异常类型、具体商品都在摘要里;需要立刻处理的价格倒挂仍然单独成条。

C 的审计抽检比例是 8%,单次复核 12 分钟,折合每个任务 0.96 分钟;转人工比例 22%,平均 14 分钟。这些数字说明,C 的异常不是罕见事件,而是日常运营的一部分。通知预算不能假设「异常很少」,它必须假设「异常每天都有」,然后设计一个能把日常异常压缩成可读摘要的结构。

预算的漏洞:共享收件箱和无限重试

通知预算最常见的两个漏洞,不是配额设得太大,而是配额被绕过。

共享收件箱。 通知发到 ops@ 或一个群,看起来只花了一份预算,实际上每个人都收到了,消耗的是 N 份注意力。更糟的是,没有人觉得自己是收件人,通知被集体忽略。预算必须绑定到具体的人或具体的值班角色,而不是一个没有主人的池子。

无限重试。 任务失败后自动重试,每次重试都发一条「正在重试」。用户收到 5 条重试通知,最后收到 1 条失败通知;前 5 条没有提供新信息,却花掉了 5 次配额。重试应该合并成一条「已重试 5 次,仍失败」,或者干脆不通知,直到最终状态。

这两个漏洞的共同点是:它们都把「通知数量」和「信息增量」分开了。预算应该按信息增量花,而不是按事件数量花。一条「仍在重试」如果没有新信息,就不值得花一次配额。

把预算写成函数

下面这个模型把通知预算做成可运行的函数。它按紧急度排序,先花配额,超出的高优先级降级、普通合并、低优先级只进摘要;紧急通知不丢弃,同主题重复的合并。

// file: src/trust/08-1-notification-budget.ts
// tier: L2
// verify: node --test test/trust/08-1-notification-budget.test.ts

// 通知预算是按人按天算的注意力配额。
// 超预算不是「多响一次」,而是必须合并、降级或推迟。

import { DAYS_PER_MONTH, RUNNER } from "../cases.ts";

export type Urgency = "critical" | "high" | "normal" | "low";

export const URGENCY_ORDER: readonly Urgency[] = [
  "critical",
  "high",
  "normal",
  "low",
];

export type Notice = {
  readonly id: string;
  readonly urgency: Urgency;
  readonly subject: string;
  readonly atMinute: number;
};

export type Budget = Readonly<Record<Urgency, number>>;

export type MergeGroup = {
  readonly urgency: Urgency;
  readonly notices: readonly Notice[];
};

export type Plan = {
  readonly sent: readonly Notice[];
  readonly merged: readonly MergeGroup[];
  readonly downgraded: readonly Notice[];
  readonly dropped: readonly Notice[];
  readonly used: Readonly<Record<Urgency, number>>;
};

// 默认配额是产品初始值,不是案例事实;上线后按团队反馈调整。
export const DEFAULT_BUDGET: Budget = {
  critical: 3,
  high: 3,
  normal: 2,
  low: 0,
};

function emptyBuckets(): Record<Urgency, Notice[]> {
  return { critical: [], high: [], normal: [], low: [] };
}

export function spendBudget(
  notices: readonly Notice[],
  budget: Budget,
): Plan {
  const sorted = [...notices].sort(
    (a, b) =>
      URGENCY_ORDER.indexOf(a.urgency) - URGENCY_ORDER.indexOf(b.urgency) ||
      a.atMinute - b.atMinute,
  );
  const used: Record<Urgency, number> = {
    critical: 0,
    high: 0,
    normal: 0,
    low: 0,
  };
  const sent: Notice[] = [];
  const downgraded: Notice[] = [];
  const buckets = emptyBuckets();
  const criticalSubjects = new Set<string>();

  for (const notice of sorted) {
    if (notice.urgency === "low") {
      buckets.low.push(notice);
      continue;
    }
    if (notice.urgency === "critical") {
      // 严重告警不降级、不丢弃;同一主题的重复告警合并。
      if (criticalSubjects.has(notice.subject)) {
        buckets.critical.push(notice);
        continue;
      }
      criticalSubjects.add(notice.subject);
      used.critical += 1;
      sent.push(notice);
      continue;
    }
    if (used[notice.urgency] < budget[notice.urgency]) {
      used[notice.urgency] += 1;
      sent.push(notice);
      continue;
    }
    downgraded.push(notice);
    buckets[notice.urgency].push(notice);
  }

  const merged: MergeGroup[] = URGENCY_ORDER.filter(
    (urgency) => buckets[urgency].length > 0,
  ).map((urgency) => ({ urgency, notices: buckets[urgency] }));

  return {
    sent,
    merged,
    downgraded,
    dropped: [],
    used,
  };
}

export function mergedCount(plan: Plan): number {
  return plan.merged.reduce((total, group) => total + group.notices.length, 0);
}

export function budgetExceeded(plan: Plan, budget: Budget): readonly Urgency[] {
  return URGENCY_ORDER.filter(
    (urgency) =>
      urgency !== "critical" &&
      plan.used[urgency] >= budget[urgency] &&
      plan.downgraded.some((notice) => notice.urgency === urgency),
  );
}

// C Runner 每天 600 个任务,其中 25% 是库存跟进;150 个/天。
export const INVENTORY_SHARE = 0.25;

export function dailyInventoryTasks(): number {
  return Math.round((RUNNER.monthlyTasks / DAYS_PER_MONTH) * INVENTORY_SHARE);
}

spendBudget 返回四组结果:直接发送的、合并的、降级的、丢弃的。dropped 永远是空数组,这不是实现偷懒,而是产品约束:预算可以合并、可以降级、可以推迟,但不能静默丢弃。budgetExceeded 用来告诉产品哪些档位已经超了,方便在运营看板上显示「今天的普通通知已合并 4 条」。

把 C 的库存场景代进去:150 个任务、9 个异常,普通档预算是 2,超出的 4 条普通异常会进入合并组,紧急的 3 条价格倒挂仍然单独发送。用户看到的是「3 条紧急 + 1 条普通摘要」,而不是 9 条平铺的通知。

预算耗尽的降级阶梯

预算耗尽不是终点,而是一个降级阶梯的起点。阶梯的顺序必须是固定的,不能由每个模块自己决定。

阶梯状态动作用户感知
1预算充足即时通知立刻收到
2高优先级超限合并同主题收到一条汇总
3普通超限降级为摘要在摘要里看到
4低优先级只进摘要主动查看时看到
5摘要也超限推迟到下一窗口明早汇总

阶梯的顺序不能乱:不能因为普通通知超限,就把紧急通知也降级;也不能因为摘要超限,就把紧急通知丢掉。紧急档永远在阶梯之外,它只有「合并同主题」和「单独发送」两种状态。

小结

  • 通知不是免费功能,它花的是用户当天的注意力;预算按人按天算,不按任务算。
  • 按紧急度分档:紧急、高、普通、低,每档有独立上限和默认渠道。
  • 超预算只有合并、降级、推迟三种合法动作,静默丢弃不合法。
  • 合并要按同主题,不按同时间;降级要保留可发现性;推迟要给明确的下一窗口。
  • C Runner 每天 150 个库存任务,9 个异常应压缩成 3 条左右通知,而不是 150 条。
  • 共享收件箱和无限重试是预算的两个漏洞,前者把一份预算花成 N 份,后者用重复信息吃掉配额。
  • 预算耗尽时按固定阶梯降级,紧急档永远不被降级或丢弃。

阅读导航:上一节:7.3 中断与恢复的用户视角 · 下一节:8.2 渠道选择 。

常见错误与边界

  1. 按任务数发通知。 600 个日任务就发 600 条,用户第一天就会把渠道静音。
  2. 把低优先级也做成推送。 「低」的预算是 0,它应该进摘要;给它推送等于让它挤占紧急通知的注意力。
  3. 超预算时静默丢弃。 用户以为没发生,事故后才发现;丢弃必须改成合并、降级或推迟。
  4. 把不同主题硬合并。 「5 个商品有异常」不比 5 条通知省事,用户还是要逐条点开。
  5. 用共享收件箱规避预算。 一份预算发给 N 个人,实际消耗 N 份注意力,而且没有人负责。
  6. 重试时重复通知。 每次重试都发一条「正在重试」,用没有信息增量的消息吃掉配额。

这一节解决「发多少」。下一节解决「从哪里发」:站内、邮件、IM、短信,各自的打扰成本和适用场景完全不同。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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