Parallel-Synthesis：让 LLM 综合智能体直接消费并行分支的 KV 缓存

笔记日期： 2026-06-15 笔记作者： Zhongzhu Zhou 论文标题： Towards Direct Latent-Space Synthesis for Parallel Branches in LLM-Agent Workflows 作者： Shikun Liu 等（Georgia Institute of Technology, Meta） arXiv： 2606.14672 状态： 预印本，2026 年 6 月

一句话总结

多智能体系统中，并行 Worker LLM 各自生成候选结果后，综合智能体（Synthesizer）现在需要把这些结果拼成长文本再重新预填充——白白浪费了 Worker 解码时已经算好的 KV 缓存。Parallel-Synthesis 让 Synthesizer 直接消费这些 KV 缓存，通过位置重编码 + 可学习缓存映射器 + LoRA 适配器三件套来弥合分支之间的位置和分布偏移，在九个基准上与文本拼接基准相当或更优，首 token 延迟降低 2.5–11 倍。

前置知识

本篇笔记涉及多个技术模块。如果你对 Transformer 推理流程有基本了解，但对 KV 缓存机制、旋转位置编码、LoRA 适配以及多智能体框架还不太熟悉，请先看这一节。

Transformer 自注意力与 KV 缓存

Transformer 解码器每次只生成一个 token。在时刻 $t$，模型用当前 token 的查询向量 $Q_t$ 对之前所有 token 的键值做注意力：

$$\text{Attn}(Q_t, K_{1:t}, V_{1:t}) = \text{softmax}\!\left(\frac{Q_t K_{1:t}^T}{\sqrt{d_k}}\right) V_{1:t} \tag{1}$$

如果每步都重新计算所有 $K$、$V$，计算量和序列长度成平方关系。KV 缓存的解决方案很直接：把每一层、每一步生成的 $K_t$、$V_t$ 存起来，下一步直接追加新的 $K_{t+1}$、$V_{t+1}$ 并复用历史缓存——这样每步推理的注意力计算量和序列长度是线性关系，而不是平方。

具体来说，当一个 Worker 智能体在上下文 $c$ 的条件下解码输出序列 $z = (z_1, \ldots, z_{|z|})$ 后，它在第 $\ell$ 层的 KV 缓存是：

$$\text{KV}_\theta(z \mid c) = \left\{(K_z^\ell,\, V_z^\ell)\right\}_{\ell=1}^L \tag{2}$$

其中 $K_z^\ell \in \mathbb{R}^{|z| \times d_k}$，$V_z^\ell \in \mathbb{R}^{|z| \times d_v}$，分别是 $z$ 段对应的键和值矩阵。

旋转位置编码（RoPE）

主流大模型（LLaMA、Qwen、DeepSeek 等）普遍使用旋转位置编码 RoPE（Su et al., 2022）。RoPE 的思路是：不把位置嵌入加到词向量上，而是在计算注意力之前，对 Q 和 K 向量施加一个和位置相关的旋转变换：

$$Q_t = R(t) \cdot W_Q x_t, \quad K_t = R(t) \cdot W_K x_t \tag{3}$$

其中 $R(t)$ 是分块对角旋转矩阵。由于 $Q_s \cdot K_t = (R(s) q_s)^T (R(t) k_t) = q_s^T R(s-t) k_t$，内积自然编码了相对距离 $s - t$，模型只需关注相对位置而无需关注绝对位置。

对本文的关键影响：每个缓存的 KV 向量里都嵌入了它被生成时对应的绝对位置。Worker $j$ 在自己的上下文 $c_j$（长度 $|c_j|$）之后生成 $z_j$，那么 $z_j$ 第 $r$ 个 token 的 KV 缓存编码的是位置 $|c_j| + r$。若直接把多个 Worker 的缓存拼起来，不同分支的 token 位置会互相冲突，导致 Synthesizer 的注意力混乱。

LoRA：低秩微调

LoRA（Hu et al., 2021）是目前最主流的参数高效微调方法。思路是：冻结原始权重 $W \in \mathbb{R}^{d \times k}$，只训练一个低秩残差 $\Delta W = AB^T$，其中 $A \in \mathbb{R}^{d \times r}$，$B \in \mathbb{R}^{k \times r}$，$r \ll \min(d, k)$：

$$h = (W + AB^T) x = Wx + AB^T x \tag{4}$$

参数量从 $d \times k$ 降到 $r(d+k)$。对于 7B 参数模型，$r=64$ 时大概只需要训练不到 1% 的参数。Parallel-Synthesis 对 Synthesizer 使用 LoRA 适配，让它学会在多分支 KV 缓存这个「非标准」接口上正确推理。

有向无环图（DAG）结构的智能体工作流

现实中的复杂智能体任务很少是一条线性链。研究助手并行探索多个假说；代码智能体采样多份候选方案再选最好的；数据库诊断智能体同时运行多个监控子智能体再汇总结论。这些工作流天然是有向无环图（DAG）：多个独立分支并行执行，再汇聚到下游的综合节点。

图 1：并行研究任务的 DAG 工作流示意

graph TD
    Q["用户任务 / 查询"] --> B["分支点"]
    B --> W1["Worker 1\n子任务：文献调研"]
    B --> W2["Worker 2\n子任务：方法分析"]
    B --> W3["Worker 3\n子任务：实验设计"]
    W1 -->|"文本输出 z₁\n或 KV 缓存"| S["综合智能体 Synthesizer"]
    W2 -->|"文本输出 z₂\n或 KV 缓存"| S
    W3 -->|"文本输出 z₃\n或 KV 缓存"| S
    S --> A["最终答案 y"]

    style S fill:#ff9966,stroke:#cc6600
    style Q fill:#66ccff,stroke:#0066cc

问题出在指向 Synthesizer 的那几根箭头上：今天的系统把 Worker 输出序列化为文本传过去（文本字符串），Parallel-Synthesis 要把这些替换为直接的 KV 缓存传输。

多智能体编排与综合瓶颈

AutoGen、LangGraph、OpenAI Swarm、Anthropic 智能体 SDK 等主流框架在合并并行分支时都共用同一个流程：

1. 等待所有 $m$ 个 Worker 完成生成。
2. 拼接文本：$x_{text} = u \circ z_1 \circ \cdots \circ z_m$。
3. 将整个拼接前缀从头重新预填充（re-prefill）——哪怕 Worker 解码时已经把这些 KV 算过一遍了。

重复预填充的代价与 $\sum_j |z_j|$ 成正比。对于 $m=4$ 个 Worker、每个生成 2000 token 来说，合成前需要额外预填充 8000 token 才能生成第一个输出 token。Parallel-Synthesis 完全消除了这次重复预填充。

论文核心贡献

Parallel-Synthesis 解决的是：Synthesizer 在合并并行分支时重复编码了 Worker 已经编码过的内容。解法由三个互相配合的组件构成：

1. 位置重编码（Positional Re-encoding）：把各分支的 KV 缓存位置重新锚定到分叉点 $n$，消除 RoPE 位置冲突。
2. 缓存映射器（Cache Mapper）：每层一个可学习变换，校正不同分支 KV 分布之间的偏移，应对「每个 Worker 在自己的上下文下生成，但合并后需要联合被 Synthesizer 消费」这一分布错位问题。
3. Synthesizer LoRA：对 Synthesizer 的低秩适配，让模型学会在多分支非顺序 KV 缓存接口上正确生成答案。

三者协同训练，产出的 Synthesizer 可以作为即插即用组件替换任何现有多智能体框架中的综合步骤。

问题形式化

符号定义

考虑包含 $m$ 个 Worker 智能体和 1 个 Synthesizer 的并行工作流，所有智能体共用同一骨干模型 $f_\theta$。Worker $j \in \{1, \ldots, m\}$ 在上下文 $c_j$ 下生成输出 $z_j$：

$$z_j \sim P_\theta(\cdot \mid c_j), \qquad c_j = c^{sh} \circ c_j^{br} \tag{5}$$

其中 $c^{sh}$ 是所有 Worker 共享的前缀（任务描述），$c_j^{br}$ 是该分支特定的指令或历史，$\circ$ 表示拼接。所有 Worker 完成后，Synthesizer 收到自己的指令 $u$，生成最终答案 $\mathbf{y}$。

文本序列化接口（现有基准）：Synthesizer 构造单一顺序输入：

$$x^{text} = u \circ z_1 \circ \cdots \circ z_m \tag{6}$$

然后自回归生成：

$$y_t \sim P_{text}(\cdot \mid x^{text} \circ y_{<t}) \tag{7}$$

这很简单，但必须重新预填充所有 $z_1, \ldots, z_m$。

基于缓存的接口（本文提出）：Synthesizer 只预填充 $u$，得到 $\text{KV}_\theta(u) = \{(K_u^\ell, V_u^\ell)\}_{\ell=1}^L$，然后直接拼接 Worker 的缓存：

$$K_{syn}^\ell = [K_{z,1}^\ell \;;\; K_{z,2}^\ell \;;\; \cdots \;;\; K_{z,m}^\ell \;;\; K_u^\ell] \tag{8}$$ $$V_{syn}^\ell = [V_{z,1}^\ell \;;\; V_{z,2}^\ell \;;\; \cdots \;;\; V_{z,m}^\ell \;;\; V_u^\ell] \tag{9}$$

使用组装好的缓存进行解码：

$$y_t \sim P_{kv}\!\left(\cdot \mid \{(K_{syn}^\ell, V_{syn}^\ell)\}_{\ell=1}^L,\; y_{<t}\right) \tag{10}$$

目标：让缓存接口的生成分布近似文本序列化接口：

$$P_{kv}\!\left(\mathbf{y} \mid u,\; \{\text{KV}_\theta(z_j \mid c_j)\}_{j=1}^m\right) \approx P_{text}\!\left(\mathbf{y} \mid u,\; z_1, \ldots, z_m\right) \tag{11}$$

为什么朴素拼接行不通

直接拼接（方程 8–9）有两个根本问题：

问题一：位置冲突。 Worker $j$ 在位置 $|c_j|, |c_j|+1, \ldots, |c_j|+|z_j|-1$ 生成了 $z_j$（RoPE 嵌入的是这些绝对位置）。不同 Worker 的上下文长度 $|c_j|$ 各不相同，拼起来后各分支的 token 位置会重叠或错位，让 Synthesizer 的相对位置注意力彻底失效。

问题二：分布偏移。 每个 Worker 的 KV 缓存是在它自己的私有历史下计算的——Worker 1 的位置 $p$ 处的 KV 向量，编码的是它读过自己上下文之后的”感知”。但合并后，Worker 1 的 KV 向量会和 Worker 2 的 KV 向量并排让 Synthesizer 来读，而 Worker 1 的 KV 从未见过 Worker 2 的上下文，分布不匹配。

这两个问题叠加，导致朴素缓存拼接的输出质量很差（实验中验证：直接拼接准确率比文本基准低 10–20 个百分点）。

三种并行工作流场景

方程 (5) 的形式化涵盖了三种常见的并行智能体模式：

场景 1：单轮并行解题（Single-turn parallel problem solving）。所有 Worker 收到完全相同的输入 $c_j = c^{sh}$，各自独立采样候选解（如数学题的 $m$ 种解法）。Synthesizer 从中选最优或做加权综合。

场景 2：多轮并行轨迹展开（Multi-turn parallel trajectory rollout）。Worker 共享同一初始提示，但各自累积不同的推理链、工具调用、中间观测，因此 $c_j^{br}$ 记录了不同的分支轨迹。Synthesizer 整合多条探索路径。

场景 3：独立子任务分配（Distinct sub-task execution）。任务分解为 $m$ 个独立子任务，分别交给不同 Worker 执行（如一个 Worker 检索文献、一个运行代码、一个搜索网页）。

方法：Parallel-Synthesis 架构详解

图 2：Parallel-Synthesis 完整推理流程

graph LR
    subgraph Workers ["并行 Worker 智能体"]
        W1["Worker 1\n上下文 c₁ → z₁"]
        W2["Worker 2\n上下文 c₂ → z₂"]
        Wm["Worker m\n上下文 cₘ → zₘ"]
    end

    subgraph Proc ["缓存处理"]
        PR["① 位置重编码\n(RoPE 锚点修正)"]
        CM["② 缓存映射器\n(每层可学习变换 φ^ℓ)"]
    end

    subgraph Syn ["综合智能体"]
        KVM["KV 合并\n[KV₁; KV₂; ...; KVₘ; KVᵤ]"]
        LORA["Synthesizer LoRA\n(非顺序缓存适配)"]
        GEN["自回归解码 → y"]
    end

    W1 -->|KV 缓存| PR
    W2 -->|KV 缓存| PR
    Wm -->|KV 缓存| PR
    PR --> CM
    CM --> KVM
    U["Synthesizer 提示 u\n(仅需预填充 u)"] --> KVM
    KVM --> LORA --> GEN

    style Proc fill:#fff3cc
    style Syn fill:#ffe0cc

组件一：位置重编码

设 $n$ 为共享前缀 $c^{sh}$ 结束后的 RoPE 位置，即工作流中各分支分叉的那一刻。思路：把所有分支输出的起始位置都锚定到 $n$，无论该分支的私有上下文 $c_j^{br}$ 有多长。

重编码规则：对分支 $j$ 输出 $z_j$ 的第 $r$ 个 token，原始位置是 $|c_j| + r$，修正为：

$$\text{pos}(z_{j,r}):\; |c_j| + r \;\longrightarrow\; n + r \tag{12}$$

由于 RoPE 的旋转矩阵 $R(\cdot)$ 是可逆的，可以对已缓存的键向量直接施加「旋转补偿」，不需要重跑 forward pass：

$$K_{z,j,r}^{\ell,\text{new}} = R(n+r) \cdot R^{-1}(|c_j|+r) \cdot K_{z,j,r}^{\ell,\text{old}} \tag{13}$$

注意：RoPE 只对键 K 和查询 Q 做旋转，值向量 V 不受影响，所以位置重编码只需修改键缓存。

直觉：重编码后，Synthesizer 的查询（在位置 $n + |z_{max}| + t$）到分支 $j$ 的第 $r$ 个 token（位置 $n + r$）的相对距离，在所有分支之间是一致的。没有这步校正，Synthesizer 的注意力会把位置距离和分支身份混淆，造成严重的注意力错位。

对比 RoPE 外推：RoPE 外推（如 YaRN、NTK）也是对位置编码做缩放调整，但目的是让模型处理比训练时更长的上下文。本文的重编码是为了对齐并行分支的起始位置，是完全不同的问题。

组件二：缓存映射器（Cache Mapper）

位置重编码解决了「位置冲突」，但「分布偏移」问题依然存在：每个 Worker 的 KV 状态是在自己私有的上下文下计算的，直接拼起来让 Synthesizer 联合消费会有分布错位。

缓存映射器 $\phi^\ell$ 对每层的 KV 施加一个可学习的线性校正：

$$\hat{K}_{z,j}^\ell = \phi_K^\ell(K_{z,j}^{\ell,\text{re-enc}}), \quad \hat{V}_{z,j}^\ell = \phi_V^\ell(V_{z,j}^{\ell,\text{re-enc}}) \tag{14}$$

映射器的参数量很小（每层一个线性变换或低秩变换），随 Synthesizer LoRA 一起训练。

直觉类比：想象你要综合三份由不同专家写给不同读者的报告。每份报告都是在「假设读者只读过这一份」的前提下写的。你作为综合者需要先把三份报告的写作风格和隐性假设「对齐」，才能做出准确的判断。缓存映射器在隐空间做的正是这件事——把各分支的 KV 分布拉进一个公共的参考系，让 Synthesizer 的注意力能够真正跨分支比较。

与 RAG 风格缓存复用的区别：面向长上下文 RAG 的并行 KV 编码方案（SelKV、LongRAG）也需要校准独立编码的缓存块，但它们针对的是静态文档片段，没有 Worker 自己的状态上下文。本文实验表明，直接把这类方法迁移到并行智能体综合场景，准确率下降 5–15 个百分点，证明专门训练的映射器是必要的。

组件三：Synthesizer LoRA

位置重编码 + 缓存映射器解决了结构问题，但 Synthesizer 的骨干模型在预训练时从未见过「拼了来自 $m$ 个独立上下文的 KV 块再做推理」这种格式。LoRA 适配修改 Synthesizer 的注意力投影权重：

$$h = \left(W + AB^T\right) q + \text{Attn}_{kv}\!\left(Wq,\; \hat{K}_{syn}, \hat{V}_{syn}\right) \tag{15}$$

其中 $A, B$ 是低秩可学习参数。LoRA 施加在 Synthesizer 的 Q、K、V 投影矩阵上（Worker 的权重完全冻结），让模型学会：

• 同时有效关注 $m$ 个并行分支块（而非顺序文本前缀）。
• 理解各分支代表独立的探索路径，而非连贯的叙事。
• 对比、判断和聚合各分支输出，完成综合判断。

训练数据构建

Parallel-Synthesis 的训练需要让模型在监督信号下接触到并行缓存上下文。论文构建了三类互补数据：

数据类型 1 — 并行缓存上下文持续预训练： 将大规模多轮对话数据重格式化，让多个对话轮次或文档以缓存分支形式呈现。这给模型提供了广泛的并行缓存接口曝光，同时防止灾难性遗忘。

数据类型 2 — 多源综合任务： 精心构造的任务，要求 Synthesizer 从 $m$ 个独立来源（多份检索段落、多位专家观点等）的缓存中聚合信息作答。直接训练多分支聚合行为。

数据类型 3 — 来自文本拼接基准的蒸馏数据： 对复杂智能体任务，用文本拼接综合器生成推理轨迹作为目标，让 Parallel-Synthesis 模型去拟合这些推理输出。把文本基准强大的链式思考推理能力迁移到缓存接口版本。

逐步算法：Parallel-Synthesis 推理过程

算法 1：Parallel-Synthesis 推理

输入：
  - 共享前缀 c_sh（共同任务上下文）
  - 分支上下文 c_1^br, ..., c_m^br（每个 Worker 的指令）
  - Synthesizer 提示 u
  - 训练好的缓存映射器 φ^ℓ（每层 ℓ 一个）
  - 训练好的 Synthesizer LoRA ΔW

输出：
  - 最终答案 y

步骤 1：共享前缀预填充
  对 c_sh 做预填充，通过骨干模型 f_θ。
  所有 Worker 继承同一共享前缀 KV 缓存：
    KV_sh = {(K_sh^ℓ, V_sh^ℓ)}_{ℓ=1}^L
  记分叉点位置 n = |c_sh|

步骤 2：并行 Worker 解码（所有 Worker 同时执行）
  对每个 j = 1, ..., m（并行）：
    (a) 预填充分支上下文 c_j^br，继承 KV_sh。
    (b) 自回归解码输出 z_j。
    (c) 只保留 z_j 段的 KV 缓存：
          KV_θ(z_j | c_j) = {(K_{z,j}^ℓ, V_{z,j}^ℓ)}_{ℓ=1}^L
        （丢弃上下文缓存，节省内存）

步骤 3：位置重编码
  对每个分支 j = 1, ..., m：
    对每个 token r = 0, ..., |z_j| - 1：
      对每层 ℓ：
        K_{z,j,r}^ℓ ← R(n+r) · R⁻¹(|c_j|+r) · K_{z,j,r}^ℓ
        （V 向量无需修改，RoPE 只影响键）

步骤 4：缓存映射
  对每个分支 j 和每层 ℓ：
    K̂_{z,j}^ℓ = φ_K^ℓ(K_{z,j}^ℓ)
    V̂_{z,j}^ℓ = φ_V^ℓ(V_{z,j}^ℓ)

步骤 5：Synthesizer 提示预填充
  对 u 做预填充，通过带 LoRA 的 Synthesizer：
    KV_u = {(K_u^ℓ, V_u^ℓ)}_{ℓ=1}^L

步骤 6：缓存组装
  对每层 ℓ：
    K_syn^ℓ = [K̂_{z,1}^ℓ ; ... ; K̂_{z,m}^ℓ ; K_u^ℓ]
    V_syn^ℓ = [V̂_{z,1}^ℓ ; ... ; V̂_{z,m}^ℓ ; V_u^ℓ]

步骤 7：Synthesizer 自回归解码
  使用 {(K_syn^ℓ, V_syn^ℓ)} 作为固定前缀 KV 缓存，
  自回归生成答案 y，每步追加新 token 的 KV。

输出 y

计算量对比：

• 文本拼接综合器：预填充代价 $\propto |u| + \sum_j |z_j|$，然后解码。
• Parallel-Synthesis：预填充代价 $\propto |u|$；步骤 3–4 是 $O(m \cdot L \cdot |z_{max}| \cdot d)$ 的线性操作，与注意力的二次代价相比可忽略不计。

首 token 延迟（TTFT）降低的机制：节省的时间恰好等于重新预填充 $\sum_j |z_j|$ 个 token 的时间。理论上对 $m=4$ 个分支、每个 1024 token、$|u|=128$ 的情况，TTFT 理论降幅约 33 倍；实验报告的 2.5–11× 反映了现实中的路由开销、GPU 同步延迟和分支长度不均衡。

与相邻工作的区别

图 3：文本综合 vs 缓存综合的关键差异

graph TB
    subgraph TB1 ["现有文本综合（昂贵）"]
        direction LR
        WT1["Worker 1\n纯文本输出 z₁"] --> CC["拼接\nu ∘ z₁ ∘ ... ∘ zₘ"]
        WT2["Worker 2\n纯文本输出 z₂"] --> CC
        CC --> RP["从头重新预填充\n（代价 ∝ Σ|zⱼ|）"]
        RP --> O1["生成 y\n（首 token 慢）"]
    end

    subgraph TB2 ["Parallel-Synthesis（高效）"]
        direction LR
        WP1["Worker 1\nKV 缓存"] --> RE["位置重编码"]
        WP2["Worker 2\nKV 缓存"] --> RE
        RE --> MP["缓存映射器"]
        MP --> MG["缓存合并\n+ LoRA Synthesizer"]
        UP["提示 u\n（只预填充 u）"] --> MG
        MG --> O2["生成 y\n（首 token 快 2.5–11×）"]
    end

    style RP fill:#ff6666
    style MG fill:#66ff66

与相关工作的区别总结：

• 面向 RAG 的并行 KV 编码（SelKV、GoldFinch 等）：针对静态文档片段，不涉及智能体轨迹。实验显示直接迁移效果差。
• 一对一潜在空间智能体通信（CacheBlend、KVSharer）：串行地把一个智能体的缓存传给另一个，是一对一关系。Parallel-Synthesis 解决的是多对一的综合拓扑：$m$ 个并行缓存 → 1 个 Synthesizer。
• Best-of-N 选择：采样 $k$ 份输出后用奖励模型打分，不做真正的综合。Parallel-Synthesis 产出一个全新的综合答案。

实验

实验设置

骨干模型：论文使用 LLaMA-3.1 系列 8B 模型（预印本未给出精确 checkpoint）。Worker 和 Synthesizer 共享同一骨干，Synthesizer 额外有 LoRA 适配器和缓存映射器。

基准对比方法：

1. 文本拼接综合（Text-concat）：标准文本序列化方法，质量锚点，完整重新预填充。
2. RAG 风格并行编码：把面向长上下文 RAG 的缓存复用方法直接迁移到并行智能体合成场景，不再训练。
3. 摘要综合（Summary-based）：每个 Worker 生成简短摘要，Synthesizer 接收拼接摘要作为输入。

评估数据集（共 9 个）：

• 数学推理：GSM8K、MATH-500、OlympiadBench
• 科学 QA：ARC-Challenge、MMLU-Pro Science
• 代码生成：HumanEval+、MBPP
• 智能体 QA：GAIA（多步工具调用基准）
• 多智能体数据库诊断：自定义基准（多个数据库监控智能体报告，Synthesizer 诊断根因）

并行设置：每个任务 $m=4$ 个分支。Worker 生成上限：数学/代码 512 token，智能体任务 1024 token。

主要结果

图 4：Parallel-Synthesis 在 9 个基准上的结果概况

graph LR
    subgraph Results ["各数据集相对文本拼接基准的表现"]
        direction TB
        R1["GSM8K：PS ≥ 文本基准 (+0.8%)"]
        R2["MATH-500：PS ≥ 文本基准 (+1.2%)"]
        R3["OlympiadBench：PS ≈ 文本基准 (−0.5%，误差范围内)"]
        R4["ARC-Challenge：PS > 文本基准 (+1.9%)"]
        R5["MMLU-Pro Science：PS ≈ 文本基准 (−0.3%)"]
        R6["HumanEval+：PS > 文本基准 (+2.1%)"]
        R7["MBPP：PS ≈ 文本基准 (+0.4%)"]
        R8["GAIA：PS < 文本基准 (−3.2%，最大差距)"]
        R9["数据库诊断：PS > 文本基准 (+4.1%)"]
    end

关键观察：

1. 9 个数据集中 7 个：Parallel-Synthesis 与文本拼接基准持平或更优。在数学和代码任务上的稳定提升表明，直接聚合并行候选解的隐状态，可能比把它们序列化为文本后再读取更有效——模型能接触到更丰富的中间表示。

2. GAIA 差距最大（−3.2%）：GAIA 要求进行长程、多样化的工具调用轨迹，分支之间依赖关系复杂。当前缓存映射器对多模态工具调用状态跨分支校准能力不足。这是最大的未解决问题。

3. 数据库诊断增益最大（+4.1%）：多个数据库监控智能体生成结构化、格式相近的报告。分支输出格式越规整，缓存映射器的校准效果越好——揭示了该方法最适合的场景。

4. RAG 风格方法直接迁移失败：准确率下降 5–15 个百分点，验证了为智能体轨迹专门训练缓存映射器的必要性。

效率结果：TTFT 降低

图 5：首 token 延迟（TTFT）降低倍数 vs 每分支 token 数

xychart-beta
    title "TTFT 降低倍数（Parallel-Synthesis vs 文本拼接基准，m=4）"
    x-axis ["512 tok/分支", "1024 tok/分支", "2048 tok/分支", "4096 tok/分支"]
    y-axis "TTFT 降低倍数" 0 --> 12
    bar [2.5, 4.8, 7.3, 11.0]

TTFT 降低倍数随分支总输出长度近似线性增长，与理论分析一致：文本拼接综合器的预填充代价是 $O(\sum_j |z_j|)$，而 Parallel-Synthesis 只需预填充 $|u|$。在每分支 512 token（$m=4$，共 2048 branch token）时，2.5× 降幅反映了位置重编码和缓存映射的额外开销；在每分支 4096 token（共 16K branch token）时，11× 降幅接近理论上限。

对典型的研究综合任务（4 个 Worker 各生成 1024 token），文本综合器等待预填充额外 1.8 秒才能输出第一个 token，Parallel-Synthesis 把这一等待压缩到 0.38 秒——对交互式智能体系统的响应性来说提升显著。

消融实验

配置	GSM8K	HumanEval+	GAIA
完整 Parallel-Synthesis	88.4%	82.7%	47.3%
去掉位置重编码	71.2%	65.3%	38.1%
去掉缓存映射器	80.6%	74.5%	41.2%
去掉 Synthesizer LoRA	76.8%	69.1%	39.7%
仅用 RAG 风格映射器	73.5%	67.2%	36.8%
文本拼接基准	87.6%	80.6%	50.5%

位置重编码是最关键的组件——去掉它准确率下降 17+ 个百分点，远超其他组件的贡献。缓存映射器和 LoRA 各自贡献约 7–8 个百分点。三者协同才能让系统达到文本基准的水平。

批判性分析：不足与可改进之处

不好的地方

1. GAIA 性能差距的分析浅尝辄止。 −3.2% 的差距是全文最大的实验漏洞，但论文的分析仅停留在「分支之间存在复杂依赖」这种模糊的描述上。GAIA 包含多种子任务（网页浏览、文件操作、计算器调用等），哪种子类型失败最严重？是分支 token 过长导致映射器过载，还是工具调用输出的异质性让映射器无法有效校准？这些关键问题没有任何分析。

2. 只测了 $m=4$ 个分支。 所有实验固定 $m=4$。理论上 TTFT 收益随 $m$ 增大，但质量如何随 $m$ 变化完全未知。在 SWE-bench 等真实 coding 场景，通常使用 $m=8$–16 个并行候选；大规模多智能体研究框架甚至会用到 $m=32$ 以上。更大的 $m$ 时，Synthesizer 的注意力是否会被过多分支 KV 块稀释？缓存映射器的分布校准能否扩展到更多分支？完全没有实验依据。

3. 骨干模型描述模糊。 论文只写了「Llama-3.1 系列 8B 模型」，没有给出具体 checkpoint（base vs. instruct）、chat template、tokenizer 版本。复现工作无法在不知道确切配置的情况下进行，这是严重的可复现性问题。

4. 内存开销未讨论。 对 $m=4$、每分支 1024 token、32 层 8B 模型，映射后的 KV 缓存占用额外 4×32×1024×$d_{head}$ 个 float16 值（以 $d_{head}=128$ 计，约 537 MB），在 GPU 显存紧张的场景下不可忽视。论文完全没有讨论峰值显存使用情况。

5. 同骨干限制是硬约束。 目前框架要求所有 Worker 和 Synthesizer 使用完全相同的骨干架构和权重（只有 Synthesizer 有 LoRA 和映射器）。这排除了生产级多智能体系统中常见的异构设计——例如用一个较小的专用 Worker 模型加速特定子任务，再用大 Synthesizer 整合。

6. 蒸馏数据细节缺失。 数据类型 3（从文本拼接 pipeline 的蒸馏）只有概念描述，没有报告样本量、任务域分布、蒸馏超参数，也没有分析训练域和评估域之间是否存在分布偏移及其影响。

作者淡化或回避的局限

滞后者（Straggler）问题被忽视。 TTFT 降低的前提是所有 $m$ 个 Worker 的 KV 缓存同时可用——但在实际系统中，Worker 完成时间各异，Synthesizer 必须等最慢的那个。从用户视角看，总延迟是 $\max_j(\text{Worker}_j \text{ 延迟}) + \text{Parallel-Synthesis TTFT}$。当 Worker 解码本身是瓶颈（短文本任务、快速 Worker 模型），TTFT 收益就无关紧要了。论文没有报告端到端延迟，只报告了 TTFT，回避了 Straggler 问题对实际用户体验的影响。

位置重编码抹除了轨迹深度信息。 把所有分支起始位置都锚定到 $n$，相当于告诉 Synthesizer：「每个分支都在同一个点分叉。」但在多轮轨迹展开（场景 2）中，有的分支可能经过了 20 轮工具调用，有的只有 2 轮，它们积累的「经验深度」不同。位置信息的这种对齐操作丢失了分支历史长度这一有意义的信号。

缓存映射器对零样本新域的泛化未验证。 映射器在有限的任务域上训练，对训练域完全不覆盖的新型智能体工作流（如科学仿真、代码仓库探索智能体），泛化能力未知。

可以改进的地方

1. 补充 $m$ 扩展实验。 在 $m \in \{2, 4, 8, 16\}$ 下分别报告质量和 TTFT，以及端到端延迟（不只是 TTFT）。增加对注意力分布的可视化分析，展示 Synthesizer 如何随 $m$ 增大调整注意力权重。

2. 探索异构骨干支持。 类比视觉-语言跨模态适配器，设计跨模型维度的缓存投影层，让不同大小的 Worker 和 Synthesizer 也能协作。这对实际部署至关重要。

3. 实现异步流式综合。 不要等所有 Worker 都完成，而是在第一个分支完成后就开始综合，后续分支完成后动态追加缓存。这可以消除 Straggler 问题，进一步降低端到端延迟。

4. GAIA 失败案例深度分析。 按子任务类别和分支 token 长度分层报告 GAIA 准确率，找到映射器失效的具体条件，设计有针对性的改进（如对工具调用输出做专项校准）。

5. 量化缓存映射器以降低显存占用。 探索 INT8/FP8 量化或块稀疏版本的缓存，把额外显存开销从数百 MB 压缩到 50 MB 以下，让方法可以在 24GB 消费级 GPU 上使用。

6. 提供完整可复现实现。 发布精确 checkpoint、训练数据处理脚本、LoRA 超参数和缓存映射器的完整架构。这是从一篇「想法有意思的论文」到「社区能真正使用的工具」的关键一步。

局限性与边界条件

明确的限制（论文自述）：

• 同骨干约束：Worker 和 Synthesizer 必须共用相同权重。
• GAIA 上的准确率差距：复杂长程工具调用场景尚未完全解决。

本文观察到的附加限制：

• 位置重编码假设所有分支从同一共享前缀分叉。在树形工作流中，不同子树的分叉深度不同，$n$ 的定义不明确。
• 训练-评估域偏移未系统研究。
• $m$ 的扩展性完全未知。

深入分析：缓存映射器为何有效——分布视角

要理解缓存映射器为什么必要，以及它在纠正什么，需要分析 Worker 在其分支上下文 $c_j^{br}$ 下生成时，KV 分布究竟发生了什么。

核心洞察：任意层 $\ell$ 的 KV 向量不是抽象嵌入——它们是条件化的表示。具体而言，分支 $j$ 位置 $r$ 处的键向量是：

$$K_{z,j,r}^\ell = W_K^\ell \cdot \text{LM}_\theta(z_{j,r} \mid c_j, z_{j,<r}) \tag{22}$$

其中 $\text{LM}_\theta(z_{j,r} \mid c_j, z_{j,<r})$ 是模型在 token $r$ 处的隐状态，以完整的 Worker 上下文 $c_j = c^{sh} \circ c_j^{br}$ 为条件。

考虑两个分支上下文不同（$c_1^{br} \ne c_2^{br}$）但恰好生成了相同文本 $z$ 的情况。即使表层输出完全相同，它们在任意层的 KV 状态也会不同：

$$K_{z,1,r}^\ell \ne K_{z,2,r}^\ell \quad \text{（相同文本，不同上下文）} \tag{23}$$

差异来源于：位置 $r$ 处的隐状态计算需要对所有前序 token（包括 $c_j^{br}$）做注意力——KV 缓存不只是 $z_j$ 的函数，而是 $(c_j, z_j)$ 的联合函数。

当 Synthesizer 同时对这些分支缓存做注意力时，其查询 $Q_{syn,t}$ 与分支 $j$ 的键 $K_{z,j,r}^\ell$ 的注意力分数为：

$$a_{j,r,t}^\ell = \frac{Q_{syn,t}^\ell \cdot (K_{z,j,r}^\ell)^T}{\sqrt{d_k}} \tag{24}$$

这个注意力分数的分布受 $K_{z,j,r}^\ell$ 的统计特性影响，而后者依赖于 $c_j$。缓存映射器的作用正是校正这一点：把各分支的 KV 统计特性规范化到一个公共参考分布，使得不管键来自哪个分支，注意力分数的分布都更一致。最简单的情形下，这等价于对 K 和 V 向量的均值和方差做跨分支规范化——隐空间中的一种实例规范化操作。

这也解释了为什么映射器要逐层设计：不同层的分布偏移特征不同（浅层编码句法特征，深层编码语义/上下文特征），一个共享映射器无法同时校正所有层的偏移。

系统性对比：Parallel-Synthesis 与相关方法

方法	通信介质	拓扑	需要训练	TTFT 优势	同骨干要求
文本拼接综合（基准）	文本字符串	多对一	否	无	否
RAG 并行编码（SelKV 等）	KV 缓存（静态文档）	多对一	部分	小	是
一对一潜在通信（CacheBlend）	KV 缓存	一对一	是	中	是
Best-of-N + 奖励模型	文本 + 分数	多对一（选择）	否	无	否
Parallel-Synthesis（本文）	KV 缓存（智能体轨迹）	多对一（综合）	是	2.5–11×	是

Parallel-Synthesis 的独特定位：KV 缓存通信 × 多对一综合拓扑 × 针对智能体轨迹训练的映射器——三者的组合在此之前没有系统研究过。

可复现性说明

论文提供的信息：

• RoPE 重编码公式（方程 13）完整，可在 50 行 PyTorch 内实现。
• 整体推理流程（算法 1）可从论文推导完整。
• 三类训练数据的概念描述。

尚未提供（截至预印本）：

• 代码仓库。
• 精确骨干 checkpoint 名称。
• 训练数据集大小和来源。
• 缓存映射器架构细节（线性还是 MLP？参数量？）。
• LoRA 超参数（$r$、目标模块、学习率）。

最适合立即复现的部分：位置重编码（方程 13）和推理流程（算法 1）可以完全从论文中推导并实现，作为实验性实现的起点。

工程实现细节

缓存映射器的架构设计

论文描述缓存映射器为「轻量级」逐层变换。从描述和相关工作的惯例来看，映射器很可能采用以下两种形式之一：

形式 A — 逐层线性投影：

$$\phi_K^\ell(K) = K \cdot W_K^\ell + b_K^\ell, \quad \phi_V^\ell(V) = V \cdot W_V^\ell + b_V^\ell \tag{17}$$

其中 $W_K^\ell, W_V^\ell \in \mathbb{R}^{d_k \times d_k}$，每层一组。对于 $L=32$ 层、$d_k=128$ 的模型，额外参数约 $32 \times 2 \times 128^2 \approx 1M$，可忽略不计。

形式 B — 逐层低秩残差校正：

$$\phi_K^\ell(K) = K + K \cdot A_K^\ell (B_K^\ell)^T, \quad A_K^\ell \in \mathbb{R}^{d_k \times r_m},\; B_K^\ell \in \mathbb{R}^{d_k \times r_m} \tag{18}$$

映射器秩 $r_m \ll d_k$（如 $r_m = 16$）。这是残差校正而非完整投影，初始化时令 $A=0$ 即可从「朴素拼接」基线开始训练，梯度流更稳定，且可证明在低秩校正较小时保持信息的可逆性。

形式 B 更受青睐，因为：

• 恒等初始化使训练从合理的起点出发。
• 保留了原始缓存信息，只做细粒度校准。
• 参数量极小，不引入过拟合风险。

位置重编码的高效实现

方程（13）中的旋转补偿对每个键向量都要计算 $R(n+r) \cdot R^{-1}(|c_j|+r)$。实践中这可以大幅简化。RoPE 对每个频率 $k$ 以角速度 $\theta_k t$ 旋转，两次旋转的差值恰好是一个对分支 $j$ 固定的角度偏移：

$$\Delta\theta_k^{(j)} = \theta_k \cdot (n - |c_j|) \tag{19}$$

这意味着分支 $j$ 内的所有 token 都施加同一个角度偏移——可以一次预计算，再批量应用，不需要逐 token 单独计算。代码示意：

# 高效位置重编码伪代码
def reposition_branch_keys(K_branch, c_j_len, n, rope_freqs):
    # K_branch: [|z_j|, num_heads, d_head]
    delta_pos = n - c_j_len          # 标量，分支固定
    delta_angles = rope_freqs * delta_pos   # [d_head // 2]
    cos_d = torch.cos(delta_angles)
    sin_d = torch.sin(delta_angles)
    K_even = K_branch[..., 0::2]
    K_odd  = K_branch[..., 1::2]
    K_branch[..., 0::2] = K_even * cos_d - K_odd * sin_d
    K_branch[..., 1::2] = K_even * sin_d + K_odd * cos_d
    return K_branch

该操作是 $O(|z_j| \times n_{heads} \times d_{head})$ 的线性操作，可跨分支、头、token 并行，对 GPU 极友好。

显存管理分析

当 $m$ 个并行 Worker 各自生成最长 $T$ 个 token 后，Synthesizer 需要同时持有所有分支的 KV 缓存，峰值显存为：

$$\text{Mem}_{KV} = m \times T \times L \times 2 \times d_k \times \text{sizeof(dtype)} \tag{20}$$

以 $m=4$，$T=1024$，$L=32$，$d_k=128$，FP16 计算：

$$4 \times 1024 \times 32 \times 2 \times 128 \times 2 = 2^{26} \text{ 字节} \approx 67 \text{ MB}$$

在现代 A100/H100 上完全可接受。对 GAIA 任务（$T=4096$），增长到约 268 MB，仍可用，但占显存比例增大。

优化方案：CPU 卸载。在 Worker 完成、映射完成后，非当前激活的分支缓存可先卸载到 CPU 内存，综合解码时按需流式搬回 GPU。由于某一步只有少数注意力头会高强度关注分支 KV，这可以将常驻 GPU 的分支缓存量大幅压缩。

训练流程

基于论文描述和相关工作的惯例，训练大致分为两阶段：

阶段 1 — 宽泛适应（数据类型 1）：

• 联合训练缓存映射器 $\phi$ 和 Synthesizer LoRA。
• 目标：在并行缓存格式的对话数据上做标准下一 token 预测。
• 多样化的分支数量和长度确保泛化。

阶段 2 — 综合能力精调（数据类型 2 和 3）：

• 在多源综合任务（数据类型 2）上继续训练。
• 添加来自文本拼接基准的蒸馏损失（数据类型 3）：

$$\mathcal{L}_{distill} = -\sum_t \log P_{kv}(y_t^* \mid \text{缓存上下文}) \tag{21}$$

其中 $y_t^*$ 是文本拼接综合器生成的 token。该蒸馏目标让缓存接口模型学会复现文本基准高质量的推理链。

超参数参考范围（基于同类工作经验）：

• LoRA 秩：$r \in \{32, 64, 128\}$
• LoRA 目标模块：Q、K、V、O 投影（全注意力层）
• 学习率：映射器 $1\times 10^{-4}$，LoRA $5\times 10^{-5}$
• 批大小：128–256 个序列，每个序列包含 $m$ 个分支缓存 + Synthesizer 提示
• 训练步数：约 1 万–5 万步（估算）

集成到现有智能体框架

把 Parallel-Synthesis 集成进 LangGraph 风格编排框架的系统示意：

图 6：Parallel-Synthesis 集成进多智能体框架的系统架构

graph TD
    subgraph Framework ["多智能体编排层"]
        ORC["编排器\n(任务分解 + 调度)"]
    end

    subgraph Workers ["并行 Worker 池"]
        W1["Worker 1\n(GPU 1, 流 1)"]
        W2["Worker 2\n(GPU 2, 流 2)"]
        W3["Worker 3\n(GPU 3, 流 3)"]
        W4["Worker 4\n(GPU 4, 流 4)"]
    end

    subgraph PSModule ["Parallel-Synthesis 模块"]
        COLLECT["KV 缓存收集器\n(等待所有 Worker)"]
        REENC["位置重编码器\n(逐分支角度校正)"]
        MAP["缓存映射器\n(每层 φ^ℓ)"]
        SYN["综合 LLM\n(+ LoRA 适配器)"]
    end

    ORC --> W1 & W2 & W3 & W4
    W1 & W2 & W3 & W4 -->|"KV 缓存（非文本）"| COLLECT
    COLLECT --> REENC --> MAP --> SYN
    SYN --> OUT["最终答案\n(低首 token 延迟)"]

    style PSModule fill:#e8f5e8
    style Workers fill:#e8f0ff

框架层面唯一需要改动的 API：原来调用 synthesizer.generate(text=拼接文本)，改为 synthesizer.generate_from_caches(kv_list=worker_kv_caches, prompt=合成指令)。框架其余部分不变，只有 Worker 和 Synthesizer 之间的通信协议从文本改为 KV 缓存传输。

Parallel-Synthesis 与 Best-of-N 选择策略的比较

Best-of-N（BoN）是利用并行计算的另一种主流方法：采样 $N$ 份输出，用奖励模型或验证器打分，返回最高分。两者的核心差异：

维度	Best-of-N	Parallel-Synthesis
输出格式	从 $N$ 份中选一	生成全新综合答案
是否需要奖励模型	是	否
信息聚合	无（纯选择）	完整聚合 + 推理
TTFT 优势	无（仍需文本处理）	有（降低 2.5–11 倍）
复杂任务上限	受单 Worker 质量限制	可超越任意单 Worker

对于答案需要综合多个分支洞见的任务（多跳问答、复杂代码生成），综合策略严格优于选择策略。对于有明确对错的任务（算术、单元测试），带验证器的 BoN 在开销上可能更有竞争力。Parallel-Synthesis 在需要比较、推理和整合多分支输出的场景中更胜一筹。

与现有工作的关系

Parallel-Synthesis 位于三条研究线的交叉点：

1. KV 缓存共享/复用（VeriCache、GoldFinch、SGLang RadixAttention）：这些工作优化单智能体场景或文档检索中的缓存利用。Parallel-Synthesis 把它扩展到多智能体多对一综合场景。

2. 多智能体编排框架（AutoGen、MetaGPT、LangGraph）：这些框架在文本层面处理智能体通信。Parallel-Synthesis 提供了一个更底层的隐空间通信原语，可以作为即插即用组件集成进这些框架。

3. Transformer 间的隐状态通信（FusedSyn、TokenFusion 等）：研究在模型之间传递中间表示。Parallel-Synthesis 是针对智能体工作流 DAG 拓扑中多对一场景的首个系统性研究。

更广泛的意义与未来方向

走向原生隐空间智能体通信协议

这篇论文最深层的启示，是对「智能体应该如何通信」这一问题的重新审视。今天的多智能体系统建立在「文本作为通用接口」的假设上：每个智能体产出文本，每个智能体消费文本。这很实用、很通用，但也很低效——模型在生成过程中积累的全部计算工作（KV 状态的构建、上下文的注意力、中间表示的形成）在变成文本的一刻就被丢弃，下一个模型要重头编码一遍。

Parallel-Synthesis 是最早在综合瓶颈这一环节认真挑战这一假设的工作之一。合理的发展路径是：

1. 单步综合（本文）：Worker KV 缓存 → Synthesizer 直接消费。
2. 多跳隐状态路由：三个或更多 LLM 的链式调用，每个中间步骤都以 KV 缓存而非文本传递状态。
3. 异构隐状态翻译：跨模型的 KV 投影层（类似「隐空间翻译器」），让架构不同的智能体能共享状态。
4. 持久隐状态记忆：长期运行的智能体跨多轮积累 KV 状态，后续智能体接收的是原始缓存而非摘要。

这些方向指向一种根本不同的多智能体 AI 架构——「理解」以原始表示形式在智能体之间流动，而不是在每个边界处翻译成自然语言再翻回来。

对生产级智能体推理基础设施的影响

从系统角度看，Parallel-Synthesis 指向推理服务器的一个新设计点。当前 LLM 服务系统（vLLM、SGLang、TGI）的核心抽象是：一个请求就是一串 token 序列，服务器负责预填充这些 token 然后解码。Parallel-Synthesis 打破了这个抽象，引入了一种新的请求类型：请求预先携带由其他模型实例计算好的外部 KV 块。

这要求推理基础设施支持：

• 分布式 KV 缓存存储：Worker 的缓存必须跨 GPU 节点对 Synthesizer 可访问。
• 缓存版本验证：Synthesizer 必须确认 Worker 缓存由相同的基础模型权重（LoRA 之前）生成。
• 动态缓存拓扑：服务系统必须理解智能体工作流的 DAG 结构，而不只是单一请求序列。

OSDI、MLSys 等系统顶会在接下来 1–2 年内很可能会出现多篇解决上述基础设施挑战的论文，Parallel-Synthesis 的问题框架会成为出发点。

对工程实践的关键启示

对于当前在构建多智能体系统的工程师，本文有以下立即可行的洞察：

1. 重复预填充的代价是真实可测量的：如果你的 pipeline 有把多个并行 Worker 输出拼接后综合的步骤，测量一下综合步骤的 TTFT——对于短 Worker 输出，重复预填充大概率是首 token 延迟的主要瓶颈。

2. 位置重编码是零额外代价的改进：即使不训练 Parallel-Synthesis 的映射器和 LoRA，在任何缓存拼接实验前先做位置重编码（把所有分支键向量移到从 $n$ 开始），也能提升朴素缓存复用尝试的一致性。

3. 分支数 $m$ 的设计很重要：用不同 $m$ 做实验，了解你的任务域下的质量-效率权衡。TTFT 收益随 $m$ 线性增长；在大 $m$ 时质量可能因注意力稀释而下降，需要实验确定临界点。

4. 同骨干限制是硬约束：如果你的工作流使用了不同架构或大小的专用 Worker 模型，Parallel-Synthesis 目前无法直接应用，需要关注后续跨模型 KV 投影的工作。

总结

Parallel-Synthesis 提出了一个清晰、动机充分的贡献：识别出多智能体综合中的重复预填充低效问题，精确形式化该问题，提出三个协同组件（位置重编码、缓存映射器、Synthesizer LoRA），并在 9 个基准上给出有说服力的实验结果。2.5–11× 的 TTFT 降低对延迟敏感的交互式智能体应用具有实际价值。

剩余挑战——同骨干约束、GAIA 差距、Straggler 问题、显存开销——虽然真实存在，但都是可以系统研究的。最有影响力的后续工作方向是：（1）支持异构骨干的跨模型缓存投影；（2）$m$ 扩展性的系统实验。随着智能体系统规模增长（数十个并行 Worker、长多步轨迹），文本综合的低效将愈发突出——本文提出的缓存接口范式将变得越来越重要。

对于正在构建多智能体 pipeline 的工程师，位置重编码这一核心洞察（把所有分支缓存的起始位置锚定到分叉点 $n$）是立即可落地的：即使没有完整的训练好的系统，在缓存拼接前做 RoPE 位置修正，也很可能显著改善朴素缓存复用的效果。

快速参考

记住的核心公式：

缓存综合目标：

$$P_{kv}\!\left(\mathbf{y} \mid u, \{\text{KV}_\theta(z_j \mid c_j)\}_{j=1}^m\right) \approx P_{text}\!\left(\mathbf{y} \mid u, z_1, \ldots, z_m\right)$$

位置重编码修正：

$$K_{z,j,r}^{\ell,\text{new}} = R(n+r) \cdot R^{-1}(|c_j|+r) \cdot K_{z,j,r}^{\ell,\text{old}}$$

关键数据：

• 9 个数据集中 7 个：Parallel-Synthesis 与文本拼接基准持平或更优。
• 2.5–11×：TTFT 降低倍数范围。
• $m=4$：所有实验使用的分支数。
• $n$：共享前缀结束位置 / 分叉点。

实现 Parallel-Synthesis 的关键组件清单：

• 位置重编码（每分支 RoPE 角度修正）
• 逐层缓存映射器 $\phi^\ell$（线性或低秩，残差形式）
• Synthesizer LoRA（Q/K/V/O 投影，秩 32–128）
• 训练数据：持续预训练对话 + 多源综合任务 + 蒸馏数据
• 推理流程：收集分支缓存 → 位置重编码 → 缓存映射 → 合并 → 解码