Session 21: cost and latency — where the money and the milliseconds go

Agent 的成本和响应时间,通常比普通业务接口更难控制。一次任务可能调用多次 LLM,执行若干 Tool,反复读取上下文,还可能因为结果不理想而继续搜索、重试或重新规划。

Originally in ChineseThis article was written in Chinese. The body below is the Chinese original; the English translation is not available yet.

如果只关注单次模型调用的价格,很容易忽略整个任务的实际成本。一个便宜的模型,如果需要反复调用十几次才能完成任务,最终花费未必低;一个响应很快的 Tool,如果返回大量无关信息,反而可能增加后续模型调用的成本。

优化 Agent,需要从整个任务的执行过程来看:哪些步骤消耗了时间和 Token,哪些工作可以减少、复用或并行执行,以及哪些优化会影响最终质量。

1. Agent 的成本和延迟来自哪里

先把一次 Research Agent 任务拆开:

text
用户提出研究主题
    ↓
LLM 分析任务、生成搜索计划
    ↓
调用搜索 Tool
    ↓
读取和整理搜索结果
    ↓
LLM 分析资料、提取证据
    ↓
检查证据是否充分
    ├── 不充分 → 继续搜索、补充分析
    └── 充分 → 生成研究报告
    ↓
返回结果

这条链路中的每一步都可能产生开销。

开销来源 主要成本 对延迟的影响
LLM 调用 输入 Token、输出 Token、模型计费 网络等待与模型推理
Tool 调用 API 费用、搜索服务费用、数据库资源 外部服务响应时间
上下文处理 重复传递历史消息、检索资料和工具说明 输入越大,通常处理时间越长
多轮循环 重复搜索、反思、规划和生成 多次串行调用累积延迟
重试与降级 额外请求、切换模型或服务 故障期间延迟增加
数据处理 文档解析、Embedding、排序、格式转换 取决于数据规模与实现方式

这里需要区分两个指标。

成本主要衡量完成一次任务消耗了多少资源,例如模型费用、外部 API 费用和服务器资源。

延迟衡量用户等待多久才能得到结果。一次任务即使只调用了两次模型,如果每次都需要等待较长时间,整体体验也可能不好。

两者经常有关联,但并不总是同步变化。并行调用可能缩短延迟,却增加瞬时资源消耗;换用更快的模型可能降低延迟,却增加单次调用成本。

2. 减少 LLM 调用次数

这是最直接的优化方向之一。

假设一个 Agent 的执行过程如下:

text
调用模型:分析用户需求
调用模型:制定搜索计划
调用模型:决定是否调用搜索工具
调用模型:总结搜索结果
调用模型:反思总结是否充分
调用模型:修改总结
调用模型:生成最终报告

七次模型调用未必都有必要。尤其是当流程比较固定时,一部分决策可以由程序完成。

2.1 固定流程交给程序

例如,Research Agent 的流程是搜索资料、提取证据、检查证据是否充分,最后生成报告。

如果每次都让 LLM 决定下一步执行哪个固定步骤,就会增加额外调用。可以把流程定义在程序中,让 LLM 负责需要语言理解和推理的部分。

text
def research(topic: str):    search_results = search_web(topic)    documents = parse_documents(search_results)    evidence = extract_evidence(documents)    if not enough_evidence(evidence):        extra_results = search_web(            build_followup_queries(evidence)        )        documents.extend(parse_documents(extra_results))        evidence = extract_evidence(documents)    return generate_report(topic, evidence)

这个示例中的 enough_evidence() 可以是程序规则,也可以结合模型判断。重点在于,固定的步骤顺序不必每次都通过模型重新决定。

实际的研究任务可能需要多轮搜索,因此不能把所有流程都写死。可以由程序控制循环次数和流程边界,由 LLM 在必要时生成补充搜索词、判断证据缺口或调整搜索方向。

优化的关键是明确职责:程序负责确定性控制,LLM 负责需要模型能力的判断和生成。

2.2 合并不必要的模型调用

有些步骤可以合并处理。例如,原本先让模型提取资料要点,再调用一次模型将要点转换成结构化 JSON。如果两步的输入、输出和质量要求允许,可以尝试让一次调用同时完成提取和结构化输出。

不过,合并调用也有边界。任务越复杂,提示词可能越长,输出格式也可能越难控制。如果某个中间步骤需要人工确认、独立重试或单独缓存,拆分节点反而更合适。

因此,不能只追求模型调用次数最少。更合理的做法是去掉没有实际价值的调用,同时保留有明确职责和独立价值的步骤。

3. 控制 Token 消耗

Agent 的上下文会随着任务推进逐渐增长。历史对话、Tool 返回结果、检索到的文档、之前生成的分析内容,都可能被继续传给模型。

如果每一轮都把完整历史重新传入,成本和延迟就可能不断增加。

3.1 不要把所有 Tool 返回结果原样交给 LLM

假设搜索 Tool 返回了 20 篇网页,每篇网页有几千字。如果把所有内容一次性塞进上下文,不仅输入 Token 很多,模型还需要从大量资料中筛选真正有用的信息。

可以先在程序中处理数据:

  • 去除重复 URL 和重复内容;
  • 清理导航栏、广告、页脚等无关文本;
  • 限制每篇文档的最大长度;
  • 根据主题筛选相关段落;
  • 为资料保留来源、发布时间和引用位置;
  • 只把与当前任务有关的证据传给模型。

例如:

text
def prepare_evidence(documents, max_items=8):    documents = deduplicate_documents(documents)    documents = filter_relevant_documents(documents)    documents = sorted(        documents,        key=lambda item: item["relevance"],        reverse=True,    )    return [        {            "title": doc["title"],            "url": doc["url"],            "published_at": doc.get("published_at"),            "evidence": doc["relevant_excerpt"],        }        for doc in documents[:max_items]    ]

这段代码展示的是处理思路。实际排序可以使用搜索分数、关键词匹配、Embedding 相似度或重排序模型。需要注意,相关性最高的几篇资料不一定能覆盖所有关键观点,因此不能单纯按数量截断,还要检查来源多样性和证据覆盖情况。

3.2 让模型看到任务所需的上下文

前面的 Context Engineering 和 Agent Context Optimization 已经讨论过上下文管理。这里关注它对成本的影响。

Agent 的状态中可能保存着完整的执行历史,但下一次模型调用不一定需要读取全部历史。程序可以维护结构化任务状态,例如:

text
state = {    "topic": "Agent 缓存策略",    "search_queries": [        "LLM response caching",        "agent tool result cache",    ],    "evidence_summary": "...",    "missing_evidence": [        "缓存失效机制",    ],    "retry_count": 1,}

下一轮调用时,根据当前节点的职责,只组装所需字段。搜索节点可能只需要主题、已有搜索词和证据缺口;报告节点则需要经过筛选的证据、引用信息和报告结构。

这可以减少重复传输的 Token,也能降低无关信息干扰模型判断的风险。

3.3 摘要不能代替所有原始证据

上下文压缩常见的做法是把长历史总结成一段短摘要。但摘要可能丢失精确数字、限定条件、来源链接和相互矛盾的证据。

对于 Research Agent,适合压缩的是执行过程和阶段性结论;需要引用的原始证据、数据出处和关键细节应该保留,必要时可以重新检索。

否则,虽然 Token 降低了,最终报告却可能出现事实不准确、引用不完整的问题。

4. 选择合适的模型

不同模型在能力、价格、速度、上下文长度和工具调用表现上有差异。所有任务都使用同一个高成本模型,往往不是最经济的方案。

4.1 按任务复杂度分配模型

例如,Research Agent 可以按任务类型选择模型:

任务 可以优先考虑的模型类型 需要关注的指标
查询改写、关键词提取 低成本、低延迟模型 关键词质量、响应时间
简单分类、格式转换 小模型或专用模型 准确率、格式合规率
复杂证据分析 推理和综合能力较强的模型 事实准确性、证据覆盖
长篇研究报告 长上下文与生成质量较好的模型 结构、连贯性、引用准确性
关键结果复核 与主模型互补的模型或确定性校验程序 错误检出率、额外成本

这里的“小模型做简单任务,大模型做复杂任务”只是初始策略,最终需要根据真实任务评估。某个小模型如果频繁产生错误,导致大量重试或人工修复,总成本可能更高。

4.2 什么时候应该切换模型

可以根据任务属性路由:

text
def choose_model(task):    if task["type"] in {"classification", "query_rewrite"}:        return "low_cost_model"    if task["requires_complex_reasoning"]:        return "strong_reasoning_model"    return "default_model"

这是基于任务特征的模型路由。实际系统还可能考虑上下文长度、工具调用能力、结构化输出支持、服务可用性、延迟预算和数据合规要求。

还要区分模型路由和故障降级。模型路由是根据任务选择合适的模型;故障降级则是在首选模型超时、限流或不可用时,切换到备用模型或其他处理路径。两者的触发条件不同。

切换模型也不意味着一定能无缝继续。不同模型可能使用不同的 API 格式、工具调用协议或输出能力,需要由统一的 Model Client 层处理差异。

5. 并行执行:缩短等待时间

Agent 的流程中,有些任务之间没有依赖关系,可以并行执行。

假设 Research Agent 需要搜索三个相对独立的方向:

text
┌─ 搜索方向 A ─┐
研究主题 ─────────├─ 搜索方向 B ─┼─ 汇总资料
                  └─ 搜索方向 C ─┘

如果三个搜索请求分别需要 2 秒,串行执行可能需要约 6 秒;在外部服务延迟相近、资源足够且没有额外排队的情况下,并行执行有机会把等待时间降到接近 2 秒,再加上汇总开销。

Python 中可以使用 asyncio 并发发起独立的 I/O 请求:

text
import asyncioasync def search_all(queries):    tasks = [        search_web_async(query)        for query in queries    ]    return await asyncio.gather(*tasks)

实际代码还应设置超时、并发上限和错误处理,避免一次任务发起过多请求,给外部服务或自己的服务器带来压力。

并行化主要减少的是关键路径上的等待时间,不一定降低总成本。三个请求同时执行,依然消耗了三个请求的资源。如果并行的是模型调用,还可能增加瞬时 Token 用量、并发配额占用和费用。

另外,并非所有步骤都能并行。必须先得到搜索结果才能分析证据;必须知道证据是否充分,才能决定是否补充搜索。对有数据依赖的步骤强行并行,可能造成重复工作或使用不完整的状态。

6. 缓存:避免重复计算

缓存机制已经在 Session 20 中展开讨论,这里只看它对成本和延迟的影响。

适合考虑缓存的内容包括:

  • 相同参数下的数据库查询结果;
  • 可复用的 Tool 返回值;
  • 同一份文档的解析结果和 Embedding;
  • 满足严格复用条件的 LLM 输出;
  • 模型服务商支持的 Prompt Caching。

例如,一份研究资料被多次使用时,可以缓存解析结果和向量,避免反复解析和计算。对于短时间内重复执行的相同搜索,也可以在时效允许的情况下复用搜索结果。

但缓存会带来额外问题:数据失效、权限隔离、缓存键设计和一致性。如果缓存返回了过期结果,省下的计算成本可能换来错误的研究结论。

Prompt Caching 也要单独理解。它通常由模型服务商复用重复输入前缀的处理结果,并不意味着模型的完整回答可以直接复用。具体支持条件、费用和有效期取决于服务商。

7. 控制循环、重试和反思成本

Agent 能自主规划和反思,也可能因此产生大量额外调用。

例如,模型不断认为研究资料不足,持续生成新的搜索词;或者生成报告后反复反思、修改,却没有明显改善结果。此时需要程序提供执行边界。

7.1 设置明确的执行预算

可以为一次任务定义预算:

text
budget = {    "max_llm_calls": 12,    "max_search_calls": 8,    "max_retries": 2,    "max_duration_seconds": 120,}

实际执行时,需要在每次调用前检查预算,并记录已经消耗的资源。超过限制后,可以终止任务、返回阶段性结果,或者请求人工介入。

除了调用次数,还可以考虑输入与输出 Token 总量、累计费用、运行时间和外部 API 配额。仅设置最大循环次数不一定够,因为单次调用本身也可能非常昂贵。

预算数值应该根据任务类型、质量要求和实际运行数据设定,而不是所有 Agent 都使用同一组固定限制。

7.2 重试应该有上限

模型 API 或 Tool 调用可能因为超时、限流、网络故障而失败。程序可以根据错误类型执行有限次数的重试,并采用退避策略,避免持续高频请求。

但重试不应该对所有错误一视同仁:

  • 临时网络错误或限流,可以在适当等待后重试;
  • 参数错误通常需要修正参数,不应原样反复发送;
  • 权限拒绝不能通过不断重试解决;
  • 有副作用的操作需要先确认执行状态,避免重复提交。

超过重试次数后,可以进入降级路径,或者把明确的错误信息交给 LLM,让它调整搜索策略、选择替代工具或生成部分结果。程序仍然负责限制后续执行,不能因为模型提出重试就无限循环。

7.3 反思要有明确目标

Reflection 可以帮助 Agent 检查遗漏、发现矛盾和修正错误,但每一次反思都可能带来额外的模型费用和延迟。

因此,反思应该对应具体检查目标,例如:

  • 是否覆盖了研究主题的关键方面;
  • 核心结论是否有可追溯的证据;
  • 引用是否支持对应的陈述;
  • 不同来源之间是否存在未解决的冲突。

能通过程序完成的检查,例如 JSON Schema 校验、必填字段检查、引用 URL 是否存在,就不必全部交给 LLM。

对于低风险任务,也不一定需要单独安排多轮反思。是否增加反思节点,应当看它能否带来足够的质量提升。

8. 流式输出:让用户更早看到结果

Agent 的完整任务可能需要几十秒甚至更久。如果必须等所有步骤结束后才返回内容,用户会觉得系统反应迟缓。

流式输出可以让用户更早看到模型生成的内容。例如,在报告生成过程中逐步输出文本,而不是等完整报告生成完毕再一次性返回。

不过,流式输出改善的是用户感知到的等待时间,不一定减少实际执行时间或模型费用。还要区分不同阶段:

  • 状态流: 告知用户当前正在搜索、分析资料或生成报告;
  • Token 流: 逐步展示模型生成的文本;
  • 任务结果流: 逐步返回已经完成的结构化结果或报告章节。

如果 Agent 需要先检索、校验事实再生成报告,可以先展示执行状态,等证据满足要求后再流式生成正文。这样可以避免过早展示未经校验的结论。

对于关键数据或高风险结果,最终输出仍然需要完整校验,不能因为采用了流式输出就跳过验证。

9. 如何判断优化是否有效

优化不能只看模型调用次数是否减少。调用少了,可能是模型偷懒、漏掉了必要步骤;响应快了,也可能是跳过了关键验证。

可以建立一组基本指标:

指标 用途
每个任务的 LLM 调用次数 观察是否存在不必要的模型调用
每个任务的输入与输出 Token 分析上下文和生成成本
每个任务的总成本 衡量整体经济性
平均延迟与 P95 延迟 观察一般情况和较慢请求的体验
Tool 调用次数及失败率 发现重复请求和外部依赖问题
重试次数与循环次数 判断故障和 Agent 是否存在失控倾向
任务完成率 检查优化后是否仍能完成任务
结果质量与引用准确率 防止性能优化损害输出质量

这里尤其要关注 P95 延迟。平均响应时间可能看起来很好,但少数任务因为长上下文、反复搜索或外部服务超时而拖得很久。P95 能帮助观察这些较慢请求的情况。

优化前后应尽量使用相同类型的任务进行对比,并同时记录成本、延迟和质量。否则,单纯比较平均耗时,很难判断优化是否真正有效。

10. 业界常见的优化方向

实际系统通常会组合多种方案,而不是依赖某一个技巧。

优化方向 常见实现 主要作用
模型选择 Model Routing、大小模型分工 控制模型调用成本
上下文管理 摘要、裁剪、按需检索 减少输入 Token
结果复用 Redis、结果缓存、Embedding 缓存 减少重复计算
Prompt Caching 使用模型服务商的缓存能力 降低重复前缀的处理开销
并行执行 asyncio、任务队列、并发 Tool 调用 缩短关键路径等待时间
流式输出 SSE、WebSocket 或框架支持的流式接口 改善用户感知的响应速度
执行预算 调用次数、Token、费用、超时和循环上限 控制失控任务的成本
监控与评估 Tracing、指标统计、离线评估 找到真正的性能瓶颈

这些方案有不同的适用范围。模型路由解决模型选择问题,缓存解决重复工作问题,并行执行解决可并行步骤的等待问题,上下文优化解决输入规模问题,预算控制则限制最坏情况下的资源消耗。

它们可以协同工作,但也可能互相影响。例如,并行调用缩短延迟,却可能增加瞬时并发;使用更小的模型降低单次费用,却可能提高重试次数;激进裁剪上下文减少 Token,却可能让模型丢失重要证据。

因此,每次优化都应该有明确的目标,并用运行数据验证结果。

11. 小结

Agent 的成本与延迟优化,可以从几个方向入手:减少不必要的 LLM 调用,控制上下文和 Token 消耗,按任务选择模型,并行执行相互独立的步骤,复用重复结果,同时限制重试、反思和循环的预算。

真正需要关注的是整个任务的成本,而不只是某一次模型调用的价格。一次任务调用更少的模型、消耗更少的 Token、减少无效 Tool 请求,确实有机会降低成本;但如果因此丢失证据、跳过必要校验,优化就失去了意义。

比较稳妥的做法是先通过监控找到最昂贵、最慢或最容易重复的步骤,再选择对应的优化手段,最后同时检查成本、延迟和结果质量。Agent 的性能优化是一项持续的工程工作,需要随着真实任务数据不断调整。

On this page