《AI Agent 产品开发·组织、平台与规模化》2.3 迁移与统一的机会成本

统一迁移不是把三套东西并成一套那么简单。本节给出开发、迁移、培训、风险四类成本,用工程人周、退出恢复时长、受影响人数与不可回滚错误暴露逐项估算,并用复制周期比算 B 的回收期:每多一个产品省 0.8 周,2 周迁移要 2.5 个产品才回本,而 B 只有 1 个增量产品,所以不统一也是合法选择。

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

三个案例分别是 A Relay(Northwind 的客服工单分诊 Agent)、B Quill(Meridian 的客户报告起草 Agent)和 C Runner(Kettle 的电商运营任务执行 Agent);后文简称 A、B、C。

「我们有三个 Agent 产品,是不是该统一到一个平台?」这个问题几乎每个多产品组织都会问。提出者通常已经看到重复建设:三套审计日志、三套重试、三套权限、三套评测入口。统一看起来能省下这些重复,还能让复制下一个产品更快。但统一本身也要开发、要迁移、要培训、要承担迁移期间的风险,这些成本经常被低估,因为它们分散在不同团队、不同季度,不像重复开发那样显眼。

这一节把统一迁移的成本拆成四类,并用三个案例估算一次「以 C 的平台为参照」的统一:开发要多少人周、迁移要中断多久、培训涉及多少人、风险暴露是多少。结论可能反直觉:B 不应该统一,C 已经在自己平台上,A 连估算所需的数据都不完整。不统一不是失败,而是一个需要被认真论证的合法选择。

四种成本,四种单位

统一迁移的成本不能加成一个总分,因为四项的单位不同,强行相加会制造虚假的精确感。可以先把它们分开列。

成本项单位三案例是否可算说明
开发工程人周可算内部工程人数 × 第一个产品周期,再按复用率折算共享部分
迁移小时B、C 可算,A 未知供应商退出恢复时长;A 的事实表写的是「未知」
培训人只能算人数人均培训工时不在事实表中,不能编一个数
风险任务/月C 可算,A、B 未单列不可回滚错误率 × 月任务量

这张表最重要的不是数字,而是「可算性」。开发成本可以复算,迁移成本部分可算,培训只有人数,风险只有 C 有不可回滚口径。四项里有两项不完整,任何「总投资 X 人周、Y 美元」的单一结论都不可信。产品负责人应该先承认这个缺口,再决定要不要继续估。

开发成本:先看已经投入了多少

开发成本不是从零建一个平台,而是看各案例已经在共享层投入了多少。按「内部工程人数 × 第一个产品周期」计算:A 是 2×10=20 人周,B 是 1×16=16 人周,C 是 4×14=56 人周。再按复用率折算共享部分:A 0 人周,B 4.8 人周,C 30.8 人周。

这三个数说明一件常被忽略的事:C 的平台不是凭空出现的,它先投入了 30.8 人周在共享层。统一迁移如果以 C 的平台为参照,等于让 A 和 B 去补一部分 C 已经付过的成本;但 A 的复用率是 0%,它没有可共享的对象,补过去的共享层对它没有直接收益。B 只投入了 4.8 人周,它的共享层很小,统一迁移意味着把 4.8 人周的东西迁到一个 30.8 人周的平台上,开发和迁移的比例可能不划算。

开发成本还要看「重建」还是「接入」。重建是把 B 的三个共享能力用 C 的平台重写一遍,成本接近 4.8 人周加上适配;接入是保留 B 的实现,只接 C 的契约,成本主要是适配层。前者看起来更统一,后者看起来更务实;选择哪一种,取决于 B 是否愿意把共享层的控制权交出去。

迁移成本:退出恢复时长

迁移成本最容易被低估,因为它不是开发时间,而是业务中断时间。事实表第十节给出的退出恢复时长是:A 未知,B 2 周,C 4 小时。把 B 的 2 周换算成小时是 80 小时,C 的 4 小时就是 4 小时;A 的「未知」不是一个可以忽略的零,而是一个必须补齐的缺口。

B 的 2 周意味着迁移期间两个产品线可能无法正常发布,或者至少无法快速回退。对一个每月产出 606 份报告、服务 15 人咨询团队的组合来说,2 周的中断不是小事;它会影响客户交付节奏,也会让团队在迁移期间没有余力处理日常问题。C 的 4 小时则说明它的平台已经做过退出演练,切换成本被压得很低;这也是 C 敢做双供应商主备、演练 1 次的前提。

A 的未知最值得警惕。A 只有一个产品、9 人支持团队、月工单 26,400 单,任何迁移中断都会直接影响首响;但事实表没有给出它的退出恢复时长,说明这个数没有被测过。没有测过的恢复时长,不能按「应该很快」处理;正确的做法是先做一次退出演练,把未知变成已知,再谈迁移。

培训成本:人数与岗位变化

培训成本不只是上课时间,还包括岗位变化带来的适应期。三个案例的受影响人数是 A 9 人、B 15 人、C 24 人;岗位变化分别是执行者→审核者、执行者→审核者、执行者→规则制定者;考核变化分别是未改、部分改、改(拦截率与例外)。

A 和 B 的岗位变化相同,都是执行者变成审核者,但培训重点不同。A 的审核是「看一眼建议,采纳或修改」,单次 45 秒,培训重点是判断标准和修改理由;B 的审核是「读 12–20 页初稿,决定发布或返工」,单次 1.6 小时,培训重点是事实核查和客户语气。C 的岗位变化更深,执行者变成规则制定者,培训重点从「怎么做这个任务」变成「怎么定义什么该自动、什么该转人工」;考核也改成拦截率与例外,培训必须和考核一起改,否则规则制定者会用旧指标做新工作。

人均培训工时不在事实表中,所以本节不编一个数。能做的是把「人数 × 岗位变化深度 × 考核是否改」作为培训复杂度的代理:A 9 人、浅变化、考核未改;B 15 人、浅变化、考核部分改;C 24 人、深变化、考核改。C 的培训复杂度明显最高,这不是因为它人最多,而是因为岗位和考核同时变。

风险成本:错误暴露

迁移期间的风险,主要来自质量波动。把三个案例的错误率乘上月任务量,可以得到每月的错误暴露:A 的采纳后错误率 2.9%,26,400 单对应 765.6 次/月;B 的事实错误率 4.6%,606 份对应 27.876 次/月;C 的审计错误率 1.7%,13,200 个任务对应 224.4 次/月。C 还有不可回滚错误率 0.238%,对应 31.416 次/月。

这些数不是迁移造成的错误,而是现有错误暴露。它们的作用是给「质量下降一个百分点」定价:A 每下降一个百分点,多出 264 次错误/月;B 多出 6.06 次/月;C 多出 132 次/月,其中不可回滚部分按 14% 折算约多出 18.5 次/月。迁移期间如果评测跟不上,下降的可能不止一个百分点;C 的不可回滚错误尤其危险,因为 14% 的错误无法回滚,只能补偿。

风险成本还和迁移方式有关。影子运行可以把风险压到最低,但要花时间;直接切换最快,但一旦出错,回滚窗口很短。C 的放量顺序是影子 4 周、执行 5%、执行 20%、执行 60%,这个顺序本身就是风险控制;统一迁移如果跳过影子阶段,等于把 C 已经验证过的安全步骤省掉。

用复制周期比算回本

开发、迁移、培训、风险四项里,最能用事实表算清的是「复制周期比」。B 的第一个产品周期 16 周,第二个 11 周,比值 0.69;C 的第一个 14 周,第二个 9 周,比值 0.64。假设 B 统一到 C 的平台后,复制周期比能从 0.69 降到 0.64,那么每多做一个产品,B 能省下 16×(0.69−0.64)=0.8 周。

B 的迁移成本是 2 周。用 2 周除以每个产品省下的 0.8 周,得到 2.5 个产品:也就是说,B 需要再做一个半产品,才能把迁移成本赚回来。B 现在有 2 个产品,按「再做一个」计算只有 1 个增量产品;1 小于 2.5,所以这次统一在周期上不回本。这个结论不依赖培训、风险这些难算的成本;只算最容易算的那一项,就已经不划算了。

C 的情况不同。C 的复制周期比已经是 0.64,统一到「C 的平台」不会让它更快,增益是 0;它的迁移成本是 4 小时,作为平台提供方,它更可能是「被接入」而不是「迁出去」。A 没有第二个产品周期,退出恢复时长又未知,连回本公式的输入都不完整,判定是「无法估算」,不是「不值得」。

不统一也是合法选择

把上面的数放在一起,可以得到三个不同的结论。

A:先补数据,不谈统一。 A 只有一个产品、复用率 0%、第二个周期不存在、退出恢复时长未知。统一迁移对 A 没有可分享的共享层,也没有可比较的复制收益;此时最该做的是把退出恢复时长测出来,把能力目录和评测基线补齐,而不是加入一个平台。

B:保留工具集合,不统一。 B 的共享层只有 4.8 人周,迁移要 2 周,每多一个产品只省 0.8 周,回本需要 2.5 个增量产品,而 B 只有 1 个。培训涉及 15 人、考核部分改,风险虽然比 C 低,但也不是零。综合看,B 的统一收益覆盖不了迁移和培训成本;保留三个共享能力的工具集合,把半页能力目录维护好,是更合理的选择。

C:平台保留,边界成文,谨慎对外。 C 已经投入 30.8 人周建平台,复制周期比 0.64,退出恢复 4 小时,三条任务线复用率约 55%。它的平台对自身是合理的;但把它推广给 A 和 B 时,要面对责任档不同、复用率不同、迁移成本不同三个问题。C 可以做平台提供方,但不能假设「我的平台对所有人都合适」。

「不统一」不是保守,而是把机会成本算清楚后的选择。统一的收益是省下重复开发、加快复制;成本是开发、迁移、培训和风险。当收益只对未来的产品数量生效,而组织的路线图里没有那么多新产品时,统一就是在为不存在的规模付费。

写成可复算的模型

下面这个模型把四类成本做成结构化输出,并用复制周期比计算回本产品数。它不把四项加成一个总分,因为单位不同;它只回答三个可判定问题:能不能算、回本要几个产品、按当前产品数是否值得。

// file: src/scale/02-3-migration-cost.ts
// tier: L2
// verify: node --test test/scale/02-3-migration-cost.test.ts

// 迁移与统一的机会成本:省下的重复开发 vs 打断的业务节奏。
// 四个成本项里,开发和迁移可复算;培训只有人数,风险只有错误暴露。

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

export const HOURS_PER_WEEK = 40;

export type CaseKey = "A" | "B" | "C";

export type MigrationCase = {
  readonly key: CaseKey;
  readonly products: number;
  readonly teamSize: number;
  readonly engineers: number;
  readonly firstCycleWeeks: number;
  readonly secondCycleWeeks: number | null;
  /** 供应商退出恢复时长;A 未知 */
  readonly recoveryHours: number | null;
  readonly reuseBps: Bps;
  readonly errorRate: number;
  /** 不可回滚错误率;A、B 未单列 */
  readonly unrecoverableRate: number | null;
  readonly roleChange: string;
};

export const CASES: Record<CaseKey, MigrationCase> = {
  A: {
    key: "A",
    products: 1,
    teamSize: RELAY.teamSize,
    engineers: 2,
    firstCycleWeeks: 10,
    secondCycleWeeks: null,
    recoveryHours: null,
    reuseBps: 0,
    errorRate: 0.029,
    unrecoverableRate: null,
    roleChange: "执行者→审核者",
  },
  B: {
    key: "B",
    products: 2,
    teamSize: QUILL.teamSize,
    engineers: 1,
    firstCycleWeeks: 16,
    secondCycleWeeks: 11,
    recoveryHours: 80,
    reuseBps: 3_000,
    errorRate: 0.046,
    unrecoverableRate: null,
    roleChange: "执行者→审核者",
  },
  C: {
    key: "C",
    products: 3,
    teamSize: RUNNER.teamSize,
    engineers: 4,
    firstCycleWeeks: 14,
    secondCycleWeeks: 9,
    recoveryHours: 4,
    reuseBps: 5_500,
    errorRate: 0.017,
    unrecoverableRate: 0.00238,
    roleChange: "执行者→规则制定者",
  },
};

export function engineerWeeks(item: MigrationCase): number {
  return item.engineers * item.firstCycleWeeks;
}

export function sharedEngineerWeeks(item: MigrationCase): number {
  return Math.round(((engineerWeeks(item) * item.reuseBps) / FULL) * 10) / 10;
}

export function round2(value: number): number {
  return Math.round(value * 100) / 100;
}

export function cycleRatio(item: MigrationCase): number | null {
  if (item.secondCycleWeeks === null) return null;
  return item.secondCycleWeeks / item.firstCycleWeeks;
}

export function roundedCycleRatio(item: MigrationCase): number | null {
  const ratio = cycleRatio(item);
  return ratio === null ? null : round2(ratio);
}

// 以 C 的复制周期比为参照,B 每多做一个产品能省下的周数。
export function cycleGainWeeks(
  item: MigrationCase,
  targetRatio: number,
): number | null {
  const ratio = roundedCycleRatio(item);
  if (ratio === null) return null;
  const gain = round2(item.firstCycleWeeks * (ratio - targetRatio));
  return gain > 0 ? gain : 0;
}

export function paybackProducts(
  item: MigrationCase,
  targetRatio: number,
): number | null {
  if (item.recoveryHours === null) return null;
  const gain = cycleGainWeeks(item, targetRatio);
  if (gain === null) return null;
  if (gain === 0) return Infinity;
  return round2(item.recoveryHours / HOURS_PER_WEEK / gain);
}

export type MigrationVerdict =
  | "insufficient"
  | "already-at-target"
  | "worth-it"
  | "not-worth-it";

export function migrationVerdict(
  item: MigrationCase,
  targetRatio: number,
): MigrationVerdict {
  if (item.secondCycleWeeks === null || item.recoveryHours === null) {
    return "insufficient";
  }
  const gain = cycleGainWeeks(item, targetRatio);
  if (gain === null) return "insufficient";
  if (gain === 0) return "already-at-target";
  const payback = paybackProducts(item, targetRatio);
  if (payback === null) return "insufficient";
  return payback <= item.products - 1 ? "worth-it" : "not-worth-it";
}

export function monthlyErrorExposure(item: MigrationCase): number {
  const profile = item.key === "A" ? RELAY : item.key === "B" ? QUILL : RUNNER;
  return profile.monthlyTasks * item.errorRate;
}

export function unrecoverableExposure(item: MigrationCase): number | null {
  if (item.unrecoverableRate === null) return null;
  const profile = item.key === "A" ? RELAY : item.key === "B" ? QUILL : RUNNER;
  return profile.monthlyTasks * item.unrecoverableRate;
}

export type CostComponent = {
  readonly name: "development" | "migration" | "training" | "risk";
  readonly unit: string;
  readonly value: number | null;
  readonly note: string;
};

export function costModel(item: MigrationCase): readonly CostComponent[] {
  return [
    {
      name: "development",
      unit: "engineer-weeks",
      value: sharedEngineerWeeks(item),
      note: "复用率折算出的共享能力工程人周",
    },
    {
      name: "migration",
      unit: "hours",
      value: item.recoveryHours,
      note: "供应商退出恢复时长;A 未知",
    },
    {
      name: "training",
      unit: "people",
      value: item.teamSize,
      note: "需改流程的人数;人均培训工时未在事实表中",
    },
    {
      name: "risk",
      unit: "tasks/month",
      value: unrecoverableExposure(item),
      note: "不可回滚错误暴露;A、B 未单列",
    },
  ];
}

costModel 返回四个组件,每个组件带单位:开发是人周、迁移是小时、培训是人、风险是任务/月。A 的迁移和风险是 null,因为事实表没有给出退出恢复时长,也没有单列不可回滚错误;返回 null 而不是 0,是为了让「未知」在模型里保持未知。

cycleGainWeeks 用 B 的 16 周乘以 0.69 与 0.64 的差,得到 0.8 周;paybackProducts 用 2 周迁移成本除以 0.8,得到 2.5 个产品;migrationVerdict 再和 B 的增量产品数 1 比较,得出 not-worth-it。C 的增益是 0,判定 already-at-target;A 缺少第二个周期和恢复时长,判定 insufficient。

monthlyErrorExposure 和 unrecoverableExposure 把错误率乘上月任务量,得到风险暴露。它们不参与回本计算,因为风险的单位是任务/月,不能直接换算成周;它们的作用是提醒评审:迁移期间的质量波动有真实的数量级,不能只用「风险可控」四个字带过。

小结

  • 统一迁移有四类成本:开发、迁移、培训和风险;单位不同,不能加成一个总分。
  • 开发成本按内部工程人数乘第一个周期计算:A 20、B 16、C 56 人周;共享部分按复用率折算为 0、4.8、30.8 人周。
  • 迁移成本看退出恢复时长:A 未知、B 2 周(80 小时)、C 4 小时;未知不能当成零。
  • 培训只能算受影响人数:A 9、B 15、C 24;人均工时不在事实表中,不应编造。
  • 风险暴露按错误率乘月任务量:A 765.6、B 27.876、C 224.4 次/月;C 的不可回滚暴露是 31.416 次/月。
  • B 的复制周期比 0.69,若降到 C 的 0.64,每多一个产品省 0.8 周;2 周迁移需要 2.5 个增量产品才回本,而 B 只有 1 个。
  • 三个结论:A 先补数据、B 不统一、C 保留平台但谨慎对外;不统一是合法选择。
  • 统一只在「省下的重复开发覆盖迁移、培训与风险」且「回本产品数不超过路线图增量」时成立。

阅读导航:上一节:2.2 平台与业务的边界 · 下一节:3.1 什么时候该上多 Agent 。

常见错误与边界

  1. 把四类成本加成一个总分。 人周、小时、人、任务/月不能直接相加;强行汇总会制造虚假的精确感。
  2. 把未知的恢复时长当成零。 A 的退出恢复时长是未知,不是很快;没有演练过的切换,不能按低风险处理。
  3. 只算开发,不算迁移和培训。 开发是最容易看见的成本,迁移中断和岗位适应期往往更贵,尤其是 B 的 2 周和 C 的 24 人规则制定者转型。
  4. 用未来的产品数量证明当前统一。 回本需要 2.5 个增量产品,路线图里只有 1 个时,统一是在为不存在的规模付费。
  5. 把 C 的平台当成通用答案。 C 的 55% 复用率和 4 小时恢复是它自己的结构;A 的复用率 0%、B 的迁移 2 周,复制过去不一定成立。
  6. 把「不统一」当成保守。 不统一是算清机会成本后的选择;真正需要论证的是统一,而不是维持现状。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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