《AI Agent 产品开发·任务定义与能力边界》12.3 aia-lab:三案例的度量口径与验算

把四个指标与人机时间账写成一个可对账的模型:人工、系统、维护三笔分列,三案例逐项复算;再故意实现一个漏算转人工的 C Runner 版本,展示节省率如何从 73.7% 夸大到 90.8%,差出 17.1 个百分点,并说明为什么人工口径比模型价格更敏感。

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

前两节给了四个指标和三个陷阱,这一节把它们落到一个能跑的模型里。模型只做一件事:把每个案例的人工、系统、维护三笔成本分开算,再和原人工成本对账。对不上的地方不许静默通过,必须通过 Result 返回错误。

模型要固定三件事。第一,人工分钟必须拆成审改或审计与转人工两段,C Runner 的 4.04 分钟要能由 0.96 加 3.08 加出来。第二,系统成本与维护摊销单独列,不能混进人工。第三,节省率的分母是原人工月成本,不是月总成本,也不是系统成本。

固定这三件事之后,三案例的月度账可以逐项复算。A 的月总成本是 11,548.8 美元,B 是 31,681.92 美元,C 是 31,214.4 美元。三个数都与案例事实表一致,差额来自人工、系统、维护三笔的不同组合,不是四舍五入。

人工账先拆成两段

人工账是整张表里最容易错的部分。A 和 B 的人工只有一段:A 是确认 0.75 分钟,B 是审改 96 分钟。C 有两段:审计 0.96 分钟,转人工 3.08 分钟。把两段合并成 4.04 分钟,才能和原人工 18 分钟比较。

案例审改/审计(分钟)转人工(分钟)人工合计(分钟)原人工(分钟)
A Relay0.7500.753.50
B Quill96.00096.00252.00
C Runner0.963.084.0418.00

这张表解释了一个常见误解:C 的 Agent 执行耗时是 2.4 分钟,但人工不是 2.4 分钟,也不是 0.96 分钟。2.4 分钟是机器时间,0.96 分钟是审计摊销,3.08 分钟是转人工。三者相加是 6.44 分钟,这才是「一个任务从开始到结束」的总耗时;其中人工只有 4.04 分钟。

A 和 B 没有转人工,不代表它们没有接管。A 的 22% 修改发生在同一条工单流程里,时间已经算进 0.75 分钟的加权确认时长;B 的 37% 小改与返工发生在审改环节,时间已经算进 1.6 小时的加权审改时长。C 的转人工之所以要单独列,是因为任务离开了自动通道,人工从接手到完成要 14 分钟,这笔时间不在审计的 0.96 分钟里。

三案例的月度对账

把人工、系统、维护三笔代入月度账,结果如下。每一行都能用「任务量 × 单任务成本」复算。

案例月任务月人工小时人工成本系统成本维护摊销月总成本月节省节省率
A Relay26,400330.09,900448.81,20011,548.834,651.275.0%
B Quill606969.629,088193.922,40031,681.9244,674.0858.5%
C Runner13,200888.826,664950.43,60031,214.487,585.673.7%

A 的人工成本是 330 小时乘 30 美元,系统成本是 26,400 单乘 0.017 美元,维护摊销 1,200 美元。三项相加 11,548.8 美元,对比原人工 46,200 美元,节省 34,651.2 美元,节省率 75.0%。

B 的人工是 606 份乘 1.6 小时,得 969.6 小时,乘 30 美元是 29,088 美元。系统成本是 606 份乘 0.32 美元,得 193.92 美元;维护 2,400 美元。月总成本 31,681.92 美元,对比原人工 76,356 美元,节省 44,674.08 美元,节省率 58.5%。

C 的人工是 13,200 个任务乘 4.04 分钟,除以 60 得 888.8 小时,乘 30 美元是 26,664 美元。系统成本是 13,200 乘 0.072 美元,得 950.4 美元;维护 3,600 美元。月总成本 31,214.4 美元,对比原人工 118,800 美元,节省 87,585.6 美元,节省率 73.7%。

三个案例的系统成本占原人工的比例分别是 0.97%、0.25%、0.80%,都很小。维护摊销反而是大头:A 的维护是系统成本的 2.67 倍,B 是 12.38 倍,C 是 3.79 倍。这说明 Agent 产品的成本主体不是模型调用,而是「让它持续正确」的规则、评测和标注。

故意漏算转人工的版本

现在把 C 的人工改成只算审计的 0.96 分钟,其他两笔不变。月人工小时从 888.8 掉到 211.2,人工成本从 26,664 掉到 6,336,月总成本从 31,214.4 掉到 10,886.4。原人工成本不变,节省额变成 107,913.6 美元,节省率变成 90.8%。

口径月人工小时人工成本月总成本月节省节省率
含转人工(正确)888.826,66431,214.487,585.673.7%
只算审计(错误)211.26,33610,886.4107,913.690.8%
差额677.620,32820,32820,32817.1 个百分点

这张表里,错误版本的总成本少了 20,328 美元,正好是 3.08 分钟转人工乘以 13,200 个任务再乘 30 美元/小时。节省率多了 17.1 个百分点,全部来自这一笔。系统成本与维护摊销没有变,所以差额可以直接归因到人工口径。

这也是为什么模型要提供 includeHandoff 开关,而不是把两个版本写成两份代码。两份代码会各自演化,最后没人说得清差异来自哪里;一个开关加一组期望值,可以让错误版本也接受测试,从而被固定成一个可对照的反例。

把对账写成一个模型

下面的代码把人工拆分、月度账、对账结果放在同一个文件里。三案例的期望总成本写成常量,verifyAgainstBible 用 Result 返回 ok 或 fail;漏算转人工的版本也走同一条路径,只是期望值不同。

// file: src/metrics/12-3-lab-metrics.ts
// tier: L2
// verify: node --test test/metrics/12-3-lab-metrics.test.ts

// 把四个指标接成一张月度账:人工、系统、维护分开列,节省率单独算。
// C Runner 的人工分钟必须包含转人工,否则整张账会好看得多,也会错得多。

import { HOUR_CENTS, byKey, type Profile } from "../cases.ts";
import { add, format as formatMoney, sub, type Cents } from "../core/money.ts";
import { divide, formatBps } from "../core/rate.ts";
import { fail, ok, type Result } from "../core/result.ts";

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

/** 人工分钟拆成审改/审计与转人工,C 的 4.04 分钟必须能加出来。 */
export type HumanBreakdown = {
  readonly reviewMinutes: number;
  readonly handoffMinutes: number;
};

export const HUMAN_BREAKDOWN: Record<CaseKey, HumanBreakdown> = {
  A: { reviewMinutes: 0.75, handoffMinutes: 0 },
  B: { reviewMinutes: 96, handoffMinutes: 0 },
  C: { reviewMinutes: 0.96, handoffMinutes: 3.08 },
};

export function humanMinutesFor(key: CaseKey, includeHandoff = true): number {
  const breakdown = HUMAN_BREAKDOWN[key];
  return breakdown.reviewMinutes + (includeHandoff ? breakdown.handoffMinutes : 0);
}

export type MonthlyLedger = {
  readonly key: CaseKey;
  readonly monthlyTasks: number;
  readonly humanHours: number;
  readonly humanCents: Cents;
  readonly systemCents: Cents;
  readonly maintenanceCents: Cents;
  readonly totalCents: Cents;
  readonly baselineCents: Cents;
  readonly savingCents: Cents;
  readonly savingBps: number;
};

export function ledgerFor(profile: Profile, humanMinutes: number): MonthlyLedger {
  const humanHours = (profile.monthlyTasks * humanMinutes) / 60;
  const humanCents = Math.round(humanHours * HOUR_CENTS);
  const systemCents = Math.round(
    profile.monthlyTasks * (profile.modelCents + profile.infraCents),
  );
  const totalCents = add(add(humanCents, systemCents), profile.maintenanceCents);
  const baselineHours = (profile.monthlyTasks * profile.manualMinutes) / 60;
  const baselineCents = Math.round(baselineHours * HOUR_CENTS);
  const savingCents = sub(baselineCents, totalCents);
  return {
    key: profile.key,
    monthlyTasks: profile.monthlyTasks,
    humanHours,
    humanCents,
    systemCents,
    maintenanceCents: profile.maintenanceCents,
    totalCents,
    baselineCents,
    savingCents,
    savingBps: divide(savingCents, baselineCents),
  };
}

export function caseLedger(key: CaseKey, includeHandoff = true): MonthlyLedger {
  return ledgerFor(byKey(key), humanMinutesFor(key, includeHandoff));
}

export const EXPECTED_TOTAL_CENTS: Record<CaseKey, Cents> = {
  A: 1_154_880,
  B: 3_168_192,
  C: 3_121_440,
};

export const RUNNER_WITHOUT_HANDOFF_CENTS: Cents = 1_088_640;

// 用 Result 回报对账结果:对不上就是错误,不允许静默打印一个好看的数。
export function verifyAgainstBible(
  key: CaseKey,
  includeHandoff = true,
): Result<MonthlyLedger> {
  if (!includeHandoff && key !== "C") {
    return fail(`handoff omission is only defined for C, got ${key}`);
  }
  const ledger = caseLedger(key, includeHandoff);
  const expected = includeHandoff ? EXPECTED_TOTAL_CENTS[key] : RUNNER_WITHOUT_HANDOFF_CENTS;
  if (ledger.totalCents !== expected) {
    return fail(`${key}: total ${ledger.totalCents} != expected ${expected}`);
  }
  return ok(ledger);
}

export function formatLedgerRow(ledger: MonthlyLedger): string {
  return [
    ledger.key,
    String(ledger.monthlyTasks),
    `${ledger.humanHours.toFixed(1)} h`,
    formatMoney(ledger.humanCents),
    formatMoney(ledger.systemCents),
    formatMoney(ledger.maintenanceCents),
    formatMoney(ledger.totalCents),
    formatMoney(ledger.savingCents),
    formatBps(ledger.savingBps),
  ].join(" | ");
}

export function formatLedgerTable(): string {
  const header = "case | tasks | human h | human | system | maint | total | saved | rate";
  const rows = (["A", "B", "C"] as const).map((key) => formatLedgerRow(caseLedger(key)));
  return [header, ...rows].join("\n");
}

export function formatHandoffComparison(): string {
  const withHandoff = caseLedger("C", true);
  const without = caseLedger("C", false);
  const gap = without.savingBps - withHandoff.savingBps;
  return [
    `with-handoff: ${formatMoney(withHandoff.totalCents)} ${formatBps(withHandoff.savingBps)}`,
    `without-handoff: ${formatMoney(without.totalCents)} ${formatBps(without.savingBps)}`,
    `gap: ${(gap / 100).toFixed(1)} pp`,
  ].join("\n");
}

ledgerFor 接收一个 Profile 和一个 humanMinutes,所以它既能算正确口径,也能算错误口径。人工小时、人工成本、系统成本、维护、总成本、原人工成本、节省额、节省率都在一个结构里,任何一个字段对不上,verifyAgainstBible 就返回 fail。

humanMinutesFor 把 C 的 4.04 拆成 0.96 与 3.08,includeHandoff 为 false 时只保留 0.96。这个函数是整张表的入口,测试里同时断言 4.04、0.96 和 3.08 三个值,防止有人把 3.08 悄悄并进 0.96。

formatLedgerTable 输出四行:表头加三个案例。formatHandoffComparison 输出正确版、错误版和 17.1 个百分点的差额。两个格式化函数都只负责展示,不参与计算,避免「打印时顺手改一个数」这类事故。

verifyAgainstBible 里有一个边界:非 C 案例不允许关闭转人工。A 和 B 本来就没有转人工,传 false 不会得到更低的成本,只会得到同一个数;允许这种调用会让「漏算」看起来像是通用能力,所以模型直接返回 fail。

从对账结果能读出什么

对账不只是为了证明数字没算错,它能回答三个产品问题。

第一,节省率的排序和系统成本的排序不一致。 A 的节省率 75.0% 最高,B 是 58.5%,C 是 73.7%。但 C 的月节省绝对额 87,585.6 美元最大,是 A 的 2.5 倍。节省率适合比较流程效率,绝对额适合比较业务价值;产品组合决策要同时看两个尺度。

第二,维护摊销是持续成本,不是一次性投入。 A 每月 1,200 美元、B 2,400 美元、C 3,600 美元,三家都超过了各自的系统成本。这意味着 Agent 上线后,预算的大头在评测、规则和标注,而不是模型调用。把维护当成一次性项目费用,第二年就会低估成本。

第三,人工口径的敏感度远高于系统成本。 C 的系统成本只占原人工的 0.80%,但人工从 4.04 改到 0.96,节省率就跳了 17.1 个百分点。任何成本汇报,先确认人工口径,再讨论模型价格;顺序反过来,会在一个不影响结论的变量上花掉大部分时间。

这三个结论也解释了为什么本卷把任务度量放在收口之前:如果任务量、人工基线、接管成本没有定清楚,后面的成本模型只能算出一个好看的数,不能算出一个能用来决策的数。

小结

  • 人工账先拆两段:审改或审计,加转人工;C 的 4.04 分钟 = 0.96 + 3.08。
  • 三案例月总成本分别是 11,548.8、31,681.92、31,214.4 美元,与事实表逐项一致。
  • 系统成本占原人工 0.97%、0.25%、0.80%,维护摊销反而是成本主体。
  • 漏算转人工会让 C 的月总成本从 31,214.4 掉到 10,886.4,节省率从 73.7% 升到 90.8%。
  • 17.1 个百分点的差额全部来自 3.08 分钟转人工,不是模型价格或基础设施。
  • 对账要用 Result 显式返回失败,不能只打印一行好看的汇总。
  • 节省率排序与节省绝对额排序不一致,产品决策要同时看两个尺度。
  • 人工口径的敏感度远高于系统成本,汇报时先固定人工,再讨论模型。

阅读导航:上一节:12.2 指标陷阱:平均值、分母变化与幸存者偏差 · 下一节:13.1 三案例任务定义基线 。

常见错误与边界

  1. 把机器时间算进人工。 C 的 2.4 分钟是 Agent 执行时间,不是人花的时间;人花的是 4.04 分钟,两者相加才是 6.44 分钟的总耗时。
  2. 把转人工并进审计。 0.96 分钟是 8% 抽检乘 12 分钟,3.08 分钟是 22% 转人工乘 14 分钟;合并会掩盖转人工的真实成本。
  3. 用月总成本做节省率的分母。 分母必须是原人工月成本,否则 31,214.4 除以 31,214.4 会得到 0% 的荒谬结果。
  4. 把维护摊销当成一次性费用。 三家的维护都按月计入;去掉维护,A 的节省率会虚高,B 和 C 也会。
  5. 只保留正确版本,不保留错误版本。 错误版本是反例,必须能被测试固定;否则下一次汇报可能重新发明同一个错误。
  6. 用格式化后的数反推原始数。 1.6 小时是展示值,按月人工小时反推会得到 969.6;用 1.6035 会得到 971.7。对账要用原始值,展示才用舍入值。

这一章把「怎么算」讲完了。下一章把三案例的任务定义收成一张基线表,再用 15 项评审检查每一行是否站得住。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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