《AI Agent 产品开发·交互、信任与上线》7.1 异步任务的承诺与回执

长任务一旦超过一次对话,用户就需要一份可核对的承诺:什么时候收到回执、预计多久、失败怎么通知。本节给出异步契约的六个字段、预计时长被推翻时的通知规则,并用 B Quill 的 11 分钟报告生成说明「承诺初稿可审」与「承诺报告完成」的差别。

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

同步任务和异步任务卖的不是同一种东西。同步任务卖的是答案:用户点一下,几秒后看到结果,答案本身就是回执。异步任务卖的是承诺:用户点一下,先收到一句「我接下了」,然后在几分钟、几小时甚至第二天才看到结果。承诺一旦给出,产品就必须对「什么时候有结果」「结果长什么样」「没结果怎么办」负责。

很多产品把异步做成了「转圈」:按钮变成加载状态,页面停留,用户不知道还要等多久,也不敢关掉。这不是异步交付,只是把同步任务拉长了。真正的异步契约要有回执、有预计时长、有失败通知,而且这三件事都要能被用户核对,而不是只在系统日志里存在。

同步的回执是答案,异步的回执是一份契约

先看 A Relay。它做客服工单分诊,模型加系统耗时 0.30 分钟,人确认 0.75 分钟,合计 1.05 分钟。这个任务在用户的感知里是同步的:工单页侧栏给出队列、优先级和模板编号,人当场确认或修改。它不需要「任务已受理」的回执,因为答案就在几秒内出现。

B Quill 和 C Runner 不一样。B 的初稿生成是 11 分钟,人审改还要 1.6 小时;C 是小时级批次,月任务量 13,200 个,日任务量 600 个。用户不可能盯着屏幕等 11 分钟,更不可能盯一个批次。这时候,产品必须先给一张「回执」,把不确定的等待变成可核对的状态。

形态用户点下按钮后先看到什么回执的作用
同步几秒内看到答案答案就是回执,不需要额外说明
异步「已受理,预计 X 分钟」证明任务没有丢,给出下一次检查的时间
批次「已加入本批,预计本批结束后汇总」证明任务在队列里,给出批次边界
后台「已开始,可关闭页面」证明离开页面不会取消任务

这张表的关键不是文案,而是回执出现的时间。如果用户点下按钮后要先看 10 秒骨架屏,再看到「已受理」,那 10 秒里他仍然不知道发生了什么。回执应该在动作被系统接住的那一刻出现,而不是在模型开始生成之后出现。

回执必须写清的六件事

一张合格的异步回执,至少包含六个字段。少一个,用户就会在某个时刻回来问「它到底做没做」。

字段回答的问题B Quill 的例子
任务号我以后怎么找到它quill-2026-11-001
受理时间它是从什么时候开始算的点击后立即记录
预计时长我大概要等多久11 分钟生成初稿
首个检查点我什么时候能第一次确认它还在动第 4 分钟
失败通知如果失败,我从哪里知道应用内通知
交付物我最后拿到的是什么12–20 页报告初稿,可进入审改

注意最后一行:交付物写的是「初稿,可进入审改」,不是「报告已完成」。这是异步契约里最容易被含糊过去的地方。B 的生成只占 11 分钟,人审改要 1.6 小时;如果产品承诺「报告完成」,用户会把 1.6 小时的审改也算进等待,然后在第 20 分钟开始投诉。承诺必须停在自己能控制的那条边界上。

C Runner 的交付物也不是「任务完成」,而是「本批动作执行完毕,审计记录可查」。它的月任务量 13,200 个,自动完成率 78%,其余 22% 会转人工,转人工平均 14 分钟。也就是说,一个批次里只要出现转人工,整批的完成时间就不再是「剩余任务数 × 2.4 分钟」。回执如果只写「预计 30 分钟」,它在第一个转人工出现时就失效了。

预计时长是一个可以被推翻的承诺

「预计 20 分钟」不是一句安慰话,它是一个可以被验证、也必须被更新的承诺。用户真正需要的不是准确的 20 分钟,而是「如果 20 分钟不够,你会主动告诉我」。

假设一个任务承诺 20 分钟,运行到第 8 分钟时完成了 40%。按当前速度外推,总耗时是 8 ÷ 0.4 = 20 分钟,仍在承诺内,不需要打扰用户。如果第 8 分钟只完成了 30%,外推就是 26.67 分钟,超出承诺 6.67 分钟,产品必须主动发出改期通知,而不是让用户在 20 分钟时自己发现没有结果。

这个外推不需要复杂的预测模型,只需要两个数:已经运行了多少分钟,完成了多少比例。难点不在算法,而在产品是否愿意把「可能迟到」提前说出来。很多团队担心提前通知会显得不靠谱,于是选择沉默,结果用户在承诺时间点发现被放鸽子,信任损失更大。

状态判定产品动作
无信号还没有完成比例不给新 ETA,只确认任务在运行
正常外推 ≤ 承诺不打扰,按首个检查点报一次平安
有风险承诺 < 外推 ≤ 承诺 × 1.1主动通知,给出新的预计时间
已违约外推 > 承诺 × 1.1主动通知,说明原因和下一个检查点
已完成完成比例 = 100%交付结果,停止所有等待提示

「有风险」和「已违约」都要通知,区别在措辞:前者说「可能晚几分钟」,后者说「已经晚了,新的预计时间是」。两者都不能隐瞒。把 10% 作为缓冲带,是因为外推本身有误差;超过 10% 还沉默,就不是误差,而是失约。

失败通知不是「出错了」,而是「什么还在、下一步做什么」

异步任务最常见的失败不是模型报错,而是中间某一步卡住:数据包缺一页、图表渲染超时、某个工具返回 500。用户不需要看堆栈,他需要知道三件事:

  1. 哪一步失败了。 「图表渲染失败」比「任务失败」有用得多。
  2. 什么被保留了。 已经生成的 8 页正文还在,不需要重做。
  3. 下一步做什么。 是自动重试、需要用户补材料,还是转人工。

失败通知和延迟通知必须分开。延迟是「还在跑,只是比承诺慢」,失败是「这次跑不下去了」。把失败写成「预计时间延长」,用户会继续等一个永远不会来的结果;把延迟写成「失败」,用户会重复提交,制造重复任务。C Runner 的重复提交尤其危险:一个重复的价格修改动作可能把价格改两次。

回执里必须提前写清失败通知走哪个渠道。B 用应用内通知,因为用户本来就在报告编辑器里;C 用应用内加邮件,因为批次可能在非工作时间结束。渠道不是装饰,它决定失败发生后用户多久能知道。关于渠道的取舍,8.2 会展开。

B Quill 的报告生成怎么承诺

B Quill 是一个适合讲异步契约的案例,因为它的时间结构很清晰:11 分钟生成,1.6 小时人审改,月报告量 606 份。产品可以给出这样一份回执:

  • 任务号:本次报告的唯一编号。
  • 预计时长:11 分钟生成初稿。
  • 首个检查点:第 4 分钟,应用内提示「已生成 5 页,仍在处理」。
  • 失败通知:应用内,说明失败步骤和已保留的章节。
  • 交付物:12–20 页初稿,进入审改,不包含审改本身。

这份回执没有承诺「报告完成」,因为审改是人的工作,产品控制不了。它也没有承诺「一次通过」,因为 B 的一次采纳率是 63%,小改率 28%,返工率 9%。用户拿到初稿后本来就要改,回执如果把「初稿」说成「成品」,后面的审改就会被当成产品缺陷。

第 4 分钟的检查点也不是随便选的。B 的生成总时长是 11 分钟,4 分钟大约在三分之一处;如果这时候连提纲都没出来,产品就有理由提前判断「可能迟到」,而不是等到第 11 分钟才说。检查点的作用不是刷存在感,而是给「提前发现迟到」一个固定窗口。

把契约写成可校验的函数

下面这个模型把回执、预计时长和失败通知做成可运行的函数。回执校验负责挡住缺字段的承诺;projectEta 负责在进度偏离时给出状态和通知文案;buildFailureNotice 负责把失败拆成「哪一步、什么还在、下一步做什么」。

// file: src/trust/07-1-async-contract.ts
// tier: L2
// verify: node --test test/trust/07-1-async-contract.test.ts

// 异步任务的承诺由三件事组成:回执、预计时长、失败通知。
// 预计时长不是装饰,它必须在进度偏离时被推翻并主动通知。

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

export type NoticeChannel = "in-app" | "email" | "im";

export const NOTICE_CHANNELS: readonly NoticeChannel[] = [
  "in-app",
  "email",
  "im",
];

export type Receipt = {
  readonly taskId: string;
  readonly estimateMinutes: number;
  readonly firstCheckpointMinutes: number;
  readonly failureChannel: NoticeChannel;
  readonly whatArrives: string;
};

export function validateReceipt(receipt: Receipt): readonly string[] {
  const issues: string[] = [];
  if (receipt.taskId.trim() === "") {
    issues.push("缺任务号");
  }
  if (!(receipt.estimateMinutes > 0)) {
    issues.push("预计时长必须大于 0");
  }
  if (!(receipt.firstCheckpointMinutes > 0)) {
    issues.push("首个检查点必须大于 0");
  }
  if (receipt.firstCheckpointMinutes >= receipt.estimateMinutes) {
    issues.push("首个检查点必须早于预计完成时间");
  }
  if (receipt.whatArrives.trim() === "") {
    issues.push("缺交付物说明");
  }
  if (!NOTICE_CHANNELS.includes(receipt.failureChannel)) {
    issues.push("失败通知渠道不在允许列表内");
  }
  return issues;
}

export type Progress = {
  readonly elapsedMinutes: number;
  readonly completedShare: number;
};

export type EtaStatus = "unknown" | "done" | "on-track" | "at-risk" | "breached";

export type EtaVerdict = {
  readonly status: EtaStatus;
  readonly projectedMinutes: number | null;
  readonly deltaMinutes: number | null;
  readonly shouldNotify: boolean;
  readonly message: string;
};

// 超过承诺 10% 进入「有风险」,超过 10% 以上进入「已违约」。
// 两个阈值都必须在回执里公开,用户才知道什么时候会收到改期通知。
export const NOTIFY_SLACK = 0.1;

export function projectEta(
  estimateMinutes: number,
  progress: Progress,
): EtaVerdict {
  if (progress.completedShare >= 1) {
    return {
      status: "done",
      projectedMinutes: progress.elapsedMinutes,
      deltaMinutes: 0,
      shouldNotify: false,
      message: "已完成",
    };
  }
  if (progress.completedShare <= 0 || progress.elapsedMinutes <= 0) {
    return {
      status: "unknown",
      projectedMinutes: null,
      deltaMinutes: null,
      shouldNotify: false,
      message: "尚无进度信号,按承诺时间等待",
    };
  }
  const projected = progress.elapsedMinutes / progress.completedShare;
  const delta = projected - estimateMinutes;
  const limit = estimateMinutes * (1 + NOTIFY_SLACK);
  let status: EtaStatus = "on-track";
  if (projected > limit) {
    status = "breached";
  } else if (projected > estimateMinutes) {
    status = "at-risk";
  }
  const shouldNotify = status === "at-risk" || status === "breached";
  const message = shouldNotify
    ? `预计需要 ${projected.toFixed(1)} 分钟,比承诺晚 ${delta.toFixed(1)} 分钟`
    : `按当前进度预计 ${projected.toFixed(1)} 分钟,仍在承诺内`;
  return {
    status,
    projectedMinutes: projected,
    deltaMinutes: delta,
    shouldNotify,
    message,
  };
}

export type Checkpoint = {
  readonly atMinute: number;
  readonly message: string;
};

export function checkpointDue(
  receipt: Receipt,
  elapsedMinutes: number,
): Checkpoint | null {
  if (elapsedMinutes < receipt.firstCheckpointMinutes) return null;
  return {
    atMinute: receipt.firstCheckpointMinutes,
    message: `任务 ${receipt.taskId} 已运行 ${receipt.firstCheckpointMinutes} 分钟,仍在处理`,
  };
}

export type FailureNotice = {
  readonly taskId: string;
  readonly failedStep: string;
  readonly preserved: string;
  readonly nextAction: string;
  readonly channel: NoticeChannel;
};

export function buildFailureNotice(
  receipt: Receipt,
  failedStep: string,
  preserved: string,
): FailureNotice {
  return {
    taskId: receipt.taskId,
    failedStep,
    preserved,
    nextAction: "可在原任务上重试,已完成步骤不会重复执行",
    channel: receipt.failureChannel,
  };
}

// B Quill 的初稿生成是 11 分钟;承诺的是「初稿可审」,不是「报告已发布」。
export const QUILL_RECEIPT: Receipt = {
  taskId: "quill-2026-11-001",
  estimateMinutes: QUILL.machineMinutes,
  firstCheckpointMinutes: 4,
  failureChannel: "in-app",
  whatArrives: "12–20 页报告初稿,可进入审改",
};

export function assessQuillProgress(
  elapsedMinutes: number,
  completedShare: number,
): EtaVerdict {
  return projectEta(QUILL_RECEIPT.estimateMinutes, {
    elapsedMinutes,
    completedShare,
  });
}

validateReceipt 返回的是问题列表,不是布尔值。产品评审时,空列表代表这张回执可以发给用户;只要有一条问题,就说明承诺里有一个字段是空的。projectEta 的四个状态对应四种界面:无信号时不编造 ETA,正常时不打扰,有风险和已违约时主动通知。buildFailureNotice 把失败通知从一句「出错了」拆成三段可执行信息。

把 B 的参数代进去:承诺 11 分钟,第 6 分钟完成 40%,外推 15 分钟,超过 11 分钟的 10% 缓冲带,状态是「已违约」,通知文案会说「预计需要 15.0 分钟,比承诺晚 4.0 分钟」。如果第 5 分钟完成 50%,外推 10 分钟,仍在承诺内,不打扰。模型不会替产品决定是否道歉,但它会替产品决定「什么时候必须开口」。

什么时候不该用异步

异步不是高级形态,它是有成本的。每增加一个异步任务,产品就多一套回执、检查点、失败通知和恢复逻辑。下面三种情况应该坚持同步:

  • 任务在几秒内完成。 A 的 1.05 分钟人机总耗时里,机器只占 0.30 分钟;把它做成异步,用户要多看一张回执,却省不下任何等待。
  • 用户必须在下一步做决定。 如果任务的结果会改变用户紧接着要做的动作,异步会把决策推迟,反而增加来回。
  • 失败后无法保留进度。 如果一个任务失败就必须从头再来,异步的检查点没有意义,不如同步重试。

反过来,B 和 C 适合异步,不是因为它们「更高级」,而是因为它们的等待时间足够长,长到用户必须离开页面;而且它们的中间状态可以保存,失败后不必全部重做。异步契约的价值,是把「用户盯着转圈」换成「用户知道什么时候回来」。

小结

  • 同步任务卖答案,异步任务卖承诺;回执是承诺的书面形式,不是加载动画。
  • 回执至少写清任务号、受理时间、预计时长、首个检查点、失败通知和交付物。
  • 交付物要停在自己能控制的边界上:B 承诺「初稿可审」,不承诺「报告完成」。
  • 预计时长必须可被推翻;外推超过承诺 10% 就要主动通知,不能等用户来问。
  • 失败通知要回答哪一步失败、什么被保留、下一步做什么,不能只写「出错了」。
  • B 的 11 分钟生成适合异步,A 的 1.05 分钟人机耗时适合同步;形态由等待结构决定,不由技术栈决定。
  • 检查点是提前发现迟到的窗口,不是刷存在感的进度条。

阅读导航:上一节:6.3 诚实的能力边界表达 · 下一节:7.2 等待体验的设计 。

常见错误与边界

  1. 把加载动画当回执。 转圈只证明请求发出去了,不证明任务被接住;回执必须带任务号和预计时间。
  2. 承诺自己控制不了的边界。 B 的审改是人的工作,承诺「报告完成」会把 1.6 小时审改算成产品延迟。
  3. 预计时长只写一次。 进度偏离后不更新 ETA,等于让用户拿旧承诺对照新现实。
  4. 把延迟和失败混为一谈。 延迟要继续等,失败要重试或转人工;两者用同一套文案会让用户做错动作。
  5. 失败通知不写保留内容。 只说「失败」会让用户以为全部白做,进而重复提交,制造重复副作用。
  6. 所有任务都做成异步。 A 的同步分诊只有 1.05 分钟人机耗时,异步化只会增加一层不必要的回执。

这一节解决「怎么承诺」。下一节要解决承诺之后的那段时间:用户在等待界面上到底该看到什么,才不会觉得被糊弄。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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