《AI Agent 产品开发·组织、平台与规模化》13.1 五级成熟度模型

成熟度不是功能清单的长度,而是能力能不能被复制。本节给出 L1 单点可用到 L5 组织能力的五级判据,逐条说明每一级新增什么、缺少什么会卡在下一级之前,用 A Relay、B Quill、C Runner 三家各定一级(L2、L2、L3),并拆解三种跨级跳跃的典型失败与一份可运行的定级函数。

一个 Agent 产品做得久了,团队最容易产生两种错觉:一种是把功能数量当成成熟度,每多一个能力就认为上了一个台阶;另一种是把某次漂亮的上线当成组织能力,认为换一个团队也能照着做一遍。这两种错觉都会在第二次复制时被打破。

成熟度模型要回答的不是「它有多强」,而是「它能不能被复制」。一家公司能不能把第一个产品的经验交给第二个团队,能不能在不依赖某个人的记忆的情况下继续上线新能力,能不能让新产品的周期不超过第一个——这些才是级别之间的差别。本节给出五级判据,用 A Relay(Northwind 的客服工单分诊 Agent)、B Quill(Meridian 的客户报告起草 Agent)、C Runner(Kettle 的电商运营任务执行 Agent)各定一级,再说明跨级跳跃为什么几乎必然失败。

五级各自回答什么问题

五级不是五个分数段,而是五种组织状态。每一级都有明确的判据,判据不满足就不能往上走,哪怕功能看起来更复杂。

级别名称判据典型特征
L1单点可用一个任务端到端跑通,指标靠人工观察有 Demo 与早期用户,没有放量曲线
L2可上线有放量曲线、撤回路径、质量节奏生产可用,但每上新能力都要重来
L3可复制第二个产品复用能力目录与评测集平台雏形,边界开始写成文档
L4平台化新团队做第十个产品的周期不超过第一个能力目录、评测集、责任边界可交接
L5组织能力组合、责任、成本、路线图进入常规治理决策有固定场所,成本有固定口径

这张表的顺序不能倒过来读。L2 不是「L1 做得更好」,而是多了三件 L1 不需要的东西:按比例扩大的放量曲线、出错时能撤回的路径、固定节奏的质量复盘。L3 也不是「L2 做得更大」,而是多了一个能被别人复用的产品,以及一套不靠人记的能力目录和评测集。

一个产品可以功能很复杂却停在 L1:它能演示,但没有人敢按比例放量,指标靠产品经理盯着看。反过来,一个功能很窄的产品可以到 L2:它只做分诊,但有 10% 到 40% 再到 100% 的放量记录,有明确的撤回方式,有连续四周的达标线。成熟度看的是后者。

每一级新增的判据

L1 只要求跑通。 一个任务从输入到输出能端到端完成,并且有真实用户在用它,而不是只在演示环境里跑过。L1 不要求放量,也不要求质量节奏;它的价值是证明任务成立,不是证明产品可运营。

L2 要求可运营。 三个判据缺一不可:有按比例扩大的放量曲线,说明团队知道怎么控制风险;有撤回路径,说明出错时不会只能道歉;有质量节奏与退出条件,说明团队能判断什么时候该停。A Relay 的试点是 10% 工单、3 周,扩大是 40%、4 周,全量要求连续 4 周达标;它的撤回路径是「不采纳」,因为建议根本没有落库。这三条加起来,A 就到了 L2。

L3 要求可复制。 三个判据是:第二个产品或任务线在运营;能力目录含 SLA 与责任人;有可重复运行的评测集。注意这里不要求平台。B Quill 有两个产品——客户报告起草与会议纪要整理——所以第一项满足;但它的能力目录只有半页文档,没有 SLA 与责任人,评测也只有报告抽样 20%,没有可回归的评测集,所以 B 停在 L2。

L4 要求平台化。 判据是平台由内部团队运营、平台与业务的边界成文、复制周期不超过第一个产品。C Runner 有内部平台,做调度、审计与回滚;它的复制周期比是 0.64(第一个产品 14 周,第二个 9 周),也满足;但它的平台边界只有一页说明,评审按「未成文」计 0 分,所以 C 停在 L3。这不是吹毛求疵:一页说明解决的是「看过的人知道」,成文解决的是「没参与的人能接手」。

L5 要求组织能力。 组合、责任、成本、路线图进入固定治理场所。三家都还没有到这一级。C 最接近,因为它的审计有责任人、考核里有拦截率与例外、供应商有主备,但组合决策、成本口径、路线图还没有固定场所。L5 的标志不是会多,而是同一套数字在组合、责任、成本三个场合能对上。

三家各定一级

把判据代进去,结果是 L2、L2、L3。这个结果看起来接近,但卡住它们的东西完全不同。

案例级别依据下一步
A RelayL2 可上线有放量曲线与质量节奏;只有一个产品,无能力目录与评测集做第二个产品,验证复用
B QuillL2 可上线有两个产品,但目录只有半页、没有 SLA 与评测集把模板与格式沉淀成带 SLA 的能力目录
C RunnerL3 可复制三条任务线、内部平台、能力目录、一次切换演练;边界未成文边界成文,补审计可导出

A 卡在「只有一个产品」。它的支持团队 9 人、工程投入 2 人,分诊这一件事做得足够好,但复用率是 0%。这不是说 A 应该立刻招人做第二个产品,而是说它在组织层面还没有回答「这套东西能不能再交付一次」。没有第二个产品,L3 的第一项判据就无法满足。

B 卡在「目录没有承诺」。它有 15 人、两个产品,复用率约 30%,看起来比 A 更接近 L3。但复用靠的是人记得模板放在哪,不是靠带 SLA 的条目。第二个产品能复用 30%,恰恰说明还有 70% 是重新做的。L3 要的不是「有人复用」,而是「复用可以被数出来、被承诺、被评测」。

C 卡在「边界没有成文」。它有 24 人、三条任务线、复用率约 55%、内部平台、能力目录含 SLA 与责任人、主备两家模型供应商并演练过一次切换,退出恢复时长估计 4 小时。它的组织事实是三家里最完整的,但仍然差一份可交接的边界文档。这也是为什么附录 C 里 C 的平台边界项是 0 分:平台在运转,边界在人脑子里。

跨级跳跃的三种失败

定级之后最常见的冲动是「跳级」:既然 L3 要第二个产品,那就同时开三个;既然 L4 要平台,那就先建平台。跳级失败不是因为团队能力不够,而是因为被跳过的那些判据,恰恰是下一级赖以成立的前提。

跳跃典型动作失效方式
L1 → L3第一个产品还没跑完放量就复制复制的是未验证的流程,第二个产品替第一个付学费
L2 → L4只有两个产品就建平台平台按第一个产品的形状凝固,第二个产品被迫改造
L3 → L5目录还没被引用就开治理会会上决定的东西,没人能在目录里查到承诺

L1 跳到 L3 的表现是「先开三条线,再补放量」。第一个产品还没有稳定的放量曲线,第二个产品就已经按同样的流程开跑。问题是第一个产品的流程本身没有被验证过,第二个产品复制的是不确定性。等到两个产品都出问题,团队会以为是执行问题,其实是把个例当成了方法。

L2 跳到 L4 的表现是「先建平台,再找复用」。平台一旦按第一个产品的形状建起来,第二个产品只有两个选择:改造自己适配平台,或者绕开平台另起一套。前者让第二个产品失去独立性,后者让平台变成摆设。C 的平台之所以还能运转,是因为它只有三条任务线且团队小、靠人记得边界;这正是规模化阶段最先失效的东西。

L3 跳到 L5 的表现是「先开治理会,再补目录」。会有固定的时间、固定的人、固定的议题,但议题背后的数字没有口径:组合边界靠感觉,成本只算模型调用,责任地图缺「做了但没人知道」那一格。会议开得越规律,越容易把没有依据的决定固化成制度。

还有一种不算跨级、但同样常见的失败:L4 到 L5 只加会议不加口径。平台已经能复制,但成本没有按月核算、责任没有写进四类事件,治理会就只能是表决会。级别看起来上了,实际上只是多了一层审批。

定级由谁做

定级必须由外部人做。自己给自己定级,通常高一到两级——这不是谦虚问题,是信息问题:内部人看不到自己依赖的那些「没人写下来但大家都记得」的东西。C 的平台边界就是例子:团队觉得「大家都知道平台只做三件事」,但评审人看不到这份「大家都知道」。

可操作的做法是三个人独立打分:不直接负责该产品的产品负责人、领域专家、工程负责人各一人。打分前先把事实写下来——在运营几个产品、复用率多少、目录有没有 SLA、平台边界有没有文档、退出演练做过几次。事实写完,级别通常自己就出来了。

定级频率建议每半年一次,与 45 项评审同场进行,但两者分开看。评审分数衡量「做得多全」,成熟度级别衡量「能不能复制」。一个产品可以分数不低但级别不高,因为它把容易的项都补了;也可以分数不高但级别不低,因为它的组织能力已经到位,只是还没写全。

把判据写成可运行的函数

下面这个模型把五级判据写成可执行的检查。输入是一组可观察事实,输出是已达到的最高级别、下一级还缺哪些判据,以及三种跨级跳跃的失效方式。三家的事实也写在同一个文件里,评审会上可以直接对照。

// file: src/scale/13-1-maturity-model.ts
// tier: L2
// verify: node --test test/scale/13-1-maturity-model.test.ts

// 五级成熟度:级别回答「能不能复制」,不回答「功能多不多」。
// 判据全部是可观察事实,定级由外部评审人完成。

export type Level = 1 | 2 | 3 | 4 | 5;

export const LEVEL_NAME: Record<Level, string> = {
  1: "L1 单点可用",
  2: "L2 可上线",
  3: "L3 可复制",
  4: "L4 平台化",
  5: "L5 组织能力",
};

export const LEVEL_ORDER: readonly Level[] = [1, 2, 3, 4, 5];

export type MaturityFacts = {
  readonly key: "A" | "B" | "C";
  readonly taskRuns: boolean; // 一个任务端到端跑通,并且真的有人在用
  readonly rolloutCurve: boolean; // 按比例扩大覆盖,而不是一次性全量
  readonly rollbackPath: boolean; // 不采纳、回退版本或反向执行
  readonly qualityCadence: boolean; // 固定节奏的质量复盘与退出条件
  readonly runningProducts: number; // 在运营的产品或任务线数量
  readonly capabilityCatalog: boolean; // 能力被写成条目
  readonly catalogHasSla: boolean; // 目录含 SLA 与责任人,可被别的团队引用
  readonly evaluationSet: boolean; // 可重复运行的评测集
  readonly platform: "none" | "toolbox" | "internal";
  readonly boundaryWritten: boolean; // 平台与业务的边界成文
  readonly cycleRatio: number | null; // 第二个周期 ÷ 第一个周期
  readonly governanceForum: boolean; // 组合、责任、成本进入固定治理
};

export type Criterion = {
  readonly id: string;
  readonly label: string;
  readonly met: (facts: MaturityFacts) => boolean;
};

// 每一级只列本级新增判据;升级逐级满足,不能跳。
export const CRITERIA: Record<Level, readonly Criterion[]> = {
  1: [{ id: "task-runs", label: "一个任务端到端跑通", met: (f) => f.taskRuns }],
  2: [
    { id: "rollout-curve", label: "有按比例扩大的放量曲线", met: (f) => f.rolloutCurve },
    { id: "rollback-path", label: "错误有撤回路径", met: (f) => f.rollbackPath },
    { id: "quality-cadence", label: "有质量节奏与退出条件", met: (f) => f.qualityCadence },
  ],
  3: [
    { id: "second-product", label: "第二个产品或任务线在运营", met: (f) => f.runningProducts >= 2 },
    {
      id: "catalog-sla",
      label: "能力目录含 SLA 与责任人",
      met: (f) => f.capabilityCatalog && f.catalogHasSla,
    },
    { id: "evaluation-set", label: "有可重复运行的评测集", met: (f) => f.evaluationSet },
  ],
  4: [
    { id: "internal-platform", label: "平台由内部团队运营", met: (f) => f.platform === "internal" },
    { id: "boundary-written", label: "平台与业务的边界成文", met: (f) => f.boundaryWritten },
    {
      id: "copy-faster",
      label: "复制周期不超过第一个产品",
      met: (f) => f.cycleRatio !== null && f.cycleRatio <= 1,
    },
  ],
  5: [
    {
      id: "governance-forum",
      label: "组合、责任、成本进入常规治理",
      met: (f) => f.governanceForum,
    },
  ],
};

export function meetsLevel(facts: MaturityFacts, level: Level): boolean {
  for (const current of LEVEL_ORDER) {
    if (current > level) break;
    if (!CRITERIA[current].every((criterion) => criterion.met(facts))) return false;
  }
  return true;
}

// 返回已满足的最高级别;一个任务都跑不通时返回 null。
export function assessLevel(facts: MaturityFacts): Level | null {
  let reached: Level | null = null;
  for (const level of LEVEL_ORDER) {
    if (!CRITERIA[level].every((criterion) => criterion.met(facts))) break;
    reached = level;
  }
  return reached;
}

export function levelLabel(level: Level | null): string {
  return level === null ? "未定级" : LEVEL_NAME[level];
}

export type NextGap = {
  readonly level: Level;
  readonly missing: readonly Criterion[];
};

// 下一级还缺哪些判据。已到 L5 时返回 null。
export function missingForNext(facts: MaturityFacts): NextGap | null {
  const current = assessLevel(facts);
  if (current === 5) return null;
  const next = (current === null ? 1 : current + 1) as Level;
  return {
    level: next,
    missing: CRITERIA[next].filter((criterion) => !criterion.met(facts)),
  };
}

// 三案例事实:数量、平台、复用与周期全部来自卷三事实表。
export const CASE_FACTS: Record<"A" | "B" | "C", MaturityFacts> = {
  A: {
    key: "A", taskRuns: true, rolloutCurve: true, rollbackPath: true,
    qualityCadence: true, runningProducts: 1, capabilityCatalog: false,
    catalogHasSla: false, evaluationSet: false, platform: "none",
    boundaryWritten: false, cycleRatio: null, governanceForum: false,
  },
  B: {
    key: "B", taskRuns: true, rolloutCurve: true, rollbackPath: true,
    qualityCadence: true, runningProducts: 2, capabilityCatalog: true,
    catalogHasSla: false, evaluationSet: false, platform: "toolbox",
    boundaryWritten: false, cycleRatio: 0.69, governanceForum: false,
  },
  C: {
    key: "C", taskRuns: true, rolloutCurve: true, rollbackPath: true,
    qualityCadence: true, runningProducts: 3, capabilityCatalog: true,
    catalogHasSla: true, evaluationSet: true, platform: "internal",
    // 只有一页说明,评审按「未成文」计 0 分。
    boundaryWritten: false, cycleRatio: 0.64, governanceForum: false,
  },
};

export const CASE_LEVEL: Record<"A" | "B" | "C", Level | null> = {
  A: assessLevel(CASE_FACTS.A),
  B: assessLevel(CASE_FACTS.B),
  C: assessLevel(CASE_FACTS.C),
};

export const CASE_LEVEL_LABEL: Record<"A" | "B" | "C", string> = {
  A: levelLabel(CASE_LEVEL.A),
  B: levelLabel(CASE_LEVEL.B),
  C: levelLabel(CASE_LEVEL.C),
};

export const CASE_BASIS: Record<"A" | "B" | "C", string> = {
  A: "有放量曲线与质量节奏;只有一个产品,无能力目录与评测集",
  B: "有两个产品,但目录只有半页、没有 SLA 与评测集",
  C: "三条任务线、内部平台、能力目录、一次切换演练;边界未成文",
};

export const CASE_NEXT: Record<"A" | "B" | "C", string> = {
  A: "做第二个产品,验证复用",
  B: "把模板与格式沉淀成带 SLA 的能力目录",
  C: "边界成文,补审计可导出",
};

export type SkipFailure = {
  readonly from: Level;
  readonly to: Level;
  readonly move: string;
  readonly failure: string;
};

export const SKIP_FAILURES: readonly SkipFailure[] = [
  {
    from: 1,
    to: 3,
    move: "第一个产品还没跑完放量就复制",
    failure: "复制的是未验证的流程,第二个产品替第一个付学费",
  },
  {
    from: 2,
    to: 4,
    move: "只有两个产品就建平台",
    failure: "平台按第一个产品的形状凝固,第二个产品被迫改造",
  },
  {
    from: 3,
    to: 5,
    move: "目录还没被引用就开治理会",
    failure: "会上决定的东西,没人能在目录里查到承诺",
  },
];

export function isSkip(from: Level, to: Level): boolean {
  return to - from >= 2;
}

assessLevel 从 L1 往上逐级检查,遇到第一个不满足的级别就停,返回上一级。missingForNext 只检查下一级新增的判据,所以它给出的不是「所有没做的事」,而是「升到下一级必须补的事」。这个区分很重要:A 的待办列表里可能有很多事,但升 L3 只差三件——第二个产品、带 SLA 的目录、评测集。

把三家代进去,A 和 B 都返回 L2,C 返回 L3。C 的下一级只缺一项:边界成文。这也解释了为什么附录 C 说 C 补两项文书就能过 72 分线,但仍然是 L3——过线补的是评审分数,边界成文补的是成熟度判据,两者不是同一张表。

模型只做判据检查,不做价值判断。它不能告诉你「该不该做第二个产品」,只能告诉你「没有第二个产品就到不了 L3」。该不该做,取决于组合策略与资源,那是第 1 章和第 10 章的问题。

定级之后做什么

定级的目的不是发证书,而是决定下一步把力气花在哪。三家的下一步已经在表里,但执行时还有一个顺序问题。

A 的下一步是第二个产品,但不要同时开三条。先选一个与分诊共享输入的任务,把复用清单记下来,再判断复用率。B 的下一步是把模板与格式沉淀成能力目录,重点不是写得更长,而是给每条能力写上 SLA 与责任人,再把报告抽样 20% 升级成可回归的评测集。C 的下一步是边界成文与审计可导出,两件都是文书工作,一周内可以完成,完成后它仍然是 L3,但已经具备升 L4 的判据。

不要用「我们已经在做 L4 的事」来解释跳级。L4 的平台化不是建一个平台,而是平台能被第二个团队接手。接手的标志是:新团队不看文档也能问对问题,看了文档能自己回答。没有成文边界,平台再强也只是一套内部工具。

小结

  • 成熟度衡量「能不能复制」,不衡量功能多少、模型多强。
  • L1 单点可用只要求任务跑通;L2 可上线要求放量曲线、撤回路径与质量节奏。
  • L3 可复制要求第二个产品、带 SLA 的能力目录与可回归的评测集。
  • L4 平台化要求内部平台、成文边界与不超过第一个产品的复制周期。
  • L5 组织能力要求组合、责任、成本、路线图进入固定治理。
  • 三家定级为 A L2、B L2、C L3;A 卡在单一产品,B 卡在目录无承诺,C 卡在边界未成文。
  • 跨级跳跃的失败来自被跳过的判据,不来自团队能力;先补判据,再谈升级。

阅读导航:上一节:12.3 招人看什么 · 下一节:13.2 全书 45 项评审汇总 。

常见错误与边界

  1. 把功能数量当成熟度。 功能多只说明产品复杂,不说明能被复制;一个功能很窄但有放量曲线与撤回路径的产品,级别可能更高。
  2. 把「有第二个产品」当成 L3。 L3 还要求能力目录含 SLA 与责任人、有可回归的评测集;两个产品各做各的,仍然停在 L2。
  3. 把「有平台」当成 L4。 平台化看的是边界成文与复制周期,不是平台规模;平台越大、边界越模糊,越难被第二个团队接手。
  4. 把「开治理会」当成 L5。 没有统一的组合、成本与责任口径,会议只会把没有依据的决定固化成制度。
  5. 自己给自己定级。 内部人看不见自己依赖的隐性知识,自评通常高一到两级;定级要由不直接负责该产品的人独立完成。
  6. 用评审分数替代成熟度。 分数衡量做得多全,级别衡量能不能复制;C 补两项文书可以过线,但它仍然是 L3。

这一节给出级别与判据。下一节把三卷 45 项评审汇总成一张表,看三家分别差在哪、补分从哪里开始。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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