《AI Agent 产品开发·交互、信任与上线》11.1 按风险分层的放量上限

本节回答放量到底按什么单位推进:不是用户数,而是风险暴露量。给出可逆性、客户可见性、资金影响与审计有效性四维分层表,用 C Runner 的 5%、20%、60% 三级说明低、中、高风险动作的进入顺序,并附可运行的暴露量与阶段上限模型,帮助产品负责人在放量前先算清最坏情况会暴露多少任务。

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

试点通过之后,团队最常问的问题是「什么时候可以扩到全量」。这个问题看起来是时间问题,实际是风险问题:同样扩到 40% 的用户,如果这 40% 里包含大量不可逆动作,暴露面可能比 100% 的只读检查更大。

所以放量的单位不是用户数,也不是任务数,而是风险暴露量。风险暴露量由三个因子相乘:覆盖的任务数、动作本身的危险程度、以及出错后能不能收回。这一节先把动作分成三档,再用 C Runner 的 5%、20%、60% 说明为什么不可逆动作必须最后放。

用户数为什么不是放量单位

假设两个团队都决定「先放 10% 的用户」。A Relay 放的是 10% 的工单分诊建议,机器只给建议,人确认后才生效;C Runner 放的是 10% 的运营任务,机器会直接改价、下架、发通知。两者的用户比例相同,风险暴露量差了一个数量级。

用户数只描述「谁在用」,不描述「机器能做什么」。真正决定风险的是动作:只读检查错了,最多是漏看;改价错了,会直接影响成交;发通知错了,客户已经收到,撤不回来。

放量单位回答的问题什么时候会骗人
用户数多少人能用用户少但动作危险时,风险被低估
任务数多少任务被处理任务多但都是只读时,风险被高估
风险暴露量多少危险动作被执行需要先给动作分层,计算成本更高

风险暴露量不是要取代用户数和任务数,而是给它们加一个权重。用户数回答「覆盖面」,风险暴露量回答「最坏情况有多大」。放量决策应该同时看两个数:覆盖面决定学习速度,暴露量决定能不能承受一次事故。

风险分层的四个维度

分层不能只看「这个动作重不重要」,那太主观。可以用四个可观察的维度:

维度低风险中风险高风险
可逆性完全可回滚需要人工介入才能回滚不可回滚
客户可见性内部可见客户能看到结果客户已经收到且无法撤回
资金影响无直接资金变化影响后续结算直接改动价格或退款
审计有效性全量可判断抽样可判断事后难以判断对错

四个维度里,可逆性权重最高。一个动作只要不可逆,不管它看起来多小,都应该先按高风险处理。C Runner 的错误中 86% 可回滚,14% 不可回滚;不可回滚错误率是 1.7% × 14% = 0.238%。这个比例看起来很小,但乘以 13,200 个任务,每个月仍有约 31.4 个不可回滚错误。这个数字不是可以靠「再观察一周」消化的。

第二个重点是客户可见性。内部可见的错误可以内部消化,客户可见的错误会变成投诉,客户已经收到的错误会变成补偿。三者对应三套处理流程,不能共用同一个放量阈值。

三档动作与进入顺序

把四个维度合成三档,得到一个足够简单的规则:

档位判定典型动作进入阶段
低风险可逆、内部可见、无资金影响、全量可审计只读检查、生成内部摘要5% 阶段
中风险可逆、客户可见,或抽样可审计改库存、下架、改展示文案20% 阶段
高风险不可逆,或直接改动资金改价、退款、发客户通知60% 阶段达标之后

这个规则不追求精确,追求的是顺序稳定。只要顺序稳定,团队就不会在事故后争论「这个动作算不算高风险」;规则已经提前写好了。

C Runner 的三级放量正好对应这个顺序:

阶段覆盖时长允许的动作退出条件
影子100% 只记录4 周不执行与人工决策一致率 ≥ 85%
执行 5%5% 任务4 周低风险错误率 ≤ 2%,零不可回滚错误
执行 20%20% 任务8 周低 + 中风险错误率 ≤ 1.8%,回滚成功率 100%
执行 60%60% 任务8 周不含高风险连续 8 周达标

注意 60% 阶段仍然「不含高风险」。高风险动作不是在第 60% 阶段顺便放开的,而是在 60% 阶段连续达标之后单独决策。这个细节经常被漏掉:团队看到「60%」就以为只剩 40% 的收尾,实际上最危险的那部分还没有开始。

暴露量怎么算

把风险暴露量写成一个可计算的数:

暴露量 = 覆盖任务数 × 风险档权重
覆盖任务数 = 月任务量 × 覆盖率

权重不是精确的科学常数,而是把「低、中、高」的相对危险程度显式化。一个可用的起点是 1、3、12:高风险动作的错误代价大约是低风险的十二倍。团队可以根据自己的事故记录调整权重,但一旦定下,就要在所有放量评审里用同一套。

以 C Runner 为例:

阶段覆盖率覆盖任务数允许档位暴露量
执行 5%5%660低660
执行 20%20%2,640低 + 中10,560
执行 60%60%7,920低 + 中31,680
全量100%13,200低 + 中 + 高211,200

从 5% 到 20%,覆盖任务数变成 4 倍,暴露量变成 16 倍;从 20% 到 60%,覆盖任务数变成 3 倍,暴露量变成 3 倍。这个非线性来自档位权重:20% 阶段第一次引入中风险动作,暴露量的跳变应该被看见,而不是只看到「覆盖率从 5% 到 20%」。

不可逆动作为什么必须最后放

不可逆动作的风险不是「错误率更高」,而是「错误的后果不能被时间修复」。可逆动作错了,回滚就是一次操作;不可逆动作错了,只能补偿,而补偿的成本通常高于预防。

C Runner 的 14% 不可回滚动作主要是已发出的客户通知。通知发错了对象或内容,反向执行没有意义,只能补发说明并安排人工回访。事实表把这类动作单列出来,就是为了让放量计划把它们排在最后。

动作可逆客户可见资金影响档位放量位置
只读检查是否否低5%
改库存是是否中20%
下架是是否中20%
改价是是是高60% 达标后
发客户通知否是否高60% 达标后

这张表还有一个用途:当团队想「先放一个高风险动作试试」时,可以直接指出它跳过了两个阶段。跳过阶段不是绝对禁止,但必须有单独的风险评审和回滚演练记录,不能混在常规放量里。

把分层写成可执行模型

下面的模型把动作分类、阶段上限、档位准入和暴露量放在一起。它的输出不是「能不能放」,而是「这个阶段最多覆盖多少、哪些档位被允许、暴露量是多少」。

// file: src/rollout/11-1-risk-tiers.ts
// tier: L2
// verify: node --test test/rollout/11-1-risk-tiers.test.ts

// 放量单位不是用户数,而是风险暴露量:
// 月任务量 × 覆盖率 × 该风险档的权重。
// 不可逆动作排在最后,不是因为难,而是因为错了没法收回。

import { RUNNER } from "../cases.ts";
import { applyRate, FULL, type Bps } from "../core/rate.ts";

export type RiskTier = "low" | "medium" | "high";
export type Stage = "shadow" | "execute-5" | "execute-20" | "execute-60" | "full";

export type ActionClass = {
  readonly name: string;
  readonly reversible: boolean;
  readonly customerVisible: boolean;
  readonly financialImpact: boolean;
  readonly auditBps: Bps;
};

// 先看能不能收回,再看影响面,最后看审计能不能判对错。
export function classify(action: ActionClass): RiskTier {
  if (!action.reversible || action.financialImpact) return "high";
  if (action.customerVisible) return "medium";
  if (action.auditBps < 8_000) return "medium";
  return "low";
}

export const TIER_WEIGHT: Record<RiskTier, number> = {
  low: 1,
  medium: 3,
  high: 12,
};

export const STAGE_CAP_BPS: Record<Stage, Bps> = {
  shadow: 0,
  "execute-5": 500,
  "execute-20": 2_000,
  "execute-60": 6_000,
  full: FULL,
};

// 低风险在 5% 阶段进入,中风险在 20%,高风险要等 60% 阶段连续达标之后。
export const ADMIT_AT: Record<RiskTier, Stage> = {
  low: "execute-5",
  medium: "execute-20",
  high: "full",
};

const STAGE_RANK: Record<Stage, number> = {
  shadow: 0,
  "execute-5": 1,
  "execute-20": 2,
  "execute-60": 3,
  full: 4,
};

export function admittedAt(tier: RiskTier, stage: Stage): boolean {
  return STAGE_RANK[stage] >= STAGE_RANK[ADMIT_AT[tier]];
}

export type StagePlan = {
  readonly stage: Stage;
  readonly capBps: Bps;
  readonly admitted: readonly RiskTier[];
  readonly excluded: readonly RiskTier[];
  readonly exposedTasks: number;
  readonly exposure: number;
};

export function planStage(monthlyTasks: number, stage: Stage): StagePlan {
  const tiers: readonly RiskTier[] = ["low", "medium", "high"];
  const admitted = tiers.filter((tier) => admittedAt(tier, stage));
  const excluded = tiers.filter((tier) => !admittedAt(tier, stage));
  const exposedTasks = applyRate(monthlyTasks, STAGE_CAP_BPS[stage]);
  const exposure = admitted.reduce(
    (sum, tier) => sum + exposedTasks * TIER_WEIGHT[tier],
    0,
  );
  return {
    stage,
    capBps: STAGE_CAP_BPS[stage],
    admitted,
    excluded,
    exposedTasks,
    exposure,
  };
}

// 同一阶段里,风险越高的动作应该占总量的比例越低。
export function shareWithinStage(tier: RiskTier, stage: Stage): Bps {
  if (!admittedAt(tier, stage)) return 0;
  const total = (["low", "medium", "high"] as const)
    .filter((t) => admittedAt(t, stage))
    .reduce((sum, t) => sum + TIER_WEIGHT[t], 0);
  return Math.round((TIER_WEIGHT[tier] / total) * FULL);
}

export function rolloutOrder(actions: readonly ActionClass[]): readonly string[] {
  const rank: Record<RiskTier, number> = { low: 0, medium: 1, high: 2 };
  return actions
    .slice()
    .sort(
      (a, b) =>
        rank[classify(a)] - rank[classify(b)] || a.name.localeCompare(b.name),
    )
    .map((action) => action.name);
}

export const RUNNER_ACTIONS: readonly ActionClass[] = [
  {
    name: "read-only check",
    reversible: true,
    customerVisible: false,
    financialImpact: false,
    auditBps: 9_500,
  },
  {
    name: "stock update",
    reversible: true,
    customerVisible: true,
    financialImpact: false,
    auditBps: 9_000,
  },
  {
    name: "delist",
    reversible: true,
    customerVisible: true,
    financialImpact: false,
    auditBps: 9_000,
  },
  {
    name: "price change",
    reversible: true,
    customerVisible: true,
    financialImpact: true,
    auditBps: 9_000,
  },
  {
    name: "send customer notice",
    reversible: false,
    customerVisible: true,
    financialImpact: false,
    auditBps: 9_000,
  },
];

export const C_STAGES: readonly Stage[] = [
  "shadow",
  "execute-5",
  "execute-20",
  "execute-60",
  "full",
];

export function runnerStagePlan(stage: Stage): StagePlan {
  return planStage(RUNNER.monthlyTasks, stage);
}

模型里有两个刻意的选择。第一,classify 先判断 reversible 和 financialImpact,再看客户可见性和审计有效性;这是把「能不能收回」放在「影响大不大」前面。第二,ADMIT_AT 把高风险动作放在 full,而不是 execute-60;这对应事实表里「执行 60% 不含高风险动作」的口径。

shareWithinStage 是一个辅助判断:在同一个阶段里,高风险动作的权重占 75%,中风险占 18.75%,低风险占 6.25%(全量阶段)。这不是要求动作数量按这个比例分配,而是提示评审者:一旦高风险动作进入,它就会主导暴露量。

放量评审要问的四个问题

有了模型,放量评审可以固定问四个问题:

  1. 这一阶段允许哪些档位的动作?被排除的档位有没有偷偷混进来?
  2. 覆盖率乘以月任务量,实际覆盖多少任务?
  3. 按当前权重,暴露量是多少?和上一阶段比,跳变是否可解释?
  4. 如果今天出现一次最坏情况,回滚或补偿能不能在承诺时间内完成?

四个问题里,第四个最容易被跳过。团队通常能说清「放多少」,说不清「出事后多久能恢复」。而恢复能力才是放量的真正上限:恢复不了的动作,放 1% 也是太多。

小结

  • 放量单位不是用户数,也不是任务数,而是风险暴露量。
  • 风险分层看四个维度:可逆性、客户可见性、资金影响、审计有效性。
  • 可逆性权重最高;不可逆动作不管多小,都先按高风险处理。
  • 低风险在 5% 阶段进入,中风险在 20%,高风险要等 60% 阶段连续达标之后。
  • C Runner 的 5%、20%、60% 不是三个百分比,而是三次风险档位的扩容。
  • 暴露量 = 覆盖任务数 × 风险档权重;20% 阶段第一次引入中风险,暴露量会跳变。
  • 不可逆动作必须最后放;C 的 14% 不可回滚动作对应 0.238% 的不可回滚错误率。
  • 放量评审要同时回答覆盖多少、暴露多少、出事后多久能恢复。

阅读导航:上一节:10.3 试点的退出条件 · 下一节:11.2 回滚触发条件 。

常见错误与边界

  1. 按用户数放量。 同样 10% 的用户,只读检查和改价的风险差一个数量级;用户数不描述机器能做什么。
  2. 把高风险动作混进 60% 阶段。 事实表的 60% 明确「不含高风险动作」;高风险要在 60% 连续达标后单独决策。
  3. 只算覆盖率,不算暴露量。 5% 到 20% 覆盖任务数变 4 倍,暴露量可能变 16 倍;跳变必须被看见。
  4. 权重经常改。 权重可以调整,但同一轮放量评审必须用同一套;否则阶段之间不可比。
  5. 跳过阶段做「小范围试试」。 跳过阶段不是绝对禁止,但要有单独的风险评审和回滚演练记录。
  6. 不问恢复时间。 恢复不了的动作,放 1% 也是太多;放量上限最终由恢复能力决定。

下一节把「什么时候回滚」写成三类触发条件:指标阈值、单一严重事件、人工判断权。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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