AAFLOW+: Stateful Operator Abstraction with Zero-Copy Distributed KV Cache Orchestration for Multi-Agent Workflows

一、论文概述

项目	内容
标题	[AAFLOW+] Stateful Operator Abstraction with Zero-Copy Distributed KV Cache Orchestration for Multi-Agent Workflows
作者	Arup Kumar Sarker (ORCID: 0009-0006-2807-4986), Alexander James Halpern, Mills Staylor, Gregor von Laszewski, Geoffrey Fox, Yue Cheng, Aymen Alsaadi, Shantenu Jha
机构	University of Virginia / Biocomplexity Institute and Initiative; Rutgers University; Princeton Plasma Physics Laboratory
论文	https://arxiv.org/abs/2607.10987v1
代码	https://github.com/arupcsedu/AAFLOW (directory: `stateful_agentic_algebra`)
发布	2026-07-13
许可	CC BY 4.0 (Creative Commons Attribution 4.0)

二、核心思想

问题定义

现代多智能体 LLM 系统（如 ReAct、Reflexion、AutoGen、DSPy）日益整合检索、推理和工具调用，但根本上是基于文本的。共享上下文已经被计算过，下游智能体必须通过昂贵的前缀填充（prefill）操作重新计算该上下文。这种基于文本的通信方式导致：

重复预填计算（Repeated Prefill）：每个智能体独立处理相同的前缀上下文，导致预填成本被重复支付 k 次（k 为智能体数量）。
KV 缓存本地化：现有的 vLLM、SGLang 等推理系统仅将 KV 缓存作为局部优化，无法在分布式工作流层面跨智能体重用。
分支因子可扩展性差：Tree-of-Thought、多智能体辩论等场景下，共享前缀的每个分支都要单独重建模型状态。

传统工作流框架将 LLM 执行视为黑盒，智能体之间通过字符串交换数据。这掩盖了一个严重的系统级低效：下游智能体通常需要对上游产生的文本进行重新 tokenization 和前缀填充，才能产生新的输出。

解决方案概述

AAFLOW+ 是对 AAFLOW 的状态扩展，将 KV 缓存提升为一个一等分布式系统对象。核心创新包括：

从 Dataflow 到 Stateflow：扩展算子抽象，从仅处理外部数据流扩展到同时处理内部模型执行状态（KV 缓存）。
显式 KV 状态算子族：定义了 materialize（物化）、transfer（传输）、fork（分叉）、restricted merge（受限合并）和 eviction（驱逐）等算子。
零拷贝传输感知执行：使用 Arrow-based 元数据格式和 UCX/MPI 高性能通信框架，实现 KV 张量缓冲区的零拷贝直接传输。
成本驱动的调度决策：通过比较传输成本与重算成本的调度策略 $\pi(S)$ ，决定使用状态复用还是文本重计算。
正确性约束：确保模型兼容性、位置编码兼容性和谱系一致性三个不变量。

实验结果表明，AAFLOW+ 在多智能体 LLM 系统中大幅减少了冗余预填计算：TTFT 最高降低 50.2 倍，16 智能体规模下多智能体延迟降低 7.63 倍，峰值 KV 内存减少 1.72-6.10 倍，吞吐量提升超过 7.74 倍。

三、技术架构

整体框架图

┌───────────────────────────────────────────────────────────────┐
│                    AAFLOW+ System Architecture                 │
├───────────────────────────────────────────────────────────────┤
│                                                               │
│  ┌─────────────┐    ┌─────────────┐    ┌──────────────────┐   │
│  │ Stateful     │   │KV-State      │   │ State-Aware      │   │
│  │ Compiler     │   │ Manager      │   │ Scheduler        │   │
│  │              │   │              │   │                  │   │
│  │ W → G_s=(V,  │   │ KV={B_1,..., │   │ π(S):            │   │
│  │          E_d,│   │  ...,B_n}     │   │   transfer vs    │   │
│  │          E_s)│   │ Arrow format │   │   recompute      │   │
│  └──────┬───────┘   └──────┬───────┘   └────────┬─────────┘   │
│         │                   │                     │             │
│  ┌──────▼───────────────────▼─────────────────────▼─────────┐  │
│  │              Execution Runtime                            │  │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────────────────┐   │  │
│  │  │Op_kv_mat-│  │Op_kv_fork│  │ Op_kv_transfer/merge │   │  │
│  │  │ erialize  │  │          │  │ & eviction           │   │  │
│  │  └────┬─────┘  └────┬─────┘  └──────────┬───────────┘   │  │
│  └───────┼──────────────┼───────────────────┼───────────────┘  │
│          │              │                   │                    │
│  ┌───────▼──────────────▼───────────────────▼──────────────┐   │
│  │              Transport Subsystem                          │   │
│  │  UCX / MPI / RDMA for zero-copy tensor buffer transfer  │   │
│  │  Apache Arrow for metadata (columnar, zero-copy)         │   │
│  └──────────────────────────┬──────────────────────────────┘   │
│                             │                                    │
│  ┌──────────────────────────▼──────────────────────────────┐   │
│  │              LLM Backend Adapters                         │   │
│  │  Hugging Face │ vLLM (PagedAttention) │ SGLang (RadixAttn)│   │
│  └─────────────────────────────────────────────────────────┘   │
└───────────────────────────────────────────────────────────────┘

Figure 1: Layered architecture of stateful operator abstraction (详见图 1)。设计扩展了 AAFLOW 风格的算子执行，带有显式的 KV 状态物化、分叉、传输、合并和驱逐。

Figure 2: Textflow 强制下游智能体重播上下文，而 stateflow 传输可复用的 KV 执行状态。

Figure 3: 基于文本的多智能体执行在共享同一上下文的分支间复制了预填计算。

核心公式

公式 (1) - 工作流的算子集合：

$W=\{Op_{embed},Op_{retrieve},Op_{reason},Op_{memory},Op_{upsert}\}, \tag{1}$

公式 (2) - 单个算子的定义：

$Op_{i}=(I_{i},O_{i},f_{i},P_{i}). \tag{2}$

公式 (3) - 编译为执行图：

$G=Compile(W), \tag{3}$

公式 (4) - 预填成本：

$T_{prefill}(L). \tag{4}$

公式 (5) - 单智能体总执行时间：

$T_{agent}=T_{prefill}(L)+T_{decode}(Y)+\Omega, \tag{5}$

公式 (6) - k 个智能体基于文本的总成本：

$T_{text}^{k}\approx k\cdot T_{prefill}(L)+\sum_{j=1}^{k}T_{decode}(Y_{j})+\Omega_{text}. \tag{6}$

公式 (7) - 状态执行优于文本执行的条件：

$T_{transfer}(KV)+T_{resume}+\Omega_{state}<T_{prefill}(L)+\Omega_{text}. \tag{7}$

公式 (8) - 状态化算子扩展定义：

$Op_{i}^{s}=(I_{i},O_{i},S_{i}^{in},S_{i}^{out},f_{i},P_{i},\sigma_{i}). \tag{8}$

其中 $S_{i}^{in}$ 和 $S_{i}^{out}$ 表示输入和输出状态对象， $\sigma_{i}$ 表示与该算子关联的状态策略。

公式 (9) - 状态化执行图：

$G_{s}=(V,E_{d},E_{s}), \tag{9}$

其中 $V$ 是算子节点集合， $E_{d}$ 捕获数据依赖， $E_{s}$ 捕获对应于 KV 缓存流的状态依赖。

公式 (10) - KV 状态对象定义：

$S_{KV}=(M,\Theta,B,\Pi,\Lambda,\Gamma), \tag{10}$

其中 $M$ 是模型标识符， $\Theta$ 是模型和词元器配置， $B$ 是 KV 块集合， $\Pi$ 是位置元数据， $\Lambda$ 是谱系元数据， $\Gamma$ 描述放置和所有权。

公式 (11) - KV 块集合：

$B=\{b_{1},b_{2},\dots,b_{m}\}, \tag{11}$

公式 (12) - 单个 KV 块结构：

$b_{j}=(K_{j},V_{j},\ell_{j},r_{j},d_{j}). \tag{12}$

其中 $K_{j}$ 和 $V_{j}$ 是键值张量， $\ell_{j}$ 是层索引， $r_{j}$ 是词元位置范围， $d_{j}$ 是设备或内存域。

公式 (13) - 状态兼容性判定：

$Compat(S_{a},S_{b})=\mathbb{1}[M_{a}=M_{b}]\cdot\mathbb{1}[\Theta_{a}=\Theta_{b}]\cdot\mathbb{1}[\Pi_{a}\sim\Pi_{b}], \tag{13}$

公式 (14) - KV 物化算子：

$Op_{kv\_materialize}(x,M)\rightarrow S_{KV}. \tag{14}$

公式 (15) - KV 传输算子：

$Op_{kv\_transfer}(S_{KV},n_{a},n_{b})\rightarrow S^{\prime}_{KV}. \tag{15}$

公式 (16) - KV 分叉算子：

$Op_{kv\_fork}(S_{KV},k)\rightarrow\{S_{KV}^{(1)},S_{KV}^{(2)},\dots,S_{KV}^{(k)}\}. \tag{16}$

公式 (17) - 受限合并算子：

$Op_{kv\_merge}(S_{1},S_{2},\mu)\rightarrow S^{*}. \tag{17}$

公式 (18-20) - 文本执行 vs 状态执行成本：

$T_{text}=T_{prefill}(L)+T_{decode}(Y)+\Omega_{text} \tag{18}$

$T_{state}=T_{transfer}(S_{KV})+T_{resume}+T_{decode}(Y)+\Omega_{state} \tag{19}$

$T_{state}<T_{text} \tag{20}$

公式 (21) - 条件展开：

$T_{transfer}(S_{KV})+T_{resume}+\Omega_{state}<T_{prefill}(L)+\Omega_{text}. \tag{21}$

公式 (22-23) - 分支工作流的成本对比：

$T_{text}^{k}=k\cdot T_{prefill}(L)+\sum_{j=1}^{k}T_{decode}(Y_{j})+\Omega_{text}^{k}. \tag{22}$

$T_{state}^{k}=T_{prefill}(L)+T_{fork}(S_{KV},k)+\sum_{j=1}^{k}T_{decode}(Y_{j})+\Omega_{state}^{k}. \tag{23}$

公式 (24) - 预期节省：

$\Delta T=(k-1)T_{prefill}(L)-T_{fork}(S_{KV},k)-(\Omega_{state}^{k}-\Omega_{text}^{k}). \tag{24}$

公式 (25) - KV 块序列表示：

$KV=\{B_{1},B_{2},\dots,B_{n}\} \tag{25}$

公式 (26) - 典型分支工作流表达式：

$Op_{kv\_materialize}\rightarrow Op_{kv\_fork}\rightarrow\{Op_{reason}^{(1)},\dots,Op_{reason}^{(k)}\}\rightarrow Op_{kv\_merge}. \tag{26}$

公式 (27) - 传输 vs 重算调度策略：

$\pi(S)=\begin{cases}\text{transfer},&\text{if }T_{transfer}<T_{prefill}\\\text{recompute},&\text{otherwise}\end{cases} \tag{27}$

公式 (28-30) - 编译与传输模型：

$v_{i}=(Op_{i}^{s},\mathcal{R}_{i},\mathcal{L}_{i}) \tag{28}$

$\mathcal{M}:(state\_id,block\_id)\rightarrow(device,address) \tag{29}$

$T_{transfer}=\frac{|KV|}{BW}+\delta \tag{30}$

公式 (31-32) - 扩展分支简化成本：

$T_{text}^{k}=k\cdot T_{prefill}(L) \tag{31}$

$T_{state}^{k}=T_{prefill}(L)+k\cdot T_{decode} \tag{32}$

公式 (33-39) - 评估指标公式：

$TTFT=T_{prefill}+T_{queue}+\Omega \tag{33}$

$T_{total}=T_{prefill}+T_{decode}+\Omega \tag{34}$

$\Omega=T_{total}-(T_{prefill}+T_{decode}) \tag{35}$

$Throughput=\frac{\text{Total tokens generated}}{T_{total}} \tag{36}$

$Mem_{KV}=\max_{t}\sum_{i}|KV_{i}(t)| \tag{37}$

$Reuse=\frac{\text{Tokens served from KV cache}}{\text{Total tokens processed}} \tag{38}$

$Efficiency=\frac{T_{prefill}-T_{transfer}}{T_{prefill}} \tag{39}$

公式 (40) - 根上下文工作流模式：

$\texttt{root context}\rightarrow\texttt{KV materialize}\rightarrow\texttt{KV fork}\rightarrow\{\texttt{agent}_{1},\ldots,\texttt{agent}_{k}\}\rightarrow\texttt{merge} \tag{40}$

公式 (41-43) - 实验分析模型：

$TTFT_{\mathrm{state}}\approx T_{\mathrm{transfer}}+T_{\mathrm{resume}} \tag{41}$

$T^{k}_{\mathrm{state}}\approx T_{\mathrm{prefill}}+k\cdot T_{\mathrm{decode}} \tag{42}$

$T_{\mathrm{transfer}}=\frac{\mathrm{KV\ bytes}}{\mathrm{bandwidth}}+\mathrm{latency} \tag{43}$

公式 (44) - 调度策略综合决策：

$\pi(S)=\begin{cases}reuse,&S\text{ is local and compatible}\\transfer,&T_{\mathrm{transfer}}<T_{\mathrm{prefill}}\\recompute,&otherwise.\end{cases} \tag{44}$

公式 (45) - 传输与重算对比：

$T_{\mathrm{transfer}}=\frac{\mathrm{KV\ bytes}}{\mathrm{bandwidth}}+\mathrm{latency},\qquad T_{\mathrm{recompute}}=T_{\mathrm{prefill}} \tag{45}$

模型组件

组件	说明	关键参数
Stateful Compiler	将智能体工作流编译为包含数据边和状态边的执行图	$W \rightarrow G_s=(V, E_d, E_s)$ , $C_i$ 兼容性约束
KV-State Manager	跟踪块级 KV 元数据、所有权、谱系和放置	$\mathcal{M}:(state\_id, block\_id) \rightarrow (device, node, address, range, owner)$
Transport Subsystem	使用 Arrow 元数据和 UCX/RDMA 风格通信跨设备/节点移动 KV 块	$T_{transfer} =
State-Aware Scheduler	决定是否传输、复用、分叉、驱逐或重算状态	$\min\sum_i T_i + \lambda \cdot Mem_i$
Execution Runtime	协调后端调用，通过 HF/vLLM/SGLang 兼容执行路径	KV-aware API 注入

Figure 4: KV 状态的生命周期，从创建到复用到驱逐。

Figure 5: 状态化算子抽象将常规推理算子与 KV 状态算子组合。虚线边表示状态依赖。

Figure 6: 系统架构图，展示编译器、运行时、KV 状态层和传输之间的交互。

训练流程

AAFLOW+ 的工作流执行分为以下阶段：

状态感知的编译阶段：给定工作流 $W$ ，编译器构建状态化执行图 $G_s = (V, E_d, E_s)$ ，其中 $V$ 表示算子实例， $E_d$ 表示普通数据依赖， $E_s$ 表示 KV 状态依赖。每个顶点标注为 $v_i = (Op_i^s, R_i, L_i, C_i)$ 。
KV 物化：共享前缀被预填充一次，生成 KV 状态对象 $S_{KV}$ 。这是唯一需要支付完整预填成本的步骤。
KV 分叉：为多个并行推理分支创建逻辑后代。分叉默认不复制整个 KV 张量，而是创建共享前缀块的逻辑子代（copy-on-write 行为）。
传输决策：对于远程分支，调度器根据成本模型决定传输还是重算。当 $T_{transfer} < T_{prefill}$ 时选择传输。
KV 恢复：智能体从导入的 KV 状态直接开始解码，跳过重复的预填阶段。
受限合并：使用保守的合并规则对分支输出进行有控制的聚合，避免任意张量混合。
驱逐管理：当内存压力超过阈值时，基于评分函数 $\alpha \cdot reuse(S) - \beta \cdot size(S) - \gamma \cdot age(S)$ 驱逐低优先级状态。

四、核心创新

创新点	说明	理论/实验依据
KV 缓存作为一等分布式系统对象	将 KV 缓存从局部推理优化提升为分布式工作流中可编排的状态对象，支持物化、传输、分叉、合并和驱逐	公式 (7) 证明 $T_{transfer}(KV) + T_{resume} + \Omega_{state} < T_{prefill}(L) + \Omega_{text}$ 时，状态执行优于文本执行
状态化算子抽象扩展	从 dataflow 扩展到 stateflow，引入 5 个 KV 状态算子（materialize/transfer/fork/merge/evict），扩展算子定义为 7-tuple $(I, O, S^{in}, S^{out}, f, P, \sigma)$	公式 (8)-(17)，状态边的引入使调度器可以在重新计算之前推理局部性、复用和传输
零拷贝传输感知执行	使用 Apache Arrow 列式元数据和 UCX/MPI RDMA 直接传输原始 KV 块张量缓冲区，元数据与张量缓冲区分离传输	公式 (30) 传输成本模型；实验 3 显示在 400 Gbps 下传输速度比重算快 113.88 倍
成本驱动的分叉优化	将分支维度从重复预填转换为从已物化状态的重复解码延续， $\Delta T = (k-1)T_{prefill}(L) - T_{fork}(S_{KV},k) - (\Omega_{state}^k - \Omega_{text}^k)$	16 智能体规模下延迟降低 7.63 倍（表 3）
安全性保证的兼容性约束	定义了三重不变量：模型兼容性、位置编码兼容性和谱系一致性，不兼容时回退到文本重放	公式 (13) $Compat(S_a, S_b)$ ，保守设计防止不安全复用
传输 vs 重算调度决策	基于网络带宽的成本模型决定何时使用传输而非重计算	实验 3：在 10 Gbps 链接上仅 5/8 个上下文有益，在 25 Gbps 及以上所有上下文均受益

五、代码实现分析

代码仓库: https://github.com/arupcsedu/AAFLOW

实验代码目录: stateful_agentic_algebra/

关键实现细节:

后端适配：AAFLOW+ 兼容三个 LLM 推理后端——Hugging Face (HF)、vLLM (PagedAttention) 和 SGLang (RadixAttention)。适配器从 past_key_values 提取 KV 元数据。
通信层：使用 UCX 和 NCCL 实现通信。Mistral-7B、vLLM 和 SGLang 采用 Apache 2.0 许可，Llama-3-8B 采用 Meta Llama 3 Community License。
实验配置：
- 硬件：4-16 节点 GPU 集群，每节点配备 NVIDIA A100 (80GB/40GB)、32-64 CPU 核心、RDMA 启用 InfiniBand 互连
- 状态传输模型：bandwidth_bytes_per_sec = 25,000,000,000（25 GB/s 或 200 Gbps），network_latency_sec = 50us，resume_overhead_sec = 0.1ms
环境变量：所有环境设置和依赖项写入 stateful_agentic_algebra/Readme.md 文件。

当前未提供完整的源代码下载链接，但代码已公开在 GitHub 仓库中。

六、实验结果

基准测试

实验 1：TTFT 降低（表 2 / 表 8，图 7）

实验在 HF+Mistral、HF+Llama3 以及 vLLM/SGLang 后端上进行，比较不同基线在不同上下文长度下的平均 TTFT。

表 2 - 核心结果（HF 后端，最大上下文）：

模型	基线	平均 TTFT (s)	相对 AAFLOW+
Mistral	AAFLOW+	0.041	1.00x
Mistral	Dense Prefill	2.017	49.2x 慢
Mistral	AAFLOW-text	2.057	50.2x 慢
Mistral	vLLM Local Prefix	0.437	10.7x 慢
Mistral	SGLang Prefix	0.280	6.8x 慢
Mistral	KVCOMM	0.704	17.2x 慢
Mistral	DistServe Style	0.123	3.0x 慢
Llama3	AAFLOW+	0.030	1.00x
Llama3	Dense Prefill	0.499	16.6x 慢
Llama3	AAFLOW-text	0.509	17.0x 慢
Llama3	vLLM Local Prefix	0.124	4.1x 慢
Llama3	SGLang Prefix	0.086	2.9x 慢
Llama3	KVCOMM	0.187	6.2x 慢
Llama3	DistServe Style	0.052	1.7x 慢

表 8 - 多后端扩展结果（最大上下文 32768）：

后端	Mistral AAFLOW+	Mistral Dense/Text	Mistral 最佳非-AAFLOW+
HF	0.041s	2.017/2.057s	DistServe 0.123s
vLLM	0.116s	20.026/20.425s	DistServe 0.197s
SGLang	0.629s	7.396/7.531s	DistServe 0.710s

最大上下文（32768 tokens，Mistral on vLLM）：AAFLOW+ 为 0.171s，Dense prefill 为 38.880s，AAFLOW-text 为 39.655s，KVCOMM 为 13.315s，DistServe 为 0.316s。

在 SGLang 后端最大上下文：AAFLOW+ 为 0.876s，而 dense prefill 为 13.317s，AAFLOW-text 为 13.566s，KVCOMM 为 5.089s，DistServe 为 1.021s。

最高降低倍数：50.2x（Mistral on HF, AAFLOW-text vs AAFLOW+）。

实验 2：多智能体缩放（表 3 / 表 9，图 8）

在 HF 后端使用 32768 上下文大小的缩放基准测试结果：

模型	智能体数	AAFLOW+ (s)	Dense (s)	SGLang (s)	效率增益 EG
Mistral	1	30.700	169.757	119.135	3.88x
Mistral	2	30.700	339.514	224.850	7.32x
Mistral	4	58.371	679.027	436.281	7.47x
Mistral	8	113.714	1358.055	859.142	7.56x
Mistral	16	224.399	2716.109	1704.865	7.60x
Llama3	1	29.067	143.959	112.396	3.87x
Llama3	2	29.067	287.918	216.891	7.46x
Llama3	4	56.351	575.836	425.880	7.56x
Llama3	8	110.918	1151.671	843.858	7.61x
Llama3	16	220.052	2303.342	1679.815	7.63x

关键观察：1 智能体和 2 智能体的 AAFLOW+ 延迟相同（利用可用的状态化并行宽度），之后成本以 “波浪” 增长而非完整重复预填。

多后端扩展（表 9）：vLLM 后端 16 智能体时，Mistral AAFLOW+ 为 465.45s，SGLang prefix 为 3532.56s（7.59x）。SGLang 后端，Mistral AAFLOW+ 为 701.29s，SGLang prefix 为 5363.03s（7.65x）。

最大效率增益：7.63x（Llama3 on HF, 16 agents vs SGLang）。

实验 3：传输 vs 重计算（表 10，图 9）

评估调度器的传输-重计算决策：

带宽	有益上下文数 (Mistral/HF)	Transfer vs Recompute Speedup (HF/vLLM/SGLang)
10 Gbps	5/8 (Mistral), 1/6 (Llama3)	2.46x / 2.54x / 2.86x (Mistral)
25 Gbps	8/8	6.14x / 6.35x / 7.14x (Mistral)
100 Gbps	8/8	24.54x / 25.39x / 28.55x (Mistral)
200 Gbps	8/8	49.04x / 50.73x / 57.04x (Mistral)
400 Gbps	8/8	97.90x / 101.29x / 113.88x (Mistral)

Llama3 在 400 Gbps 达到最高速度提升：102.77x（HF 后端）。

关键结论：在慢速 10 Gbps 链接上，重算可能更优（某些上下文）。在 25 Gbps 及以上，传输在所有测试上下文下均占优。

实验 4：内存效率（表 4 / 表 11，图 10）

峰值 KV 内存比较（最大上下文，所有分支因子 1/2/4/8/16 的平均值）：

模型	基线	峰值 KV 内存 (GiB)	比率
Mistral	AAFLOW+	8.355	1.00x
Mistral	Dense Prefill	49.987	5.98x 更大
Mistral	AAFLOW-text	53.986	6.46x 更大
Mistral	vLLM Local Prefix	14.351	1.72x 更大
Mistral	SGLang Prefix	14.591	1.74x 更大
Mistral	KVCOMM	15.702	1.88x 更大
Mistral	DistServe Style	50.995	6.10x 更大
Llama3	AAFLOW+	4.210	1.00x
Llama3	Dense Prefill	25.188	5.98x 更大
Llama3	AAFLOW-text	27.202	6.46x 更大
Llama3	vLLM Local Prefix	7.231	1.72x 更大
Llama3	SGLang Prefix	7.311	1.73x 更大
Llama3	KVCOMM	7.912	1.88x 更大
Llama3	DistServe Style	25.695	6.10x 更大

多后端结果（表 11）：vLLM 后端 Mistral AAFLOW+ 为 8.290 GiB，SGLang 后端同为 8.290 GiB，在所有三个后端上保持最低内存占用。

最大内存降低：6.46x（Mistral AAFLOW-text vs AAFLOW+）。

实验 5：吞吐量和框架开销（表 5 / 表 12，图 9）

模型	基线	吞吐量 (tok/s)	Ω (s)
Mistral	AAFLOW+	302.61	0.0075
Mistral	Dense Prefill	31.94	0.0019
Mistral	AAFLOW-text	31.84	11.1659
Mistral	vLLM Local Prefix	38.81	0.0627
Mistral	SGLang Prefix	39.62	0.0657
Mistral	KVCOMM	35.59	21.6770
Mistral	DistServe Style	37.62	0.0597
Llama3	AAFLOW+	300.57	0.0075
Llama3	Dense Prefill	33.61	0.0019
Llama3	AAFLOW-text	33.54	6.7272
Llama3	vLLM Local Prefix	38.46	0.0627
Llama3	SGLang Prefix	39.27	0.0657
Llama3	KVCOMM	36.16	13.0375
Llama3	DistServe Style	37.46	0.0597

多后端扩展（表 12）：

HF 后端 Mistral: AAFLOW+ 302.61 tok/s, vLLM 280.30 tok/s, SGLang 207.09 tok/s
Llama3: HF 300.57 tok/s, vLLM 314.26 tok/s, SGLang 256.84 tok/s
AAFLOW-text 在 vLLM 后端出现高开销：Mistral 89.5948s, Llama3 47.4580s
KVCOMM 开销更高：vLLM 后端 Mistral 达 174.3231s

吞吐量优势：对比 dense prefill 约 9.47x，对比 SGLang prefix 约 7.63x-8.04x。

消融实验

AAFLOW+ 的关键组件消融体现在：

AAFLOW-text（移除 KV 状态，仅保留数据流）：TTFT 比 AAFLOW+ 慢 50.2x（Mistral HF），验证了 KV 状态传输的核心价值。
Dense Prefill（无前缀共享）：内存消耗比 AAFLOW+ 大 5.98x，吞吐量仅为 AAFLOW+ 的 ~1/9.5。
vLLM/SGLang Local Prefix（仅本地复用）：在分布式多智能体场景中，本地前缀复用无法消除工作流级别的分支重复，导致 6.8-10.7x 更慢的 TTFT。

与现有方法对比

对比维度	AAFLOW+	vLLM Local Prefix	SGLang Prefix	DistServe	KVCOMM
分布式 KV 传输	支持	不支持	不支持	部分	有限
工作流级抽象	完整 7-tuple 算子	无	无	无	仅通信
状态分叉	支持	不支持	不支持	不支持	不支持
谱系追踪	完整 Λ 元数据	无	无	无	部分
传输决策	成本驱动	N/A	N/A	N/A	静态
跨后端兼容	HF/vLLM/SGLang	vLLM only	SGLang only	N/A	N/A

七、相关工作

分布式数据系统与算子抽象：MapReduce、Spark、Flink 等展现了声明式数据变换如何编译为高效分布式执行计划。Modin、Cylon 将这一范式扩展到高性能 DataFrame。AAFLOW 将这些思想应用到智能体工作流中。AAFLOW+ 进一步扩展为状态化算子。

工作流运行时与分布式执行：Ray、Dask、Parsl 提供灵活的任务执行框架；RADICAL-Pilot、Pegasus 关注大规模科学工作流。但这些系统将任务视为独立单元，未显式建模 LLM 特定状态如 KV 缓存。

LLM 编程与智能体框架：LangChain、LangGraph、AutoGen、DSPy 专注于提高 LLM 应用的可表达性和可组合性，但大部分忽略了数据传输和状态重计算的底层系统成本。

LLM 推理与 KV 缓存优化：vLLM 的 PagedAttention、SGLang 的 RadixAttention、FlexGen 的 offloading、DistServe/LMCache 的解耦预填/解码。这些系统的优化局限在单机或单请求环境中，未将 KV 缓存暴露为跨多个智能体的分布式系统对象。

分布式多租户 LLM 服务：Orca、Sarathi、Helix 关注吞吐量和公平性，未显式考虑独立请求或智能体间的 KV 状态复用。

检索增强生成与记忆系统：MemoRAG、HippoRAG、CueRAG 等展示了持久记忆对多步推理的重要性，但大多将记忆视为外部数据而非内部模型状态。

八、总结

核心贡献

Stateful Operator Abstraction: 将 AAFLOW 的数据流扩展为 stateflow，定义了 5 个 KV 状态算子（materialize, transfer, fork, restricted merge, eviction）和 7-tuple 算子形式化定义。
Distributed KV-State Object: 提出 $S_{KV} = (M, \Theta, B, \Pi, \Lambda, \Gamma)$ 结构化表示，包含模型标识、配置、KV 块、位置元数据、谱系和放置信息，确保安全复用的三重不变量。
Zero-Copy Transfer with Cost-Driven Scheduling: 使用 Apache Arrow 元数据和 UCX/RDMA 实现零拷贝传输，配合调度策略 $\pi(S)$ 动态决策传输 vs 重计算。
Comprehensive Evaluation: 在 Mistral-7B 和 Llama-3-8B 上的五组实验覆盖 TTFT（最高降低 50.2x）、多智能体缩放（7.63x）、传输 vs 重计算分析（最高 113.88x）、内存效率（6.10x 降低）和吞吐量（9.47x 提升），并在三种后端（HF、vLLM、SGLang）上进行了全面验证。

技术影响

AAFLOW+ 将 KV 缓存管理从局部推理优化提升到了分布式工作流层面，使得多智能体 LLM 系统能够像分布式数据系统管理 partition 和 buffer 一样，显式地物化、传输、分叉、复用和驱逐 KV 状态。这对于共享前缀的多智能体工作流（如 Tree-of-Thought、多智能体辩论、协作式 RAG）具有显著的效率提升潜力。

局限性

工作负载限制：使用合成确定性提示词，未在外部数据集上评估答案质量；主要输出长度为 Y=64 tokens，更长输出会降低预填复用收益。
模型同质性假设：当前兼容性约束假设相同的模型架构和位置编码，不支持异构模型环境中的混合调度。
受限合并：目前仅支持严格非重叠顺序拼接，不支持任意张量混合。
未约束内存评估：定义了驱逐和内存受限调度的架构目标，但仅评估了无约束内存场景。
基础设施基于受控实验：评估基于控制实验而非生产集群数据。

未来方向

扩展到异构模型环境（不同架构、适配器、微调变体）
动态带宽估计和工作负载预测的成本感知调度
与非 Transformer 架构（如状态空间模型）的集成
大规模部署的高效检查点、部分状态恢复和 KV 状态持久存储
面向开发者的 stateflow 编程抽象和可视化工具

九、参考资源

arXiv 页面: https://arxiv.org/abs/2607.10987v1
PDF 下载: https://arxiv.org/pdf/2607.10987v1
GitHub 代码: https://github.com/arupcsedu/AAFLOW
实验代码目录: stateful_agentic_algebra/
许可证: CC BY 4.0
原始 HTML: /tmp/paper4.html
论文编号: arXiv:2607.10987v1 [cs.DC], 2026-07-13