Together AI Blog

Making open models work for long-horizon agentic workloads

8.5内容质量

TL;DR · AI 摘要

长周期智能体工作负载需要优化模型推理效率,Together AI 和 Ollama 提出通过前缀缓存减少重复计算。

核心要点

  • 智能体每次请求都需发送完整对话历史,导致推理效率下降。
  • 前缀缓存可避免重复处理历史内容,显著提升性能。
  • Together AI 和 Ollama 分别从客户端和推理端优化缓存机制。

结构提纲

按章节快速跳转。

  1. 智能体工作负载需要优化模型推理效率,Together AI 和 Ollama 提出通过前缀缓存减少重复计算。

  2. 智能体每次请求都发送完整对话历史,导致输入序列长而输出序列短。

  3. GPU 推理分为预填充和解码两个阶段,智能体请求主要消耗在预填充阶段。

  4. 前缀缓存可避免重复处理历史内容,显著提升推理效率。

思维导图

用一张图看清主题之间的关系。

查看大纲文本(无障碍 / 无 JS 友好)
  • 优化智能体推理效率
    • 问题背景
      • 智能体请求流量模式
      • GPU 推理阶段
    • 解决方案
      • 前缀缓存机制
      • Together AI 与 Ollama 协作

金句 / Highlights

值得收藏与分享的关键句。

#AI#模型优化#推理效率#缓存机制
打开原文

使开源模型适用于长期代理工作负载

摘要

编码代理在每次交互时都会将整个对话重新发送一次。前缀缓存可以防止推理引擎重复执行这些工作,但前提是框架不修改提示的开头,并且引擎将每次交互返回到已经缓存了该内容的GPU上。Together AI和Ollama分别位于这一交接的两端,因此我们记录了客户端和推理引擎端各自需要执行的操作,以成功构建代理应用。

编码代理的流量模式非常特殊。每次代理执行一个步骤时,框架会将到目前为止的整个对话发送给模型:系统提示、每个工具的定义、你的请求、代理读取的每个文件以及代理运行的每个命令。返回的内容通常是一个长度为几十个标记的工具调用。然后,这个过程会再次发生,包括之前所有内容再加上一点新的内容。

这种长输入序列长度(ISL)和短输出序列长度(OSL)是大多数代理工作负载的特征。如果GPU在每次交互时都必须从头开始处理整个对话记录,那么长时间的会话将随着每一步的进行变得越来越慢和昂贵。前缀缓存可以节省大部分工作。问题是,如果不小心,也很容易破坏前缀缓存。

我们从问题的两端入手。Ollama负责框架集成,这意味着决定每个请求中包含哪些内容。Together AI负责推理引擎,这意味着决定请求到达时会发生什么。我们发现,我们在各自一侧的很多工作都是关于保护缓存免受另一侧可能对其造成的影响,因此我们希望在一个地方将所有这些内容记录下来,以帮助代理和基础设施构建者!

对GPU来说,代理的一次交互是什么样子

每个请求都经过两个阶段。第一个阶段是预填充:引擎通过一次大的并行处理读取整个提示,并生成第一个标记。GPU擅长这个过程,因为这是同时进行大量数学运算,从而最大化算术强度。预填充决定了在任何新标记出现之前需要等待多长时间。第二个阶段是解码:模型逐个标记地写出其余的回答,每个新标记都需要读取并关注它之前的所有内容。解码受内存带宽的限制比计算更多,并且决定了文本流出来的速度。

正常的聊天响应在两个阶段都会花费时间,而代理的一次交互主要在预填充阶段,因为输入是整个会话,而输出通常是一个简短的工具调用。推理模型在此基础上添加了思考标记,有时是很多,但随着会话增长到数万个标记,输入仍然占主导地位。每次交互,输入会变得更长,而输出的大小大致保持不变——几个工具调用。

因此,对于代理来说,“这个模型有多快?”基本上意味着“它能多快处理一段很长的历史记录?”快速处理包含大量先前交互的任务的方法就是缓存它,然后读取它,而不是重新计算。

最简单的方式是通过阅读来想象 KV 缓存(或者前缀缓存,也是一样的道理)。想象一下,如果你要读取页面上的每个新词,都必须从头开始读。你读得越往下,速度就越慢,因为你得不断重新阅读之前已经读过的内容。这就是没有缓存的模型。缓存可以在单个请求中解决这个问题:引擎会保留之前处理过的 token 的工作(以中间键值对的形式存储),并只计算新的部分。

前缀缓存则在多个请求之间实现同样的效果。代理会话的第 7 轮是第 6 轮加上一点额外的内容,所以如果引擎仍然保留第 6 轮的处理结果,它只需要处理新增的部分。

计算方式很简单。如果每一轮增加的量相同,没有缓存的情况下,10 轮处理的提示内容总量是 1 + 2 + … + 10 = 55 单位。而使用缓存的情况下,处理的总量是 10。在编程任务中,100 轮是常见的,此时处理的提示内容总量是 5050 对比 100。实际的轮次大小各不相同,所以将这些数字视为理想化数值。缓存会话也不是完全免费的,因为每个新 token 仍然需要关注已缓存的 token。但这个规律依然成立:没有缓存的情况下,你重复处理的工作量会随着会话长度的平方而增长。

需要注意的是,前缀缓存是从提示内容的开头匹配,直到第一个不同的 token,然后就停止了。在第一个不同点之后的所有内容都必须重新处理。

在提示内容末尾添加内容不会产生额外成本。而如果更改了任何更早的内容,即使只是一个字符,也意味着需要重新处理它之后的所有内容。如果更改发生在顶部附近,那么你实际上就相当于丢弃了整个会话,现在必须重新构建缓存。本文其余大部分内容都基于这个规则。

“Harness”决定了第一个更改的位置。引擎决定在下一个请求到来时缓存是否仍然存在。我们先从“Harness”开始。

Harness 和 API

在 Ollama 的一侧,我们通过 ollama launch 命令实现了连接你最喜欢的 Harness 的能力。因此,你可以通过像 Claude Code、Codex、Pi(以及更多)这样的 Harness,连接像 DeepSeek-V4.1-Flash 和 GLM-5.3 这样的开源模型,并保持你现有的工作流程。

将 Harness 连接到 API 可能看起来很简单,但 Harness 和模型之间存在许多层的翻译和不同的期望。这通常会导致缓存中断(产生时间和金钱成本)、无法解释的代理行为,甚至 Harness 直接报错。

晚期加载工具

目前,Harness 携带了相当多的工具。如果每个定义都提前放入提示内容中,你就会在任务永远不会使用的工具上浪费上下文空间,而模型也会变得更差,无法正确选择合适的工具。较新的 Harness 增加了一个工具搜索功能,以缓解这个问题,工具可以在代理搜索到它之后被加载和使用。

假设你有一个具有这种能力的个人助理作为代理。如果你让代理将你收藏的事件导出到日历中,它会搜索“日历”,加载 save_calendar 的定义,并调用它。

对于缓存来说,问题是这个定义应该放在哪里。

显而易见的方法是将定义添加到工具列表中。这确实可以工作,但工具列表位于提示的顶部,位于对话之前。因此,如果前缀发生变化,之后的所有内容在重新处理时都会受到影响。在长时间的会话中,这可能会涉及数十万的标记。更好的方法是将定义放在最后,因为新内容本来就会出现在那里。

不过,并非所有模型都支持这种方法。一些聊天模板并不期望在对话中间出现工具定义,这会导致调用失败。因此,是否可以在不支付额外费用的情况下延迟加载工具,取决于模型。用户不应该知道这一点,但任何构建工具架的人都需要了解。

顶部会变化的内容

破坏缓存最简单的方式是将一些在每次轮次中都会变化的内容放在系统提示中,比如当前时间戳、git状态,或者代理不断移动的工作目录。如果工具架在每次轮次中都用新的值重新渲染系统提示,那么每次轮次都需要重新读取整个内容。

对于会话中固定但会话之间不同的内容,比如用户的姓名或会话开始的日期,不会影响当前会话。但它们会阻止新的会话重用已经缓存的设置,这在引擎端会有涉及。不管怎样,解决方法都是一样的:将这些信息一次性放在任务消息中,并确保系统提示在所有地方都保持一致。

推理努力

我们在Ollama端遇到了这个问题。在GLM-5.3-Flash中,推理努力不是一个由引擎单独处理的独立设置。聊天模板将它写入了系统块的第一个部分,位于工具和对话之前。

假设你正在处理一个长时间的任务,但进展不顺利。你将努力程度从低提升到高。这是一件合理的事情,但下一次请求几乎在第一个标记处就与上一次请求不同。这意味着整个会话需要重新处理。在长时间运行的情况下,这可能会消耗数十万个标记来更改一个设置。

我们的建议是在开始时选择一个努力等级并保持不变。如果你确实需要更多的思考,通常以更高的设置启动一个新会话会比继续旧会话更便宜,而且你还能得到一个干净的上下文。你也可以在更改推理值之前进行压缩,以减少提示标记的数量。

大型工具结果

工具的输出会成为下一个请求的一部分,以及之后所有请求的一部分。如果代理在需要四十行时读取了一个3000行的文件,你不会只为此支付一次费用;你将在每次剩余的轮次中都为此支付费用(即使它被缓存了,你也会失去上下文窗口)。为了解决这个问题,工具架通常会削减工具的输出。这是正确的做法,但如何削减工具的输出却很重要。

这里有一个很容易无意中创建的失败案例。任务是修复日历导出中的时区错误。代理读取了calendar.py,工具返回了640行文件的前100行,但没有说明它已经停止。关键的函数convert_timezone位于第420行。模型完全不知道它遗漏了任何内容。

解决方法是在输出中添加一行,告诉模型它只得到了640行中的第1到第100行,并且它可以在文件中搜索或请求另一个范围。有了这个信息,模型会搜索“时区”,找到第420行,并读取第410到450行。削减输出可以节省费用。但在没有说明的情况下削减输出,会让你的模型自信地编辑它从未见过的代码。

子代理

像 Kimi K3、GLM-5.3 和 GLM-5.3-Flash 这样的开源模型现在在将大任务拆分并分发给子代理方面表现得相当不错。Harness 启动每个子代理的方式决定了它能重用父代理缓存的多少。

一种选择是让子代理继承一切内容:相同的系统提示、工具和对话,以及它的任务分配。侧边对话就是以这种方式工作的。它们从父会话中分支出来,因此整个前缀已经缓存好了。另一种选择是发送一个简要说明:相同的系统提示和工具,然后只发送子代理所需的文件和指令。在这种情况下,缓存只覆盖设置部分,不包括其他内容。

继承听起来似乎更好,但事实并非如此。一个缓存的前缀处理起来成本低,但不是免费的。子代理生成的每个 token 仍然需要读取它,并且它会一直占用 GPU 内存。一个需要两个文件和一个检查清单的审阅者可能并不需要三百轮的历史记录。而且,如果你给子代理它自己的系统提示,它与父代理之间就没有任何共享内容,甚至不包括设置。

引擎端

你可能已经完美地完成了上述所有内容,但仍然无法获得好处。缓存仍然需要存在,下一个请求也必须到达保存它的机器。

在 Together AI,我们认为推理引擎是一种让 GPU 始终忙碌的机器。单个 GPU 每年租赁成本约为 5 万美元,因此理想情况下它不应该处于空闲状态,任何时候它都应该为数百个用户服务,这些用户各自处于请求的不同阶段。代理流量以几种特定的方式对这些限制施加压力。

为最佳缓存命中路由请求

一个会话的缓存存在于特定数据中心的特定节点上。如果对话的下一轮落在其他地方,该节点必须从头开始处理所有之前的轮次,现在两个节点将存储相同的前缀。为了正确路由,我们首先需要选择一个运行模型、有容量并且是会话运行所在的数据中心。然后,我们需要选择该数据中心中拥有之前轮次缓存的节点。

选择节点主要有两种方式。一种是使用一个键:客户端在每次请求中发送类似 prompt_cache_key 的内容,然后理想情况下将相同键的请求路由到同一节点。另一种方式是哈希前缀,并将请求发送到缓存了最长匹配前缀的节点,即使该前缀是由另一个会话放置的。

第二种方式是保持系统提示一致的另一个原因。如果每个 harness 会话都以完全相同的系统提示和工具定义开始,一个新的会话可能能够找到已经缓存的设置。如果你在其中放入唯一的标识符,那么每个会话都保证从冷启动开始。

此外,也不总是将请求发送到热节点那么简单。有时热节点因流量过大而超载,此时的选择是在那里排队等待,还是使用一个空闲节点并支付处理前缀的费用。在这种负载感知的路由范式中,有时缓存未命中可能是更好的选择。因此,即使提示完全稳定,如果后端的推理引擎实现不正确,也无法保证命中。

在轮次之间保持缓存活跃

路由只有在仍有缓存可以路由时才有帮助。代理通常会调用一个工具,然后等待几分钟,直到测试运行完成。在整个过程中,将该会话的缓存保留在 GPU 内存中会占用活跃用户所需的内存空间,而丢弃缓存则意味着代理在从工具调用返回时需要重新读取所有内容。因此,我们也可以在会话空闲时将缓存卸载到 CPU 内存中,并在下一次操作时恢复它。

内存是所有这些限制背后的主要因素。我们无法提前知道一个响应是 30 个标记还是 30,000 个标记,因此我们不会为最坏情况下的最大上下文长度场景预留空间,而是像操作系统处理 RAM 一样,根据每个请求的需求,以小块的方式分配缓存内存(PagedAttention)。并且我们在每次处理时重建运行中的批次(连续批处理),这样当代理同时发出五个子代理时,每个新请求会在一个空闲的插槽中立即执行,而不是等待批次中最慢的那个完成。

对于任何构建接口的人来说,缓存内存的余量,而不是计算能力,通常是限制 GPU 一次能处理多少请求的主要因素。每一个过大尺寸的工具结果,以及每一个携带无关历史记录的子代理,都会占用本可以用于其他会话缓存的内存。

代理还会将预填充/解码的分割推向极限,使用非常大的提示和非常小的答案。为了更好地优化这一点,我们将这两个阶段分别在不同的集群上运行。一个集群专注于计算,负责预填充;另一个集群专注于内存带宽,可以同时为数百个流进行解码,缓存通过 RDMA 在它们之间传输。这样,一波长代理提示不会影响其他人的标记流速度。

综合来看:一个会话,两个方面

这就是所有这些在一个会话中看起来的样子。

在接口端,代理找到日历工具,并将其添加到对话的末尾,因此其上方的内容不会发生变化。它读取 calendar.py,发现只获取了 640 行中的 1 到 100 行,搜索“时区”,并读取正确的部分。努力仍然从它开始的地方继续。一个评审子代理继承会话,以检查 agenda.ics 与 sessions.json 的一致性。

在引擎端,每次交互都会回到缓存了该会话的节点。在测试运行期间,缓存等待在 CPU 内存中。评审的请求插入到运行中的批次中,每次交互只处理新的内容。

对于使用代理的人来说,这些都不可见;他们只是看到在第 90 次交互时仍然保持快速。但只有当双方都尽到自己的责任时,这一切才有效。一个接口可以保持提示完全稳定,但如果引擎将第 7 次交互发送到错误的机器,仍然会丢失缓存。一个引擎可以完美地进行路由,但如果接口在每次交互时都更改第一行,仍然会丢失缓存。

Parth 在 parthsareen.com 上撰写了更多关于构建代理的内容,Ollama 在 ollama.com/blog 上发布更新。你也可以在 https://www.together.ai/blog 上阅读并运行此处提到的开放模型。