《AI Agent 产品开发·任务定义与能力边界》4.2 上下文预算的产品决策

上下文预算不是把窗口塞满,而是决定系统、任务、历史、检索和输出各占多少。本节给出 A Relay 的 2,980 token 分配与裁剪顺序,说明为什么历史先砍、检索后砍、系统与当前任务不动,以及裁剪后必须怎样让用户看见,并给出可运行的预算模型。

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

上下文窗口变长之后,很多团队的第一反应是「那就多放一点」。但窗口再长也有上限,而且放得越多,模型越难分辨哪些是当前任务、哪些是历史噪声。上下文预算要回答的不是「最多能放多少」,而是「每一类内容各占多少,超出时先动谁」。

这是一个产品决策,不是工程参数。工程可以告诉你窗口有多大、压缩算法能省多少 token;产品必须决定:系统规则能不能被裁剪,当前任务能不能被摘要,历史记录保留多久,检索结果按什么顺序丢。每个决定都会改变用户在出错时看到的东西。

预算不是长度,是分配

先把上下文分成五段:系统规则、当前任务、历史、检索、输出预留。前三段决定模型看到什么,输出预留决定它能写多长。A Relay 的一次分诊调用用 2,800 个输入 token 和 180 个输出 token,可以拆成下面这张表。

段落内容token能否裁剪
系统分诊规则、队列定义、输出格式600否
当前任务本张工单的正文与字段900否
历史同一客户近期的工单与回复700是,先裁
检索知识库命中的相似工单600是,后裁
输出队列、优先级、模板编号的生成空间180否

五段相加是 2,980,其中 2,800 是输入,180 是输出。这个数字来自 A 的调用口径,不是拍脑袋的上限。不同任务的分配完全不同:B Quill 的一次报告生成是 45,000 输入加 4,200 输出,C Runner 的一次任务执行是 6,000 输入加 400 输出。拿 A 的分配去套 B,会把一份 12–20 页的报告压成摘要;拿 B 的分配去套 C,会让一次价格检查带上大量无关的历史文本。

分配的真正难点不在总量,而在比例。系统规则占得太少,模型会忘记输出格式;当前任务占得太少,它会漏掉工单里的关键字段;历史占得太多,它会把旧结论当成当前事实;输出预留太少,它会在写到一半时被截断。每一段都有一个「再少就不行」的下限,产品要先把这些下限标出来,再谈超出时怎么裁。

超出时先砍历史,再砍检索

裁剪顺序不是按 token 数量从大到小,而是按「删掉之后对当前判断的影响」排序。A Relay 的顺序是:先历史,后检索,系统、当前任务、输出预留不动。

为什么历史先砍?因为历史记录里大部分内容与当前工单只是弱相关。同一客户上个月的工单可能提到过类似问题,但当前工单的队列、优先级和首响模板,主要取决于这张工单本身和分诊规则。历史的价值是提供背景,不是提供结论;当预算不够时,背景可以让位。

为什么检索后砍?检索结果是按相关性召回的,前面几条通常直接支撑当前判断。砍检索要从尾部开始,先丢低相关的结果,而不是随机删。如果检索结果本身已经很少,再砍就会让模型失去判断依据,这时应该考虑降级:告诉用户「知识库没有足够匹配」,而不是硬答。

为什么系统和当前任务不动?系统规则定义了输出空间,删一条规则可能让模型给出一个不存在的队列;当前任务是判断对象,删一个字段可能让分诊直接错位。输出预留也不能动,它不是「多余的空间」,而是模型把判断写出来的地方;预留不足会让输出被截断,用户看到的是一条不完整的建议。

A 的一次分诊如果预算从 2,980 降到 2,500,差的 480 个 token 全部从历史里出,历史从 700 降到 220,检索仍然是 600。如果降到 2,100,差的 880 先吃完 700 历史,再从检索里拿 180,检索从 600 降到 420。如果再降到 1,500,历史和检索都砍到零仍然不够,因为系统、当前任务和输出三项加起来是 1,680。这时正确动作不是继续删,而是拒绝这次调用,要求用户缩短工单或拆分任务。

裁剪必须可见

裁剪最大的风险不是「少看了几段历史」,而是「用户不知道少看了」。模型仍然会给出一个看起来很确定的队列和优先级,用户会以为它看过了全部上下文。等分诊错了再复盘,才发现关键信息在裁剪时被丢掉了。

所以裁剪必须产生一个用户可见的信号。这个信号至少回答四件事:

  1. 裁了什么。 是历史、检索,还是两者都有;各裁掉多少 token 或多少条记录。
  2. 为什么裁。 是超出本次预算,还是某类内容本身过期、低相关。
  3. 怎么补看。 提供一个展开入口,让用户能看到被裁掉的内容,或者重新发起一次更聚焦的调用。
  4. 对结论有什么影响。 如果裁剪可能影响判断,要明确提示「本次建议未参考更早的工单」,而不是只显示一个技术性的 token 数字。

这四条不需要都塞进主界面。主界面可以只显示一句「已省略 12 条更早的工单」,点开后再看明细。关键是这句话必须出现,而且必须与本次调用真实发生的裁剪一致。不能所有调用都显示同一句模板提示,否则用户会很快学会忽略它。

裁剪可见还有一个组织作用:它让产品团队无法假装窗口无限。只要每次裁剪都被记录,团队就能看到哪些任务经常超预算、哪些段落经常被砍、砍完之后错误率有没有变化。这些记录是下一轮预算调整的依据,也是向业务解释「为什么这个任务需要更长的处理时间」的证据。

三个案例的预算口径

三个案例的 token 量级差异很大,但预算方法是一样的:先按段落分配,再定裁剪顺序,最后让裁剪可见。

案例输入 token输出 token合计主要段落
A Relay2,8001802,980工单正文、历史工单、知识库
B Quill45,0004,20049,200数据包、上月报告、模板
C Runner6,0004006,400商品目录、价格规则、任务上下文

B 的预算里,数据包和上月报告占了大头。它的裁剪顺序不能照抄 A:B 的历史是上月报告,删掉会直接影响同比分析;B 的检索是行业模板和相似报告,删掉通常只影响表达方式。所以 B 应该先裁低相关的参考报告,再考虑压缩上月报告,而不是一上来就把历史清空。

C 的预算最小,但它的裁剪最危险。C 的任务是执行,价格规则和库存快照属于当前判断依据,不能因为预算不够就省略;历史任务记录可以压缩,但不能丢掉「这个商品上次为什么被下架」这类因果信息。C 的裁剪如果不可见,用户看到的是一个执行结果,却不知道 Agent 当时少了哪条规则。

预算之外:先问任务能不能拆

当保护段已经到下限仍然装不下,最容易被忽略的选项是拆任务。A 的工单如果正文特别长,可以让 Agent 先做队列和优先级,再用第二次调用生成首响模板;两次调用的预算各自独立,比一次硬塞更可靠。B 的报告如果数据包太大,可以按章节拆分,先写摘要和运营回顾,再写财务部分;C 的价格检查如果规则太多,可以先筛出异常商品,再对异常项做完整判断。

拆分不是把同一个任务重复做两遍。它要求每一段都有独立的输入、输出和验收,并且能把结果合并。拆得不好,会出现两个问题:一是上下文在两次调用之间丢失,二是两次输出互相矛盾。所以拆分前要先定义合并规则,比如以第二次的模板编号覆盖第一次的占位值,或者以财务章节的数字为准回填摘要。

拆任务还有组织成本:用户要多确认一次。A 的人工确认是 0.75 分钟一单,拆成两次可能增加确认时间;B 的审改是 1.6 小时一份,拆成章节后可以并行审改,但合并需要额外时间。产品要判断的是:多出来的确认成本,是否小于硬塞导致的错误成本。这个判断没有统一答案,但必须显式做,不能假装窗口无限。

预算评审的五个问题

预算方案上会时,不需要先看技术实现,先回答五个问题:

  1. 五段各占多少,哪几段是保护段?
  2. 超出时按什么顺序裁,裁到哪一段停止?
  3. 裁剪后用户看到什么,能否展开被裁掉的内容?
  4. 保护段到下限仍超预算时,是拒绝、拆分还是降级?
  5. 裁剪记录是否进入评测,能否回答「裁剪后错误率有没有变化」?

五个问题里,第四个最容易被跳过。团队通常愿意讨论「怎么裁」,不愿意讨论「裁不动怎么办」,因为后者意味着要拒绝用户或改变任务边界。但正是这个决定,区分了「有预算意识的产品」和「把窗口当无限的团队」。

把预算写成可运行的模型

下面这个模型把分配、裁剪顺序、保护段和可见提示做成一次计算。输入是一份预算和上限,输出是裁剪后的分配、裁剪事件和一句可以直接展示给用户的提示。

// file: src/task/04-2-context-budget.ts
// tier: L2
// verify: node --test test/task/04-2-context-budget.test.ts

// 上下文预算:先分配,再裁剪,裁剪必须可见。
// 裁剪顺序固定为历史 -> 检索;系统规则、当前任务、输出预留不动。

export type Segment = "system" | "task" | "history" | "retrieval" | "output";

export type Budget = Record<Segment, number>;

export const SEGMENTS: readonly Segment[] = [
  "system",
  "task",
  "history",
  "retrieval",
  "output",
];

export const TRIM_ORDER: readonly Segment[] = ["history", "retrieval"];

export const PROTECTED: readonly Segment[] = ["system", "task", "output"];

// A Relay:2,800 input tokens + 180 output tokens。
export const RELAY_BUDGET: Budget = {
  system: 600,
  task: 900,
  history: 700,
  retrieval: 600,
  output: 180,
};

// B Quill:45,000 input tokens + 4,200 output tokens。
export const QUILL_BUDGET: Budget = {
  system: 2_000,
  task: 3_000,
  history: 9_000,
  retrieval: 31_000,
  output: 4_200,
};

// C Runner:6,000 input tokens + 400 output tokens。
export const RUNNER_BUDGET: Budget = {
  system: 800,
  task: 1_200,
  history: 600,
  retrieval: 3_400,
  output: 400,
};

export function total(budget: Budget): number {
  return SEGMENTS.reduce((sum, segment) => sum + budget[segment], 0);
}

export type TrimEvent = {
  readonly segment: Segment;
  readonly removed: number;
};

export type FitResult = {
  readonly ok: boolean;
  readonly used: number;
  readonly overBy: number;
  readonly allocations: Budget;
  readonly trimmed: readonly TrimEvent[];
  readonly notice: string | null;
};

export function trimNotice(trimmed: readonly TrimEvent[]): string | null {
  if (trimmed.length === 0) return null;
  const parts = trimmed.map((item) => `${item.segment} ${item.removed} tokens`);
  return `Context trimmed: ${parts.join(", ")}. Open the source panel to see what was left out.`;
}

export function fitBudget(
  requested: Budget,
  limit: number,
  order: readonly Segment[] = TRIM_ORDER,
): FitResult {
  const allocations: Budget = { ...requested };
  let used = total(allocations);
  const trimmed: TrimEvent[] = [];
  for (const segment of order) {
    if (used <= limit) break;
    const cut = Math.min(allocations[segment], used - limit);
    if (cut > 0) {
      allocations[segment] -= cut;
      used -= cut;
      trimmed.push({ segment, removed: cut });
    }
  }
  return {
    ok: used <= limit,
    used,
    overBy: Math.max(0, used - limit),
    allocations,
    trimmed,
    notice: trimNotice(trimmed),
  };
}

export function protectedIntact(requested: Budget, fitted: Budget): boolean {
  return PROTECTED.every((segment) => requested[segment] === fitted[segment]);
}

fitBudget 只按给定顺序裁剪,不碰保护段。它的返回值里,ok 表示这次调用能否在上限内完成;overBy 表示即使裁完还差多少;trimmed 记录每一段被删掉多少;notice 是给用户看的提示。protectedIntact 是一个独立检查,用来确认系统、当前任务和输出预留没有被误伤。

这个模型故意不实现「自动摘要」。摘要看起来能省 token,但它会引入一个新的失真层:用户不知道摘要把哪句话删了,也不知道摘要本身是否准确。对 A 的分诊任务来说,历史工单可以被整段省略,但不应该被摘要成一句「客户之前也有类似问题」,因为这句话可能把一次具体的升级投诉变成一次普通咨询。

模型也不决定「裁到多少算合理」。这个判断属于产品:A 的历史从 700 降到 220 之后,分诊质量是否还能接受?B 的上月报告压缩多少会开始影响同比?C 的历史记录能不能整段省略?这些问题需要用小规模评测回答,不能只靠 token 数拍板。

预算模型的价值不是给出一个精确到 token 的答案,而是把「超出时怎么办」从运行时即兴决定变成产品可以评审的规则。模型跑出来的数字会随任务变化,但裁剪顺序、保护段和可见提示应该保持稳定。稳定不是说永远不改,而是每次修改都要有记录、有评测、有对应的用户提示更新,而不是某次上线时悄悄换掉。

预算的调整周期也要写进产品。任务量、数据源和用户行为都会变化,今天合适的分配半年后可能已经偏了。建议把预算评审和任务规格评审放在同一个节奏里:任务边界变了,输入清单和预算分配一起复核;只改模型或只改提示词,不改预算,通常会让裁剪行为在不知不觉中改变。用户看到的裁剪提示、评测里记录的错误率,都应该跟着预算版本走,而不是散落在各次发布里。

另一个常见问题是预算只按平均值设计。A 的工单大多很短,但少数长工单会占掉大量历史空间;如果预算按平均工单设计,这些长工单每次都会触发裁剪。产品要为长尾留出降级路径,而不是让平均值掩盖尾部。

预算评审也不应该只看 token。裁剪之后用户是否还能完成任务、审改时间是否变长、错误率是否上升,才是预算是否合理的最终判据。token 只是中间变量,不是产品指标。

小结

  • 上下文预算不是窗口长度,而是系统、任务、历史、检索、输出五段的分配。
  • A Relay 的一次分诊是 2,800 输入加 180 输出,合计 2,980;不同案例的分配不能互相套用。
  • 裁剪顺序按「删掉之后对当前判断的影响」排:先历史,后检索,系统、当前任务、输出预留不动。
  • 历史是背景,不是结论;预算不够时可以让位,但不能用摘要把具体事实压成一句模糊描述。
  • 检索从尾部开始丢,先丢低相关结果;检索本身不足时应降级说明,而不是硬答。
  • 保护段被裁到下限仍然超预算时,正确动作是拒绝调用或拆分任务,不是继续删。
  • 裁剪必须可见:裁了什么、为什么裁、怎么补看、对结论有什么影响,四个问题至少回答前三个。
  • B 和 C 的预算量级不同,裁剪顺序也不同;照抄 A 的顺序会破坏它们各自的关键判断依据。

阅读导航:上一节:4.1 输入清单:用户给、系统给、不许用 · 下一节:4.3 过期数据与冲突数据的处理口径 。

常见错误与边界

  1. 把预算当成窗口上限。 窗口上限是工程约束,预算分配是产品决策;只知道上限,不知道每段占多少,超出时只能乱砍。
  2. 按 token 数量从大到小裁。 大不等于可删;历史往往最大,但也最该先删,而当前任务很小却不能动。
  3. 裁完不告诉用户。 用户会以为模型看过了全部上下文,错误归因会完全错位;裁剪提示必须与真实裁剪一致。
  4. 用摘要替代整段省略。 摘要会引入新的失真层,尤其不适合把具体投诉、具体价格压成一句概括。
  5. 保护段被裁到零还继续硬跑。 系统规则和当前任务被删后,输出空间已经不存在,继续调用只会产生更不可靠的结果。
  6. 三个案例共用一套比例。 A 的分诊、B 的报告、C 的执行,关键判断依据不同,裁剪顺序必须分别设计。

这一节回答「装不下时砍什么」。下一节要回答另一个更隐蔽的问题:装得下,但数据已经过期或互相冲突时,Agent 该怎么办。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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