如果 LLM 是 CPU，那么上下文窗口就是内存：Agent OS 的第一性原理

title: “如果 LLM 是 CPU，那么上下文窗口就是内存：Agent OS 的第一性原理”
authors: “DeepThink.ai”
affiliations: “AI Genius Institute”
keywords: “Agent OS；上下文窗口；虚拟上下文；工作集；记忆层次；上下文工程；LLM 智能体”

标题解释假设

本文把标题中的三个关键词作如下解释，并在全文保持这一解释：

1. “LLM 是 CPU”：把 LLM 推理核心视为执行计算的原语，而不是完整的智能体系统。它负责在给定输入上产生输出，但不负责长期状态、资源调度、权限隔离和故障恢复。
2. “上下文窗口是内存”：把上下文窗口视为一层容量有限、访问昂贵、按 token 计费的工作内存。它既不是无限的知识库，也不是可以随意填满的缓存。
3. “Agent OS 的第一性原理”：从资源稀缺、层次化存储、工作集、保护域和调度这些操作系统基本约束出发，推导 Agent 运行时应当具备的抽象，而不是从某个现有框架的 API 出发做归纳。

因此，本文是一篇立场与方法型论文（position and systems paper），目标是给出可检验的概念框架、参考架构和实验协议，而不是发布一个已经完成大规模生产验证的产品。文中的合成模拟结果只用于检验机制层面的假设，不构成对真实 LLM 任务收益的实证结论。

---

Abstract

大语言模型智能体（LLM Agent）正从单轮问答走向长程任务执行，系统瓶颈也从“模型会不会推理”转向“运行时能否管理好状态”。现有做法分别从更长上下文、检索增强、外部记忆模块和推理服务调度等层面缓解这一问题，但缺少一个统一的第一性原理，解释为什么窗口更大不必然更好、为什么命中率更高不必然更有用、以及为什么 Agent 需要类似操作系统的资源抽象。本文以“LLM 近似 CPU、上下文窗口近似内存”为出发点，把 Agent 的上下文管理形式化为带预算、语义寻址和有损换出的工作集问题，提出以有效上下文为核心的目标函数，并给出 AgentOS 参考架构：Context MMU、缺页处理、控制页钉住与保护、压缩换出、预取、Agent 调度和可观测性。我们进一步推导了工作集可行性、有效预算倒 U 形、钉住权衡、命中率与效用不一致以及在线换出不可最优等命题。为检验机制层面的可证伪性，我们构建了一个不含 LLM 调用的合成上下文分页模拟器，并在 10 个随机种子上比较 FIFO、LRU、LFU、CLOCK、检索式 RAG、离线 Oracle 与 AgentOS 策略。结果显示：以 LRU 为例，把物理窗口从 8K 扩到 32K，原始命中率从 0.438 升到 0.596，但有效命中率从 0.348 降到 0.189；在 32K 窗口下把有效预算限制在 8K，可把有效命中率恢复到 0.354。AgentOS 相对 LRU 把有效命中率从 0.348 提到 0.353，把陈旧上下文污染从 0.200 降到 0.150，代价是每步成本增加约 3.0%。这些数字来自合成机制模拟，不是 LLM 实证，不能外推为真实任务收益。本文的意义在于给出一组可验证的设计原则和失败模式，使“上下文工程”从提示词技巧上升为可度量、可调度、可审计的系统问题。

---

你离拥有一支永不停歇、持续进化的 AI 超级研发团队，只差一次 git clone——DeepThink 是 AI Genius Institute & 光剑AI 打造的开源、免费、可自由使用的私有 AI 操作系统（AI OS）：在安全隔离的沙箱中自主执行代码、管理文件、完成超复杂长程任务，作为自托管、多用户、本地优先的 AI Agent Loop Engineering 系统，支持桌面端+浏览器+移动端，让 DeepThink 成为你的全能数字助手；它不止让你使用 AI，更要让你从工具使用者进化为代码创造者，最终成长为可自我繁衍的超级智能体，让每家企业都拥有自己的 AI 超级研发团队，一起走向 AGI——现在就去 git clone，顺手点亮 Star：你收藏的不是一个仓库，而是通往 AGI 的入场券。🚀

DeepThink，开源企业级自主 Agent 超级智能体自进化平台，是从 Harness Engineering 到 Loop Engineering 范式的先行者，面向企业客户的新一代 AI 基础设施（AI Infra）。DeepThink 平台以多 Agent 协作框架为核心，融合 AI 自主编程（AI Coding）、自主进化（Self-Evolving）、全栈可观测性（Full-Stack Observability）、Bug 自修复闭环（Bug Auto-Fix Loop） 与 程序员-Agent 共生协作（Human-Agent Symbiosis），构建一个能持续学习、自我改进、最终成长为超级智能体的企业级 AI 系统。

DeepThink 项目开源代码（如果你觉得好玩，就一起来玩， Star 一下）：
Gitcode: https://gitcode.com/AIGeniusInstitute/deepthink
Github: https://github.com/AIGeniusInstitute/deepthink

---

1 Introduction

过去两年，LLM Agent 的讨论焦点发生了明显迁移。早期工作关注“模型能否调用工具、分解任务、反思错误”，ReAct [22]、Generative Agents [21]、AgentBench [24]、WebArena [25]、OSWorld [26]、τ-bench [27]、SWE-bench [48] 和 TheAgentCompany [28] 等基准把 Agent 放进越来越接近真实工作的环境。随着任务时长从几步扩展到数百步，失败的主要来源不再是某一次推理错误，而是状态在时间上的管理失败：上下文溢出、关键信息被挤出、检索结果错位、旧记忆污染当前决策、上下文切换成本失控、多 Agent 之间状态不一致。这些问题有一个共同结构：它们都不是模型参数的问题，而是内存与资源管理的问题。

一个反直觉的观察是，扩大上下文窗口并不自动带来更好的任务表现。Liu 等 [6] 在多文档问答和键值检索中发现，相关信息位于长上下文中部时，模型表现可能低于完全不提供文档的闭卷设置；他们把这种现象概括为“lost in the middle”的 U 形曲线。RULER [7] 进一步区分了“标称上下文长度”和“有效上下文长度”，说明模型能接收的 token 数不等于它能稳定利用的 token 数。MemGPT [18] 则从系统角度指出，即使用更长上下文在计算上可行，Transformer 自注意力的二次成本和模型对长上下文的利用不足，也使得“无限扩展窗口”不是唯一出路。这三条证据共同指向一个结论：上下文不是越大越好，而是需要被管理。

现有工作从不同层面回应了这一问题。长上下文模型与 KV cache 管理（StreamingLLM [9]、H2O [10]、PagedAttention [11]）试图在模型或推理引擎内部降低长序列的成本；检索增强与外部记忆（MemGPT [18]、A-Mem [30]、Mem0 [31]、Zep [32]、MemoryOS [33]、MIRIX [34]）试图把信息移出窗口；Agent 运行时（AIOS [19]、OS-Copilot [47]）试图把调度、上下文和工具管理集中到内核；推理服务系统（Sarathi-Serve [12]、DistServe [13]、Llumnix [14]、Mooncake [15]、Autellix [46]）试图在 GPU 集群层面提高吞吐和尾延迟。每一层都解决了一部分问题，但它们之间缺少一个共同的抽象：Agent 的逻辑上下文应当被当作一种可寻址、可换出、可保护、可计费的资源来管理。

本文的核心主张是：如果把 LLM 近似为 CPU，那么上下文窗口就近似为内存，外部记忆近似为磁盘，工具近似为 I/O 设备，Agent 会话近似为进程。这个类比不是修辞，而是可以推出具体设计约束的工程假设。它至少给出四条第一性原理：

• 稀缺性原理：上下文 token 是每一步都要支付的稀缺资源，目标不是“填满窗口”，而是“让工作集以可接受的成本驻留”。
• 层次性原理：寄存器、L1 工作上下文、L2 会话记忆、磁盘级长期记忆和冷归档构成层次；不同层之间需要显式的换入换出协议。
• 局部性原理：Agent 的访问序列具有阶段性和时间局部性；工作集跟踪、预取和换出策略应当利用这种局部性，而不是把上下文当作无序文本。
• 保护性原理：控制状态（目标、约束、安全策略）必须与普通记忆隔离，不能因为容量压力被随意换出；不可信的工具输出必须进入隔离的保护域。

但类比也有边界。LLM 不是严格的 CPU：它没有固定指令集，执行是随机的，内存是语义寻址而非字节寻址，换出是有损的，故障是隐式的。本文会同时说明这些差异如何改变设计。例如，传统 OS 的页表可以把虚拟地址精确映射到物理页，而 Agent 的“页表”只能给出语义近似；传统 OS 的换出是精确的，而 Agent 的换出往往需要摘要、压缩和置信度；传统 OS 的缺页由硬件触发，而 Agent 的缺页需要从行为中推断，存在“静默缺页”。

本文的贡献可以概括为四条：

• 提出有效上下文视角：把 Agent 上下文管理形式化为带预算、语义寻址、有损换出的工作集问题，定义原始命中率、上下文污染率和有效命中率，并给出可检验命题。
• 给出 AgentOS 参考架构：包括 Context MMU、缺页处理器、控制页钉住与保护、压缩换出、预取器、Agent 调度器和可观测性接口；给出系统调用与状态机，而不是停留在“把 MemGPT 和向量库拼起来”的层面。
• 构建可复现的机制模拟：用不含 LLM 调用的合成分页模拟器检验“更大窗口是否更好”“有效预算是否应小于物理窗口”“钉住和相位信号是否值得”等问题；报告 10 个随机种子的实际结果，并明确其外部效度边界。
• 给出验证协议：说明如何在 LongMemEval [36]、LoCoMo 类多会话记忆评测 [37]、τ-bench [27]、AgentBench [24]、OSWorld [26]、SWE-bench [48] 和 TheAgentCompany [28] 上验证本文假设，以及哪些指标必须被报告。

本文余下部分安排如下：第 2 节按技术流派回顾相关工作；第 3 节给出问题形式化、架构、模块、算法与理论性质；第 4 节报告合成模拟的设置、结果、消融、分析与局限；第 5 节讨论类比的适用边界、安全与伦理；第 6 节总结并给出可执行的未来工作。

2 Related Work

2.1 从提示工程到上下文工程

早期 LLM 应用主要关注提示词设计：如何把任务、示例和约束组织成一段文本。随着 Agent 出现，上下文不再是一次性输入，而是随环境反馈不断变化的状态。上下文工程（context engineering）因此从“写 prompt”扩展为“决定每一步把哪些信息放进窗口、以什么顺序放、何时移除”。这一转向与操作系统中的工作集管理高度同构：程序不会把整个磁盘读入内存，Agent 也不应把整个记忆库读入上下文。

与本文最接近的是 MemGPT [18]。它提出“虚拟上下文管理”，把上下文窗口类比为主存，把外部存储类比为磁盘，并通过函数调用让 LLM 自己读写外部记忆。MemGPT 证明了“固定窗口 + 分层存储”可以支持超出窗口的文档分析和多会话对话。本文的差异在于：MemGPT 主要把换入换出策略交给 LLM 的函数调用；本文主张把机制（缺页、钉住、保护、计费、调度）下沉到内核，把策略（换出评分、预取、目标预算）作为可替换插件。换言之，MemGPT 更像一个“会自己翻页的进程”，本文想要的是“有页表和调度器的操作系统”。

2.2 LLM as OS 与 Agent 运行时

AIOS [19] 是“LLM 作为操作系统”路线中最完整的系统工作之一。它把 LLM 实例封装为“核”（core），提供调度器、上下文管理器、内存管理器、存储管理器、工具管理器和访问管理器，并报告了相对多种 Agent 框架最高 2.1 倍的执行加速。AIOS 的上下文管理器支持中断/恢复和快照，内存管理器在达到阈值时使用 LRU-K 换出到存储层。这些设计与本文高度一致。本文与 AIOS 的差异有三点：第一，本文把“有效上下文”而非“上下文切换效率”作为第一目标，强调污染率和任务效用的关系；第二，本文给出更细的保护域、污点标记和审计抽象，面向不可信工具输出；第三，本文用合成模拟显式检验“窗口扩大可能降低有效命中率”这一反直觉命题。

OS-Copilot [47] 把 Agent 放进计算机环境，强调工具、文件和界面的统一操作。它更关注“Agent 如何操作操作系统”，本文关注“Agent 自身需要一个什么样的操作系统”。两者是互补关系：前者是 Agent 作为 OS 的用户，后者是 Agent 作为 OS 的进程。

MemoryOS [33] 直接借用操作系统内存管理思想，设计短期、中期、长期三层存储，使用 FIFO 和分段页组织，并在 LoCoMo 上报告了相对基线的提升。它证明了“OS 类比”在记忆模块层面是有效的。本文的差异在于：MemoryOS 主要解决对话记忆的层次化存储；本文把上下文窗口、外部记忆、工具 I/O、多 Agent 共享和权限保护放在同一个资源模型中，并强调有效预算和污染度量。

2.3 Agent 记忆与长期状态

CoALA [20] 把语言 Agent 的认知架构拆分为工作记忆、情景记忆、语义记忆和程序记忆，并区分内部行动与外部行动。这一分类为本文的记忆对象类型提供了认知科学依据。Generative Agents [21] 用记忆流、反思和计划构建长期行为，说明了时间局部性和重要性评分的作用。A-Mem [30] 受 Zettelkasten 方法启发，把记忆组织为动态索引和链接的笔记网络；Mem0 [31] 从生产系统角度强调记忆的抽取、合并和检索；Zep [32] 使用时间感知的知识图谱；MIRIX [34] 区分六类记忆并引入多 Agent 协调；Memory-R1 [35] 用强化学习训练记忆管理策略。这些工作共同说明：记忆不是简单的向量库，而是需要组织、更新和遗忘策略的系统。

与这些工作相比，本文不提出新的记忆表示，而是提出一个资源管理框架：记忆表示可以是向量、图、文件或结构化数据库；AgentOS 关心的是它们如何被映射为上下文页、如何计费、如何保护、如何换出、如何在多 Agent 之间共享。本文的合成模拟也刻意抽象掉具体记忆表示，只保留页大小、访问序列和污染这些机制变量。

2.4 长上下文、KV cache 与位置效应

长上下文模型试图直接扩大“内存容量”。Transformer-XL、Memorizing Transformers、RETRO 等工作从架构或检索角度扩展有效历史；StreamingLLM [9] 发现注意力汇（attention sinks）可以让模型在有限 KV cache 下处理长流；H2O [10] 用重击者（heavy hitter）保留关键 KV 项；PagedAttention [11] 把 KV cache 分成固定大小的块，借用虚拟内存和页表思想降低碎片；Prompt Cache [17] 复用跨提示的注意力状态；SGLang [16] 用 RadixAttention 复用前缀。这些工作说明，操作系统中的分页、缓存和前缀共享思想在推理引擎内部已经产生了实际收益。

但模型层的长上下文不等于 Agent 层的有效记忆。Liu 等 [6] 的位置实验和 RULER [7] 的多针检索、聚合与推理任务都表明，模型对长上下文的利用是非均匀的。本文把这一现象抽象为“污染率”：即使所需页都在窗口内，过多无关页也会降低有效命中率。本文不试图改进注意力机制，而是主张在系统层控制进入窗口的页集合和目标预算。

2.5 Agent 服务与调度

推理服务系统关注的是 GPU 上的请求调度和 KV cache 管理。Sarathi-Serve [12] 用分块预填充分离预填充和解码的干扰；DistServe [13] 把预填充和解码分配到不同 GPU；Llumnix [14] 在多个模型实例之间动态迁移请求；Mooncake [15] 以 KVCache 为中心做预填充/解码分离和分层缓存；Autellix [46] 把 Agent 程序作为调度单位；Parrot [45] 用语义变量表达应用级依赖；LLMCompiler [44] 把函数调用编译成并行计划。这些系统与本文的 AgentOS 位于不同层：它们优化“LLM 推理请求如何在 GPU 上执行”，本文优化“Agent 在每一步应当把哪些逻辑页放进上下文”。两者可以组合：AgentOS 决定上下文页集合，推理服务决定这些 token 如何被批处理、缓存和调度。

2.6 经典操作系统内存管理

本文直接借用了经典 OS 的三个概念。Denning [1] 的工作集模型指出，程序在一段时间内活跃访问的页集合决定了它需要多少内存；当分配给进程的页框少于工作集时，会发生抖动（thrashing）。Belady [2] 的换出算法在已知未来访问序列时给出最优置换；Sleator 和 Tarjan [3] 证明了在线分页算法的竞争比下界。Arpaci-Dusseau 与 Arpaci-Dusseau [4] 的系统教材把这些概念整理为虚拟内存、页表、TLB、换页、保护和调度。本文的差异在于：经典 OS 假设页大小固定、地址精确、换出无损；Agent 的页是语义对象、大小可变、换出有损、访问序列由模型行为决定。因此，经典结论不能直接照搬，需要重新推导。

3 Method

3.1 Problem Formulation

3.1.1 记忆对象与上下文

设 Agent 的外部记忆由对象集合 M = { m 1 , … , m N } \mathcal{M}=\{m_1,\dots,m_N\} M={m1​,…,mN​} 构成。每个对象 $m_i$ 具有：

• 内容 ${\mathrm{content}}_i$，可以是文本块、工具输出、文件片段、图节点、结构化记录或摘要；
• token 大小 $s_i>0$；
• 版本 $v_i$ 与来源 ${\mathrm{prov}}_i$；
• 置信度 $c_i\in [0,1]$；
• 保护级别 ${\mathrm{prot}}_i$。

在第 $t$ 步，Agent 的上下文是驻留对象集合 $R_t\subseteq \mathcal{M}$，其 token 总量受物理窗口 $B_t$ 和有效目标预算 $T_t$ 约束：

$$R_t\subseteq \mathcal{M},\sum _{m_i\in R_t}{s}_i\le T_t\le B_t.$$

物理窗口 $B_t$ 由模型和推理引擎决定；有效目标预算 $T_t$ 是 AgentOS 的策略变量。本文的核心主张之一是：$T_t$ 不应默认等于 $B_t$。

当前步骤真正需要的对象集合记为 $A_t\subseteq \mathcal{M}$，称为访问集。AgentOS 在决策时通常不知道 $A_t$，只能根据查询、计划、工具返回和历史访问预测。控制对象集合 $P_t$（目标、约束、安全策略、工具模式等）被钉住，满足 $P_t\subseteq R_t$，且其 token 总量通常远小于 $B_t$。

3.1.2 命中、污染与有效上下文

原始命中率定义为

$$h_t=\frac{|A_t\cap R_t|}{|A_t|}.$$

它衡量“所需页中有多少在窗口内”，但不衡量窗口是否被无关页污染。设 $W_t$ 为最近 $\Delta$ 步内被访问过的对象集合（工作集近似），定义陈旧集合

$$S_t=R_t\setminus \left(A_t\cup W_t\right).$$

上下文污染率定义为陈旧对象占驻留 token 的比例：

$${\rho }_t=\frac{{\sum }_{m_i\in S_t}{s}_i}{{\sum }_{m_i\in R_t}{s}_i}.$$

有效命中率把“可用”与“被稀释”两个因素合并：

$${\tilde{h}}_t=h_t\left(1-{\rho }_t\right).$$

这个定义是本文的实验代理指标，不是对 LLM 注意力的精确建模。它的作用是让“把更多页塞进窗口”与“让模型真正用上所需页”在同一个目标函数中显式冲突。真实 LLM 还受位置效应、指令顺序和注意力头分布影响；第 4.6 节会说明这一代理的局限。

3.1.3 成本模型

每一步的成本由四部分组成：

$$
C_t

c_{\mathrm{ret}}\sum_{m_i\in A_t\setminus R_t}s_i
+
c_{\mathrm{att}}\left(\frac{\sum_{m_i\in R_t}s_i}{1024}\right)^2
+
c_{\mathrm{sw}}\left|R_t\triangle R_{t-1}\right|
+
c_{\mathrm{wb}}\sum_{m_i\in \mathrm{EvictDirty}_t}s_i .
$$

其中 $c_{\mathrm{ret}}$ 是每 token 的检索与重排成本，$c_{\mathrm{att}}$ 是注意力计算的二次成本系数，$c_{\mathrm{sw}}$ 是上下文切换的固定成本，$c_{\mathrm{wb}}$ 是脏页回写或摘要成本。该成本模型是机制级的，不对应任何具体硬件或厂商价格；第 4.1 节给出模拟中的系数。

3.1.4 目标函数

Agent 的目标是最大化长期效用减去成本与风险：

$$\underset{\pi }{\max }\mathbb{E}\left[\sum _{t=0}^T{U}_t\left({\tilde{h}}_t\right)-\lambda C_t-\mu {\mathrm{Risk}}_t\right],$$

约束为预算约束、控制页约束、保护级别约束和任务级安全约束。$U_t$ 单调递增于 ${\tilde{h}}_t$，但对 ${\tilde{h}}_t$ 的边际收益递减；${\mathrm{Risk}}_t$ 包括不可信内容注入、隐私泄露、越权工具调用和记忆污染。这个目标函数是本文后续所有设计原则的出发点。

表 1 汇总了主要符号。

表 1 主要符号

符号	含义
$\mathcal{M}$	记忆对象集合
$m_i$	第 $i$ 个记忆对象（页）
$s_i$	对象 token 大小
$B_t$	第 $t$ 步物理上下文预算
$T_t$	第 $t$ 步有效目标预算，$T_t\le B_t$
$R_t$	第 $t$ 步驻留上下文集合
$A_t$	第 $t$ 步访问集（所需对象）
$P_t$	钉住的控制对象集合
$W_t$	最近 $\Delta$ 步的工作集
$h_t$	原始命中率
${\rho }_t$	上下文污染率
${\tilde{h}}_t$	有效命中率
$C_t$	单步成本
$\lambda$	成本权重
$\Delta$	工作集时间窗

3.1.5 基本假设

本文的形式化依赖四条假设，后文会逐条讨论其边界：

• A1（对象化）：记忆可以被划分为有边界的对象，且对象是检索、换入、换出和计费的基本单位。
• A2（硬预算）：每一步的上下文 token 数不得超过模型窗口；超出部分必须被截断、压缩或换出。
• A3（效用单调性）：任务效用随有效命中率上升，随污染率下降；边际收益递减。
• A4（访问不确定性）：AgentOS 无法精确预知 $A_t$，只能通过查询、计划和历史预测。

3.2 Framework Overview

3.2.1 分层架构

AgentOS 位于 Agent 应用与底层推理服务之间。它不替代 Linux、容器或 GPU 驱动，而是提供 Agent 特有的逻辑资源管理。图 1 给出参考架构。

┌──────────────────────────────────────────────────────────────────────┐
│ Agent 进程层                                                         │
│  规划器 Planner │ 执行器 Executor │ 反思器 Reflector │ 多 Agent 会话  │
├──────────────────────────────────────────────────────────────────────┤
│ 系统调用接口                                                         │
│  ctx.map │ ctx.fault │ ctx.pin │ ctx.evict │ ctx.compact │ ctx.stats  │
├──────────────────────────────────────────────────────────────────────┤
│ AgentOS 内核                                                         │
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐                │
│ │ Context MMU    │ │ Agent 调度器   │ │ 保护域/权限    │                │
│ │ 页表/地址翻译   │ │ 优先级/公平    │ │ 环/污点/审计   │                │
│ ├───────────────┤ ├───────────────┤ ├───────────────┤                │
│ │ 缺页处理器      │ │ 工作集跟踪器   │ │ 预取器         │                │
│ │ 检索/重排/校验  │ │ 相位检测       │ │ 计划感知       │                │
│ ├───────────────┤ ├───────────────┤ ├───────────────┤                │
│ │ 换出/压缩器     │ │ 成本核算器     │ │ 可观测性       │                │
│ │ 摘要/指针/回写  │ │ token/延迟     │ │ 轨迹/回放      │                │
│ └───────────────┘ └───────────────┘ └───────────────┘                │
├──────────────────────────────────────────────────────────────────────┤
│ 资源层                                                               │
│  LLM 推理核心（CPU） │ 上下文窗口（RAM） │ 外部记忆（Disk）             │
│  Prompt/KV Cache（TLB） │ 工具与沙箱（I/O） │ 多租户存储（Volume）       │
└──────────────────────────────────────────────────────────────────────┘

图 1 AgentOS 参考架构。 上半部分是 Agent 进程与控制面，下半部分是推理与存储资源；内核负责把逻辑记忆对象映射为受预算约束的上下文页。

3.2.2 与传统 OS 的对应关系

表 2 给出概念映射。映射的价值在于借用成熟的设计模式；风险在于把不成立的假设一起搬过来。

表 2 传统 OS 与 AgentOS 的概念映射

传统 OS	AgentOS	相同点	关键差异
CPU	LLM 推理核心	执行计算、有限并行	LLM 无固定指令集，输出随机
RAM	上下文窗口	容量有限、访问快、易失	按 token 计费，位置效应显著
Disk	外部记忆	容量大、延迟高、持久	语义检索而非块地址
MMU/页表	Context MMU	地址翻译、缺页、保护	映射是近似语义，不是精确地址
TLB	Prompt/KV cache	缓存最近翻译/前缀	缓存命中受提示顺序影响
Page fault	Context fault	缺失触发装入	故障需从行为推断，可能静默
Swap	摘要/压缩/回写	释放容量、可恢复	换出有损，恢复可能不精确
OOM killer	压缩/丢弃策略	容量耗尽时的兜底	丢弃可能造成任务失败或安全风险
Process	Agent 会话	独立状态、调度单位	会话可由 LLM 自我修改
Syscall	Context/Tool syscall	受控资源访问	参数是语义对象与自然语言
Protection ring	保护域/污点标记	隔离不可信代码与数据	攻击面包括提示注入与记忆投毒

3.2.3 设计原则

从第 3.1 节的目标函数和表 2 的映射，可以推出十条设计原则。它们不是口号，而是可以在系统调用、数据结构和评测指标中落地的约束。

P1 有效上下文优先于窗口占用率。 不要把“窗口填满”当作目标。系统应报告有效命中率、污染率和每任务成本，而不是只报告平均 token 使用率。若一个策略提高了原始命中率却降低了有效命中率，它不应被判定为改进。

P2 工作集驻留。 对最近 $\Delta$ 步和预测的下一步访问集合，应尽量保持驻留。工作集估计不需要精确，但必须显式；没有工作集概念的缓存策略会退化为“最近若干轮对话”的滑动窗口。

P3 机制与策略分离。 内核提供缺页、换入、换出、钉住、压缩、计费和审计机制；具体策略（换出评分、预取阈值、目标预算）应可插拔、可替换、可回滚。这样不同任务可以共用同一套安全与计费基础设施。

P4 语义寻址而非字节寻址。 Agent 的地址是“目标”“工具模式”“第 3 集第 2 幕”“用户偏好”这类语义对象，而不是 0x7fff 地址。Context MMU 需要维护对象标识、版本、来源和置信度，并允许近似匹配。

P5 控制状态钉住与保护。 目标、约束、安全策略、工具签名和审计上下文必须钉住，且放在高保护环。它们不能被普通换出策略挤出，也不能被不可信工具输出覆盖。

P6 按未来效用换出，而非仅按最近使用。 LRU 是强基线，但它假设“最近使用的页更可能再次使用”。在 Agent 中，旧的目标页可能在整个任务中持续重要，而最近的工具输出可能一次性无用。换出评分应包含重算成本、相位亲和性、保护级别和污染风险。

P7 有损但可恢复的换出。 当容量不足时，优先换出可重新检索或可摘要的页；对脏页先写回摘要和指针，再释放原文。系统必须记录摘要的损失程度和置信度，避免把摘要当作原文使用。

P8 预取与缓存复用。 计划感知的预取可以在相位切换前把下一阶段的工作集装入；前缀缓存和 KV cache 复用可以降低重复上下文的成本。但预取必须有成本收益判断，错误的预取会增加污染。

P9 隔离、权限与审计。 不可信工具输出进入低保护环，带污点标记；跨租户记忆必须隔离；所有换入换出、权限提升和记忆写入都应可审计、可回放。

P10 可观测性与可回放。 没有度量就没有管理。系统应记录每步的访问集、驻留集、缺页原因、换出决策、成本和安全事件，支持事后回放与策略对比。

3.3 Module Details

3.3.1 Context MMU 与页表

Context MMU 负责把 Agent 的语义地址翻译为上下文中的 token 片段。一个页表项可以表示为：

struct ContextPage {
  object_id;          // 语义对象标识，例如 goal、tool_schema、episode_42
  version;            // 版本号，用于检测过期
  tokens;             // token 数
  location;           // CONTEXT / EXTERNAL / TOOL / ARCHIVE
  protection_ring;    // 0=内核, 1=Agent, 2=用户, 3=不可信
  pinned_until;       // 钉住截止步；0 表示不钉住
  dirty;              // 是否被 Agent 修改
  confidence;         // 来源置信度
  last_access;        // 最近访问步
  access_count;       // 访问次数
  phase_id;           // 所属任务相位
  summary_ptr;        // 摘要对象指针
  provenance_hash;    // 来源哈希，用于审计与防投毒
}

与硬件页表不同，Context MMU 的“地址”是模糊的。一个查询“用户上次提到的部署环境”可能匹配多个对象；一个工具输出可能同时属于多个语义类别。因此，Context MMU 需要支持：

• 精确地址：session://goal、tool://deploy.schema；
• 范围地址：episode://12..18；
• 语义地址：query://deployment_environment；
• 保护地址：只有高保护环可读写的 policy://safety。

地址翻译的结果不是单一物理页，而是一个候选页集合及其置信度。缺页处理器在这个集合上做检索、重排和装入。

3.3.2 工作集跟踪与相位检测

工作集跟踪器维护一个滑动访问窗口，估计当前任务阶段的活跃对象。最简单的估计是

$${\hat{W}}_t=\left\{m_i:t-{last\_access}_i\le \Delta \right\}.$$

更稳健的做法是对访问频率做指数加权，并对相位变化做变点检测。Agent 的任务通常有明显的阶段结构：读取需求、制定计划、调用工具、检查结果、修复错误、总结。每个阶段的活跃页集合不同。相位检测器可以用 CUSUM、滑动窗口分类器或计划文本中的显式阶段标记。

工作集估计的质量直接影响换出策略。如果 ${\hat{W}}_t$ 过小，系统会低估需求，频繁缺页；如果过大，系统会保留过多页，增加污染。第 4 节的模拟显示，当工作集约 60 页、页大小中位数约 127 token 时，完整工作集约 7.6K token（按均值约 142 token 计约 8.5K）；有效命中率在 6K–8K 目标预算附近达到峰值，与工作集大部分驻留的区间一致。这不是巧合，而是 P2 的机制性体现。

3.3.3 缺页处理器

缺页处理器是 AgentOS 最核心的数据面模块。它处理六类缺页：

表 3 缺页类型与处理策略

类型	触发条件	典型处理
强制缺页 (compulsory)	首次访问	从外部记忆检索或创建对象
容量缺页 (capacity)	预算不足被换出	重新检索、重排、压缩后装入
冲突缺页 (conflict)	多 Agent 争用同一页	调度、复制、写时复制（COW）
语义缺页 (semantic)	检索结果与需求不匹配	改写查询、扩大候选集、请求澄清
过期缺页 (stale)	版本与来源不一致	重新获取、校验、标记旧版本
静默缺页 (silent)	页在窗口内但模型未使用	重排位置、显式提示、压缩上下文

前五类是显式缺页：系统知道某个对象缺失或不可用。第六类是 Agent 特有的“静默缺页”：对象在窗口内，但模型没有利用它。Lost in the Middle [6] 的 U 形曲线说明，信息位置会显著影响利用率；因此，静默缺页不能只靠“把页装进去”解决，还需要重排、分段提示、查询感知上下文和显式引用。

缺页处理的标准流程是：

1. 解析地址：确定对象标识、版本和候选集；
2. 查页表：命中则返回 token 视图，未命中则进入缺页处理；
3. 检索：从向量库、图数据库、文件系统、工具或对话历史中取回候选；
4. 重排：按相关性、置信度、时效性、保护级别排序；
5. 压缩：按目标预算做抽取式或摘要式压缩；
6. 校验：检查版本、来源、污点和安全策略；
7. 装入：分配 token 空间，必要时换出其他页；
8. 记账：记录缺页类型、成本、延迟和结果。

3.3.4 换出引擎

换出引擎决定在容量不足时牺牲哪些页。一个可解释的评分函数是

$$u(m)=\alpha \mathrm{recency}(m)+\beta \mathrm{freq}(m)+\gamma \mathrm{phase}(m)+\delta \mathrm{recompute}(m)-ϵ\mathrm{size}(m)-\zeta \mathrm{dirty}(m)-\eta \mathrm{risk}(m),$$

其中：

• $\mathrm{recency}$ 随最近访问时间衰减；
• $\mathrm{freq}$ 是归一化访问频率；
• $\mathrm{phase}$ 表示页是否属于当前相位的工作集；
• $\mathrm{recompute}$ 表示重新获取该页的预计成本；
• $\mathrm{size}$ 惩罚大页，因为释放大页能更快腾出空间；
• $\mathrm{dirty}$ 惩罚需要回写的页；
• $\mathrm{risk}$ 表示换出或保留该页的安全风险。

系统选择 $u(m)$ 最小的非钉住页作为牺牲页。这个评分不是最优的：第 3.5 节会说明，变长页、效用权重和在线未知访问使最优换出成为 NP 难问题。它的价值在于把多个可观测信号显式化，并允许不同任务调整权重。

一个重要的工程细节是抖动回退。当最近窗口的命中率低于阈值时，频率和相位信号往往已经失真，继续使用复杂评分可能加剧抖动。此时应退化为 LRU，先恢复基本驻留能力，再重新学习相位。本文的模拟实现了这一回退：当最近至少 10 步（最多 20 步）的平均命中率低于 0.35 时，AgentOS 切换到纯最近使用顺序。

3.3.5 保护域与污点标记

Agent 的上下文包含不同信任级别的数据：系统安全策略、Agent 目标、用户数据、工具输出、网页内容、第三方 Agent 消息。把它们混在同一个文本窗口里，会带来提示注入、记忆投毒和隐私泄露风险。AgentOS 应采用类似保护环的设计：

表 4 保护环与权限

保护环	内容	默认权限
Ring 0 内核	安全策略、系统提示、审计规则	只读、不可换出、最高优先级
Ring 1 Agent	目标、计划、约束、工具签名	可读、可压缩、默认钉住
Ring 2 用户	用户偏好、授权数据、会话记录	需授权、可换出、可删除
Ring 3 不可信	工具输出、网页、外部消息	隔离、污点标记、不得提升权限

污点标记应随数据流动传播：如果一段不可信文本被摘要进 Ring 1，摘要必须继承污点；如果 Agent 试图根据污点内容调用高权限工具，系统应要求额外确认或拒绝。这与传统 OS 的“不可信输入不得直接成为指令”是同一原则，只是攻击面从内存破坏变成了提示注入。

3.3.6 压缩换出与回写

当容量不足时，AgentOS 有四种选择：

1. 换出到外部记忆：保留原文指针，按需重新检索；
2. 摘要后换出：保留摘要和指针，损失细节但节省 token；
3. 压缩为结构化状态：例如把一段工具输出压缩为 {status, key_findings, errors}；
4. 丢弃：只适用于可重新获取且低价值的页。

换出不是免费的。摘要需要调用 LLM 或专用压缩器，回写需要存储和版本管理，重新装入需要检索和重排。系统应比较“保留”的边际注意力成本与“换出+重装”的期望成本。第 3.5.4 节给出一个简化的盈亏平衡条件。

3.3.7 预取器

预取器在相位切换前预测下一阶段的工作集，并提前装入。理想情况下，预取可以隐藏检索延迟、减少缺页；错误情况下，预取会增加污染和成本。预取策略应包含：

• 计划感知：从 Agent 的计划文本中提取下一阶段可能需要的对象；
• 历史相位模式：相似任务的历史访问序列；
• 置信度阈值：只有当预测置信度超过阈值且剩余预算足够时才预取；
• 可撤销性：预取页应标记为低优先级，容量不足时优先换出。

本文的合成模拟显示，一个简单的“下一阶段随机预取”策略没有带来可测量的有效命中率提升（第 4.4 节）。这不是说预取无用，而是说低质量预取会把延迟收益转化为污染成本。计划感知和可撤销预取是后续工作需要验证的方向。

3.3.8 Agent 调度器

AgentOS 的调度器管理多个 Agent 会话对 LLM、上下文预算和工具的竞争。调度目标包括：

• 公平性：多租户或多 Agent 场景下，避免一个长任务饿死其他任务；
• 优先级：安全关键任务、用户交互任务和后台任务应有不同优先级；
• 上下文切换成本：频繁切换会带来快照/恢复成本，应尽量批量；
• 前缀共享：多个 Agent 共享系统提示、工具模式和知识前缀时，应复用 KV cache；
• 写时复制：子 Agent 继承父 Agent 的只读上下文，私有修改以 COW 方式隔离。

AIOS [19] 的上下文管理器提供了文本快照和 logits 快照两种中断/恢复方式；这为 Agent 调度提供了可借鉴的机制。本文补充的是：调度决策应把“有效上下文”和“污染风险”纳入优先级，而不仅看请求延迟。

3.3.9 可观测性

AgentOS 应暴露以下指标：

• context fault rate：每步缺页对象数 / 访问对象数；
• raw hit rate 与 effective hit rate；
• pollution rate：陈旧 token 占比；
• working set size：当前估计的工作集 token 数；
• token utilization：驻留 token / 目标预算；
• thrash rate：命中率低于阈值的步占比；
• cost per success：完成一个任务的总 token、检索和切换成本；
• memory safety events：污点传播、越权尝试、记忆投毒告警。

这些指标应写入结构化轨迹，支持回放和策略对比。没有轨迹，就无法回答“这次失败是检索错了、换出错了，还是模型没有使用已有信息”。

3.3.10 系统调用接口

表 5 给出一个最小系统调用集。它借鉴 OS 的 mmap、page fault、mlock、madvise、fork 和 stat，但参数是语义对象。

表 5 AgentOS 最小系统调用集

系统调用	语义	关键参数	返回
ctx.map	注册记忆对象与页表项	object_id, tokens, ring, provenance	handle
ctx.fault	处理缺页	handle, query_hint, deadline	tokens/status
ctx.pin	钉住控制页	handle, ttl	ok
ctx.evict	主动换出	handle, mode=swap/compact/drop	cost
ctx.compact	压缩页	handle, level, budget	summary_handle
ctx.prefetch	预取	handle, confidence	ok
ctx.snapshot	保存上下文快照	session_id	snapshot_id
ctx.restore	恢复快照	snapshot_id	ok
ctx.protect	设置保护环/污点	handle, ring, taint	ok
ctx.stats	读取指标	session_id, window	metrics

3.4 Training / Inference

AgentOS 本身不需要训练。它可以以三种方式运行：

1. 规则模式：使用固定的工作集窗口、评分权重和目标预算。适合冷启动和可解释性要求高的场景。
2. 校准模式：在任务开始时用少量步数估计页大小分布、访问局部性、相位长度和检索成本，自动设置 $\Delta$、$T_t$ 和评分权重。
3. 学习模式：把换出、预取和目标预算选择建模为上下文 bandit 或强化学习问题，奖励为任务成功减去 token、延迟和安全惩罚。Memory-R1 [35] 已经展示了用强化学习管理记忆的可行性；本文的框架可以把它的策略嵌入换出引擎，而不改变内核机制。

算法 1 给出单步上下文管理流程；算法 2 给出换出流程。

算法 1  CONTEXT_STEP(session, request)
输入: Agent 会话 session, 当前请求 request
输出: 受预算约束的上下文 R

1  A ← PLAN_REQUIRED(session, request)          // 预测访问集
2  for m in A do
3      if not RESIDENT(m) then
4          h ← CMMU.LOOKUP(m)
5          if h = NONE then h ← CMMU.CREATE(m)
6          FAULT_HANDLER(h, session.deadline)
7      end if
8  end for
9  R ← CMMU.RESIDENT_SET()
10 if TOKENS(R) > TARGET(session) then
11     EVICT(session, R)
12 end if
13 if NEAR_PHASE_BOUNDARY(session) then
14     PREFETCH(session, PREDICT_NEXT_WORKING_SET(session))
15 end if
16 return BUILD_PROMPT(R, ORDER_BY_PROTECTION_AND_RELEVANCE(R))

算法 2  EVICT(session, R)
输入: 驻留集合 R, 目标预算 TARGET
输出: 更新后的 R

1  C ← R \ PINNED(session)
2  for m in C do
3      u[m] ← α·RECENCY(m) + β·FREQ(m) + γ·PHASE(m)
4              + δ·RECOMPUTE(m) - ε·SIZE(m)
5              - ζ·DIRTY(m) - η·RISK(m)
6  end for
7  while TOKENS(R) > TARGET do
8      m ← argmin_{m∈C} u[m]
9      if DIRTY(m) then WRITE_BACK(m)
10     if COMPACTABLE(m) then COMPACT(m)
11     REMOVE(R, m); C ← C \ {m}
12     update u for remaining candidates
13 end while
14 return R

训练/推断的边界需要说明：本文不训练 LLM，也不假设可以访问模型内部注意力。AgentOS 的观测面是 token、对象、工具调用、延迟和任务结果。它可以在闭源模型上工作，也可以在开源模型上与 KV cache 管理配合。这一点对工程落地很重要：上下文管理不应依赖模型厂商的白盒接口。

3.5 Complexity and Theoretical Properties

3.5.1 复杂度

表 6 给出主要操作的时间与空间复杂度。设 $N$ 为对象总数，$k$ 为候选集大小，$|R|$ 为驻留页数。

表 6 主要操作复杂度

操作	时间	空间
页表查找	$O(1)$ 哈希	$O(N)$
缺页处理	$O(\log N+\mathrm{retrieval})$	$O(k)$
换出评分	$O(N\log N)$ 排序，或 $O(N)$ 堆	$O(N)$
预取	$O(k\log N)$	$O(k)$
快照/恢复	$O(	R
上下文构造	$O(	R

换出评分是每一步的热点。工程上可以用增量堆、分桶或 learned ranker 降到近似 $O(\log N)$。在大规模多 Agent 场景，页表应按租户和会话分片，避免全局锁。

3.5.2 命题 1：工作集可行性

命题 1. 若在某个时段内控制页集合 $P_t$ 与工作集 $W_t$ 满足

$$\sum _{m_i\in P_t}{s}_i+\sum _{m_i\in W_t}{s}_i>B_t,$$

则任何策略都无法同时保证控制页和完整工作集驻留；若工作集对任务进展是必要的，则系统必然发生控制缺页或工作集缺页。

证明思路. 由预算约束和集合包含关系直接可得：两个不相交集合的 token 总量超过容量时，至少有一个元素必须被换出。若控制页被换出，则发生控制缺页；若工作集页被换出，则发生工作集缺页。证毕。

这个命题给出一个非常实用的容量规划规则：先估计工作集和控制页，再选择窗口和模型。如果工作集长期超过窗口的 70%–80%，系统会进入抖动区，增加窗口或改进检索比优化换出算法更有效。

3.5.3 命题 2：有效预算的倒 U 形

命题 2. 设 $h(B)$ 和 $\rho (B)$ 可微，有效命中率 $\tilde{h}(B)=h(B)(1-\rho (B))$。则

$$
\frac{d\tilde h}{dB}

h’(B)\left(1-\rho(B)\right)-h(B)\rho’(B).
$$

当

$${\rho }^{\prime }(B)>\frac{h^{\prime }(B)\left(1-\rho (B)\right)}{h(B)}$$

时，扩大窗口会降低有效命中率。

证明思路. 对乘积求导即可。直观含义是：当新增容量带来的污染增长快于命中增长时，窗口越大，模型越难用上真正需要的信息。

用第 4 节的模拟数据检验：从 8K 到 32K，原始命中率从 0.438 升到 0.596，污染率从 0.200 升到 0.666。取差分近似，$h^{\prime }\approx 6.4\times 10^{-6}$/token，${\rho }^{\prime }\approx 1.9\times 10^{-5}$/token；在 8K 处右侧约为 $1.2\times 10^{-5}$/token。因为 ${\rho }^{\prime }>$ 右侧，命题 2 的条件成立，有效命中率随窗口扩大而下降。这与模拟中 0.348 降到 0.189 的方向一致。

3.5.4 命题 3：钉住权衡

命题 3. 设钉住 $p$ 个 token 的控制页，控制页命中概率 $q(p)$ 随 $p$ 递增且边际递减，工作集可用容量为 $B-p$，有效命中率为

$$\tilde{h}(p)=q(p)h_{\mathrm{ws}}(B-p)\left(1-\rho (p)\right).$$

在 $q$ 和 $h_{\mathrm{ws}}$ 可微且满足正则条件下，最优钉住量 $p^{\ast }$ 满足边际收益等于边际成本：

$$
q’(p^{*)h_{\mathrm{ws}}(B-p}*)\left(1-\rho\right)

q(p^{*)h’_{\mathrm{ws}}(B-p})\left(1-\rho\right)
+
q(p^{*)h_{\mathrm{ws}}(B-p})\rho’(p^*).
$$

证明思路. 对 $\tilde{h}(p)$ 求导并令其为零。直观含义是：钉住控制页提高安全性，但挤占工作集；最优钉住量不是“越多越好”，而是由控制页的重要性、工作集的边际价值和污染变化共同决定。

第 4.4 节的消融显示，完全取消钉住会让有效命中率从 0.353 降到 0.303，污染率从 0.150 升到 0.223，成本从 37.69 升到 39.09。这说明在该模拟中，钉住的收益超过容量成本；但它不证明“钉住越多越好”，最优钉住量仍需按任务校准。

3.5.5 命题 4：命中率不等于效用

命题 4. 存在两个策略 ${\pi }_1,{\pi }_2$，使得 ${\pi }_1$ 的原始命中率更高，但有效命中率更低。

构造. 设策略 A 保留全部所需页，但同时保留大量陈旧页，$h_A=1.0$，${\rho }_A=0.6$，则 ${\tilde{h}}_A=0.4$。策略 B 保留 80% 的所需页且没有陈旧页，$h_B=0.8$，${\rho }_B=0$，则 ${\tilde{h}}_B=0.8$。因此 $h_A>h_B$ 但 ${\tilde{h}}_A<{\tilde{h}}_B$。第 4 节的 RAG 与 AgentOS 对比提供了一个经验版本：RAG 的原始命中率为 0.863，高于 AgentOS 的 0.417，但有效命中率为 0.314，低于 AgentOS 的 0.353，原因是 RAG 每步重建的 top-k 上下文中有约 65% 是当前步不需要的页。

这个命题对评测有直接影响：只报告命中率、召回率或窗口大小，可能把“塞得更多”误判为“记得更好”。Agent 评测应同时报告有效上下文、污染和任务成功。

3.5.6 命题 5：在线最优换出不可得

命题 5. 在页大小可变、页效用不同、访问序列未知的条件下，每步的换出选择包含 0/1 背包问题作为特例，因此是 NP 难的；即使页大小固定，确定性在线分页算法的竞争比也不能优于 $k$（$k$ 为可用页框数）。

证明思路. 令每个页的大小为 $s_i$、保留效用为 $u_i$、预算为 $T$，则选择保留集合最大化 $\sum u_i$ 且满足 $\sum s_i\le T$ 就是 0/1 背包，已知 NP 难。在线分页的竞争比下界来自 Sleator 与 Tarjan [3] 的经典结果。证毕。

这个命题解释了为什么本文不追求“最优换出算法”，而是提供可解释的评分、抖动回退和可学习策略。工程上更现实的目标是：在给定任务分布和成本模型下，找到“足够好且可审计”的策略。

3.5.7 盈亏平衡条件

保留一个页与换出后重装的简化比较如下。设页大小为 $s$，当前上下文总长为 $B$，注意力成本系数为 $c_{\mathrm{att}}$，检索成本为 $c_{\mathrm{ret}}$，该页在下一步被再次使用的概率为 $p_{\mathrm{reuse}}$。保留该页的边际注意力成本约为

$$\Delta C_{\mathrm{keep}}\approx c_{\mathrm{att}}\cdot \frac{2sB}{1024^2},$$

换出的期望成本约为

$$\Delta C_{\mathrm{swap}}\approx p_{\mathrm{reuse}}{c}_{\mathrm{ret}}s.$$

因此，当

$$B<\frac{c_{\mathrm{ret}}\cdot 1024^2}{2c_{\mathrm{att}}}{p}_{\mathrm{reuse}}$$

时，保留更划算；反之，换出更划算。这个条件说明目标预算 $T_t$ 应随复用概率和检索成本动态变化，而不是固定为窗口大小。第 4 节的有效预算扫描与该直觉一致：在 32K 物理窗口下，6K–8K 的目标预算取得最高有效命中率。

4 Experiments

4.1 Experimental Setup

4.1.1 实验定位与边界

本节报告的是一个合成机制模拟，不是 LLM 基准评测。它不调用任何语言模型，不测量真实任务成功率，也不测量真实推理延迟。它的目的是检验第 3 节提出的机制性命题：

• H1：原始命中率随物理窗口增大而上升，但有效命中率可能下降；
• H2：在固定物理窗口下，存在一个小于窗口的有效目标预算，使有效命中率最高；
• H3：控制页钉住和相位信号能降低污染、提高有效命中率；
• H4：命中率更高的策略不一定有效命中率更高。

这些假设如果被证伪，第 3 节的设计原则就需要修正。合成模拟不能替代真实评测；第 4.6 节和第 6 节给出真实基准的验证协议。

4.1.2 合成痕迹生成

模拟器生成一个长程 Agent 的页访问序列。参数如表 7 所示。

表 7 合成痕迹参数

参数	取值	说明
记忆对象数 $N$	2000	外部记忆页总数
任务步数 $T$	240	8 个相位 × 30 步
每相位热点页	60	当前相位的工作集大小
每相位新增页	40	其余 20 页与上一相位重叠
控制页	8	目标、约束、工具模式等
每步所需页	4	另有 8% 概率访问下一相位页
页大小	32–512 token，对数正态	中位数约 128，均值约 142 token
物理窗口 $B$	8192 token（主实验）	另有 4K/8K/16K/32K 扫描
工作集窗 $\Delta$	12 步	用于污染和评分
随机种子	0–9，共 10 个	报告均值 ± 标准差

每步的访问集按以下混合分布生成：62% 来自当前相位热点页，16% 来自上一相位热点页，10% 来自控制页，12% 来自全局随机页；另有 8% 概率访问下一相位页，用于模拟相位切换和预取机会。这个分布同时包含时间局部性、相位局部性和跨相位干扰。

4.1.3 对比策略

• FIFO：按装入顺序换出最早页，模拟简单的滑动窗口。
• LRU：换出最近最久未使用页，是经典强基线。
• LFU：换出访问频率最低页，模拟“重要性计数”策略。
• CLOCK：二次机会算法，模拟低成本近似 LRU。
• RAG：每步重建 top-10 检索上下文，模拟无状态检索增强；每个所需页以 0.85 概率被检索到，其余槽位由当前相位热点页和随机页填充。
• Oracle：已知未来访问序列，按 Belady 规则换出“下一次使用最远”的页；它是离线上界，不可在线部署。
• AgentOS：钉住控制页，使用相位/频率/新近性/重算成本/大小/脏页评分，带抖动回退和主动老化；目标预算默认等于物理窗口，另有目标预算扫描。

4.1.4 指标与成本

• 原始命中率：所需页命中数 / 所需页访问数；
• 有效命中率：$h_t(1-{\rho }_t)$ 的步平均；
• 污染率：陈旧驻留 token / 驻留 token；
• 每步成本：按第 3.1.3 节的检索、二次注意力、切换和回写成本计算；
• 每步检索 token：外部检索装入的 token 数；
• 抖动率：命中率低于 0.5 的步占比；
• 换出次数：总换出页数。

成本系数取 $c_{\mathrm{ret}}=1$（每 128 token 计 8 个基础单位）、$c_{\mathrm{att}}=0.02$、$c_{\mathrm{sw}}=1$、$c_{\mathrm{wb}}=1$；具体实现见附录 B。系数是机制级的，不代表任何厂商价格。

4.1.5 可复现性

模拟器为纯 Python 实现，不依赖 GPU、网络或 LLM API。固定随机种子后，结果可完全复现。运行命令：

python3 context_paging_sim.py \
  --seeds 0 1 2 3 4 5 6 7 8 9 \
  --sweep \
  --out context_paging_results.json

脚本路径为 context_paging_sim.py，结果文件为 context_paging_results.json。本文报告的所有模拟数字均来自该脚本的 10 个种子均值；标准差为总体标准差。没有对结果进行选择性报告；失败或无效的消融（如预取）也一并报告。

4.2 Main Results

表 8 给出主实验（物理窗口 8K）的结果。

表 8 主实验结果（8K 窗口，10 seeds，均值 ± 标准差）

策略	原始命中率	有效命中率	污染率	每步成本	每步检索 token	抖动率
FIFO	0.386 ± 0.006	0.245 ± 0.011	0.371 ± 0.020	39.56 ± 0.54	351.24 ± 11.24	0.525 ± 0.023
LRU	0.438 ± 0.013	0.348 ± 0.011	0.200 ± 0.017	36.55 ± 0.93	321.36 ± 13.03	0.437 ± 0.034
LFU	0.320 ± 0.008	0.168 ± 0.006	0.533 ± 0.011	43.10 ± 0.67	391.50 ± 11.95	0.635 ± 0.022
CLOCK	0.431 ± 0.014	0.337 ± 0.011	0.215 ± 0.016	36.99 ± 0.96	324.56 ± 12.47	0.448 ± 0.035
RAG	0.863 ± 0.007	0.314 ± 0.006	0.650 ± 0.006	124.41 ± 0.71	1419.86 ± 22.68	0.010 ± 0.007
Oracle	0.598 ± 0.007	0.420 ± 0.014	0.292 ± 0.022	26.94 ± 0.26	229.68 ± 4.16	0.211 ± 0.022
AgentOS	0.417 ± 0.012	0.353 ± 0.012	0.150 ± 0.014	37.69 ± 0.89	334.59 ± 12.98	0.469 ± 0.033

从表 8 可以读出四点：

1. LRU 是强基线。 它的原始命中率 0.438 高于 AgentOS 的 0.417，有效命中率 0.348 只比 AgentOS 低 0.005。这与“经典算法仍然有效”的工程直觉一致，也提醒我们不要夸大复杂策略的收益。
2. AgentOS 的收益主要来自污染控制。 它把污染率从 LRU 的 0.200 降到 0.150（相对下降 25.0%），代价是每步成本从 36.55 升到 37.69（相对上升 3.1%），原始命中率下降 0.021（相对下降 4.8%）。有效命中率的相对提升约为 1.4%。这是一个小而一致的收益，不是数量级改进。
3. Oracle 是离线上界，不是可部署策略。 它的原始命中率 0.598 最高，但污染率 0.292 也高于 AgentOS；有效命中率 0.420 高于所有在线策略。它说明“知道未来”能显著改善换出，但也说明即使最优换出仍会保留污染页，因为它的目标只是命中率，不是有效上下文。
4. RAG 的原始命中率最高，但有效命中率不高。 每步 top-10 重建可以命中 86.3% 的所需页，但 65.0% 的上下文是当前步不需要的页，导致有效命中率只有 0.314；同时每步成本是 LRU 的 3.40 倍。这个结果不是否定 RAG，而是说明：检索质量、上下文预算和去重/重排必须一起优化，否则“检索得多”会变成“污染得多”。

需要再次强调：这些数字是合成机制模拟，不是 LLM 任务准确率。它们支持 H4（命中率不等于效用），但不能证明 AgentOS 在真实任务上优于 LRU。第 4.6 节给出真实评测方案。

4.3 Capacity and Effective Budget

4.3.1 物理窗口扫描

表 9 和图 2 给出物理窗口从 4K 到 32K 的结果。为控制篇幅，只列 LRU、AgentOS 和 Oracle；完整数值见结果文件。

表 9 物理窗口扫描（有效命中率 / 原始命中率 / 污染率 / 每步成本）

窗口	LRU 有效 / 原始 / 污染 / 成本	AgentOS 有效 / 原始 / 污染 / 成本	Oracle 有效 / 原始 / 污染 / 成本
4K	0.256 / 0.255 / 0.000 / 46.83	0.258 / 0.259 / 0.005 / 46.61	0.404 / 0.503 / 0.190 / 32.28
8K	0.348 / 0.438 / 0.200 / 36.48	0.353 / 0.417 / 0.150 / 37.64	0.420 / 0.598 / 0.292 / 26.92
16K	0.261 / 0.578 / 0.537 / 30.24	0.246 / 0.503 / 0.507 / 33.87	0.270 / 0.600 / 0.537 / 28.88
32K	0.189 / 0.596 / 0.666 / 36.23	0.192 / 0.584 / 0.656 / 34.97	0.190 / 0.600 / 0.666 / 35.96

有效命中率（10 seeds 均值，物理窗口扫描）
4K   LRU     ████████████████████████ 0.256
     AgentOS ████████████████████████ 0.258
     Oracle  ██████████████████████████████████████ 0.404
8K   LRU     █████████████████████████████████ 0.348
     AgentOS ██████████████████████████████████ 0.353
     Oracle  ████████████████████████████████████████ 0.420
16K  LRU     █████████████████████████ 0.261
     AgentOS ███████████████████████ 0.246
     Oracle  ██████████████████████████ 0.270
32K  LRU     ██████████████████ 0.189
     AgentOS ██████████████████ 0.192
     Oracle  ██████████████████ 0.190

图 2 物理窗口与有效命中率。 原始命中率随窗口增大而上升，但有效命中率在 8K 附近达到峰值后下降；污染率是主要原因。

关键数字：

• 原始命中率从 4K 的 0.255 升到 32K 的 0.596（LRU），相对上升约 134%；
• 同一区间，污染率从 0.000 升到 0.666；
• 有效命中率从 8K 的 0.348 降到 32K 的 0.189（LRU），相对下降约 45.7%；
• 32K 的每步成本（LRU 36.23）反而高于 8K（36.48）附近，因为二次注意力成本抵消了检索减少的收益（两者接近，差异在噪声范围内）。

这个结果与“上下文越长越好”的直觉相反，但与 Lost in the Middle [6] 和 RULER [7] 的结论方向一致：可接收的 token 数不等于可有效利用的 token 数。本文的贡献是把这一现象从模型层推广到系统层，并用污染率给出了一个可操作的中间变量。

4.3.2 有效预算扫描

表 10 和图 3 给出在固定 32K 物理窗口下，改变 AgentOS 的有效目标预算 $T$ 的结果。这是本文最重要的实验：它直接检验“物理窗口不应等于有效预算”。

表 10 32K 物理窗口下的有效预算扫描（AgentOS，10 seeds）

有效目标预算	原始命中率	有效命中率	污染率	每步成本	有效命中/成本
4K	0.278	0.277	0.005	45.18	0.00613
6K	0.388	0.362	0.068	39.05	0.00927
8K	0.418	0.354	0.150	37.43	0.00946
12K	0.465	0.284	0.388	35.08	0.00810
16K	0.502	0.246	0.507	33.77	0.00728
24K	0.557	0.210	0.613	33.12	0.00634
32K	0.584	0.192	0.656	34.90	0.00550

有效命中率（32K 物理窗口，AgentOS，改变有效目标预算）
4K   ██████████████████████████ 0.277
6K   ██████████████████████████████████ 0.362
8K   █████████████████████████████████ 0.354
12K  ███████████████████████████ 0.284
16K  ███████████████████████ 0.246
24K  ███████████████████ 0.210
32K  ██████████████████ 0.192

图 3 有效目标预算与有效命中率。 在 32K 物理窗口下，6K–8K 的有效预算取得峰值；继续填满窗口会提高原始命中率，但降低有效命中率和成本效率。

关键观察：

• 有效命中率在 6K 达到 0.362，在 8K 为 0.354，两者构成一个平台；12K 以后快速下降，32K 仅为 0.192。
• 原始命中率从 8K 的 0.418 升到 32K 的 0.584（+39.7%），但污染率从 0.150 升到 0.656（+337%），有效命中率下降 45.8%。
• 成本效率（有效命中/成本）在 8K 最高（0.00946），6K 次之（0.00927），32K 最低（0.00550）。也就是说，把 32K 窗口当成 8K 用，反而更划算。
• 6K–8K 与第 3.3.2 节估计的工作集规模（60 页 × 中位数约 127 token ≈ 7.6K；按均值约 142 token 计约 8.5K）大致一致，对应工作集大部分驻留的区间。这为“工作集决定有效预算”提供了机制层面的支持，但仍是合成痕迹上的观察，不是普遍定律。

这个结果的政策含义很直接：模型厂商宣传的窗口大小是容量上限，不是推荐工作点。AgentOS 应暴露目标预算旋钮，并根据任务分布自动校准；评测应报告有效预算和污染率，而不是只报告“支持 128K/1M 上下文”。

4.4 Ablation Study

表 11 给出消融结果。所有消融都在 8K 物理窗口、10 个种子上运行。

表 11 消融实验（8K 窗口，10 seeds）

配置	原始命中率	有效命中率	污染率	每步成本
AgentOS 完整	0.417 ± 0.012	0.353 ± 0.012	0.150 ± 0.014	37.69 ± 0.89
去掉控制页钉住	0.394 ± 0.015	0.303 ± 0.010	0.223 ± 0.012	39.09 ± 1.19
去掉相位信号	0.432 ± 0.014	0.341 ± 0.012	0.208 ± 0.015	37.08 ± 1.10
去掉预取	0.418 ± 0.012	0.354 ± 0.012	0.149 ± 0.014	37.62 ± 1.03
仅 LRU（无 AgentOS 机制）	0.438 ± 0.013	0.348 ± 0.011	0.200 ± 0.017	36.58 ± 0.93

消融解读：

1. 控制页钉住是最大的单项贡献。 去掉钉住后，有效命中率从 0.353 降到 0.303（-5.0 个百分点，相对 -14.2%），污染率从 0.150 升到 0.223（相对 +48.7%），成本反而从 37.69 升到 39.09。原因是控制页被换出后会反复缺页，既增加检索成本，又让普通页占据上下文。这与命题 3 的“钉住有净收益”一致，但不意味着钉住越多越好。
2. 相位信号带来小幅收益。 去掉相位信号后，有效命中率降到 0.341（-1.2 个百分点），污染率升到 0.208，成本降到 37.08。相位信号用少量额外换出和检索换取了更干净的上下文；收益不大，但方向稳定。
3. 简单预取没有可测量收益。 去掉预取后，有效命中率 0.354，与完整配置的 0.353 在标准差内不可区分；污染率和成本也几乎相同。预取的预测质量不足时，提前装入的页很快变成污染。这是一个负面结果，我们如实报告，并把“计划感知、可撤销预取”列为未来工作。
4. AgentOS 相对 LRU 的净收益很小。 完整配置比 LRU 高 0.005 有效命中率、低 0.050 污染率，但成本高 1.11。若只看原始命中率，LRU 甚至更好（0.438 vs 0.417）。这提醒我们：复杂策略必须证明其成本归一化后的效用，而不是只展示某一个指标。

4.5 Analysis

4.5.1 为什么更大的窗口可能更差

表 9 的核心机制是污染：窗口越大，LRU 越倾向于保留“最近但已过时”的页。8K 时污染率 0.200，32K 时 0.666。上下文中的陈旧页不会消失，它们会占用注意力预算、稀释指令、干扰检索结果的使用。Lost in the Middle [6] 从位置维度展示了这种稀释：相关信息在长上下文中部时，模型表现可能低于闭卷；本文从驻留集合维度展示了同一类问题：即使相关信息在窗口内，过多无关页也会降低有效命中。

需要澄清：本文的模拟没有建模注意力位置，因此不能声称“污染率精确预测 LLM 准确率”。它建模的是系统层的资源竞争：当预算被陈旧页占用时，所需页更可能缺席或被挤到不利位置。真实 LLM 的污染效应可能更强（位置效应）或更弱（模型学会忽略无关内容），需要真实实验校准。

4.5.2 命中率与有效效用的分离

表 8 给出了两个反例：

• RAG vs AgentOS：RAG 原始命中率 0.863，远高于 AgentOS 的 0.417；但有效命中率 0.314，低于 AgentOS 的 0.353。原因是 RAG 每步重建的 top-10 中有大量当前步不需要的页（污染率 0.650），且成本是 AgentOS 的 3.30 倍。
• Oracle vs AgentOS：Oracle 原始命中率 0.598，有效命中率 0.420，高于 AgentOS；但 Oracle 是离线算法，需要未来访问序列。它说明“换出算法本身”仍有提升空间，而不是说 AgentOS 已经足够好。

这两个反例支持命题 4：命中率是必要但不充分的指标。Agent 评测应同时报告原始命中、污染、有效命中、成本和任务成功，避免用单一指标替代端到端效用。

4.5.3 抖动、工作集与容量规划

在 4K 窗口下，LRU 和 AgentOS 的原始命中率分别只有 0.255 和 0.259，有效命中率接近原始值（污染接近 0），说明系统处于“容量不足但上下文干净”的状态：大量所需页根本装不进来，但装进来的页大多有用。8K 时，原始命中率升到 0.438，污染率升到 0.200，有效命中率 0.348，达到最佳平衡。16K 和 32K 时，原始命中率继续升到 0.578/0.596，但污染率升到 0.537/0.666，有效命中率降到 0.261/0.189。

这条曲线可以解释为三个阶段：

1. 容量受限区（< 工作集）：命中率低，污染低，任务受缺页限制；应增加容量或改进检索。
2. 工作集匹配区（≈ 工作集）：命中率和污染达到平衡，有效命中率最高；应保持目标预算稳定。
3. 过度驻留区（> 工作集）：命中率继续上升，但污染快速上升，有效命中率下降；应主动限制目标预算、清理陈旧页、压缩换出。

这与 Denning [1] 的工作集直觉一致：分配少于工作集会抖动，分配远多于工作集则浪费且可能引入干扰。本文的贡献是把“远多于工作集”的代价从“浪费内存”扩展为“降低有效上下文”。

4.5.4 成本分析

每步成本由检索、注意力、切换和回写组成。在 8K 主实验中，AgentOS 的成本 37.69 高于 LRU 的 36.55，主要来自相位信号带来的额外换出和检索；但 AgentOS 的污染更低，因此有效命中率略高。在 32K 目标预算扫描中，成本从 4K 的 45.18 降到 32K 的 34.90，说明大窗口减少了检索次数；但有效命中率下降得更快，导致成本效率在 8K 最高。这验证了第 3.5.7 节的盈亏平衡直觉：不是检索越少越好，也不是窗口越大越好，而是要在“保留的注意力成本”和“换出的检索成本”之间取平衡。

4.5.5 失败案例

• LFU 的陈旧流行：LFU 原始命中率只有 0.320，污染率 0.533。它会把早期高频但已过时的页长期保留，导致相位切换后大量缺页。这说明“频率”必须与“时间衰减”和“相位”结合。
• FIFO 的相位错配：FIFO 在相位切换时仍保留旧相位页，原始命中率 0.386，污染率 0.371。它比 LFU 好，但明显不如 LRU。
• RAG 的检索噪声：RAG 每步 top-10 重建，原始命中率很高，但污染率 0.650，成本 3.4 倍。真实系统应加入重排、去重、时间衰减和预算约束，而不是把 top-k 直接塞进窗口。
• 预取的无效性：简单随机预取没有收益。预取的价值取决于预测质量；在相位边界不明确或计划文本不可用时，预取容易变成污染源。

4.5.6 外部效度

本模拟的外部效度受以下因素限制：

• 没有真实 LLM：有效命中率是代理指标，未与任何模型的问答准确率、任务成功率或人类判断校准。
• 没有位置效应：模拟不区分页在上下文中的位置；真实模型对开头、中间、结尾的利用不同 [6]。
• 没有语义检索错误：RAG 的检索命中率固定为 0.85；真实检索会受查询改写、嵌入模型、索引质量和多跳推理影响。
• 没有多 Agent 并发：模拟是单会话的；多 Agent 共享、竞争和 COW 没有建模。
• 没有 KV cache 与延迟：成本模型是抽象的；真实推理的 TTFT、TPOT、批处理和缓存命中会改变最优策略。
• 参数选择：页大小分布、相位长度、访问混合比例和成本系数都是人为设定；不同任务分布可能移动峰值位置。

因此，本文把模拟定位为机制检验，而不是性能声明。它的价值在于：即使用最有利于“窗口越大越好”的简单模型，仍然出现了有效命中率的倒 U 形；这为在真实系统中进一步验证提供了理由。

4.6 Limitations

本文的局限可以归为五类：

1. 证据强度：核心实验是合成模拟，不是 LLM 基准。所有关于真实任务收益的陈述都应视为待验证假设。本文没有在 LongMemEval [36]、LoCoMo 类评测 [37]、τ-bench [27]、AgentBench [24]、OSWorld [26]、SWE-bench [48] 或 TheAgentCompany [28] 上运行实验；这些是下一步工作。
2. 代理指标：有效命中率 $h(1-\rho )$ 是一个简洁但粗糙的代理。它假设污染线性折损效用，忽略位置、指令层级、语义重复和模型鲁棒性。真实校准需要控制位置、长度和污染度的析因实验。
3. 策略覆盖：本文只比较了 FIFO、LRU、LFU、CLOCK、RAG、Oracle 和一个 AgentOS 启发式；没有比较学习型策略、语义缓存、图记忆检索或分层摘要的完整组合。AgentOS 的评分权重是手调的，未做贝叶斯优化或 RL 训练。
4. 系统实现：本文没有实现完整的 AgentOS 原型，没有测量真实上下文切换、检索延迟、KV cache 命中和多租户隔离开销。系统调用接口是设计草案，不是稳定标准。
5. 安全与隐私：保护环、污点标记和审计只是架构建议，没有经过红队测试。记忆删除、遗忘、跨租户隔离和提示注入防御需要独立的安全评估。

这些局限不影响本文的立场：Agent 需要操作系统式的上下文管理；但它们限制了本文结论的适用范围。我们明确反对把合成模拟的数字包装成“显著优于 SOTA”的实证结果。

5 Discussion

5.1 类比为什么有效

“LLM 是 CPU，上下文是内存”之所以有效，是因为它把四类看似不同的工程问题统一到同一组约束下：

• 容量约束：窗口有限，token 有成本；
• 层次约束：不同存储层的延迟、容量和持久性不同；
• 局部性约束：访问序列有阶段性和时间局部性；
• 保护约束：不同信任级别的数据不能混在一起。

一旦接受这组约束，很多设计问题就有了共同语言：检索是缺页处理，摘要换出是压缩分页，钉住是 mlock，多 Agent 共享是 COW，上下文切换是进程切换，污染是缓存污染，抖动是工作集不足。这种统一语言有助于跨团队协作：模型团队、推理团队、Agent 框架团队和安全团队可以用同一套指标讨论问题。

5.2 类比的五个失效点

类比也有边界。忽略这些边界会导致错误设计。

第一，语义寻址 vs 字节寻址。 传统页表把虚拟地址精确映射到物理页；Agent 的“地址”是语义的、模糊的、多对多的。一个查询可能匹配多个记忆对象，一个对象可能属于多个任务阶段。Context MMU 不能假设精确命中，必须处理候选集、置信度和语义冲突。这意味着“缺页”往往不是二值的，而是“部分命中”“近似命中”“错误命中”。

第二，有损换出 vs 精确换出。 传统换出把页原样写到磁盘，换入后完全恢复；Agent 的换出往往需要摘要、压缩或结构化，恢复后可能丢失细节。系统必须记录摘要的损失程度、来源和置信度，并在关键决策处要求回读原文。否则，Agent 会把“摘要的记忆”当作“事实的记忆”，产生难以追踪的错误。

第三，随机执行 vs 确定性执行。 CPU 对相同输入产生相同输出；LLM 对相同上下文可能产生不同输出。上下文管理的效果因此是统计性的：同一策略在不同采样、不同温度、不同模型版本下可能表现不同。评估需要多次运行、置信区间和版本控制，不能只看单次轨迹。

第四，隐式缺页 vs 硬件缺页。 传统缺页由硬件精确触发；Agent 的缺页需要从行为中推断。模型可能在没有所需信息时“编造”一个答案（静默缺页），也可能在信息已存在时忽略它（静默未命中）。系统需要主动探测：要求模型引用来源、做一致性检查、在关键步骤强制检索，或者用外部验证器检查输出。

第五，二次成本与位置效应。 传统内存的访问成本近似均匀；Transformer 的注意力成本随上下文长度二次增长，且模型对上下文不同位置的利用不均匀。上下文不是“越多越便宜”的存储，而是“越长越贵、越中间越容易被忽略”的资源。这要求目标预算、页排序和分段提示共同优化，而不是只做换出。

5.3 对研究与产业的启示

对研究：

• 评测应从“窗口大小”转向“有效上下文”：报告有效命中率、污染率、成本效率和任务成功，而不仅是长上下文检索分数。
• 需要标准化的 Agent 记忆对象格式：对象标识、版本、来源、置信度、保护级别和摘要指针。这类似于数据集的数据卡（datasheet）[49] 和 ML 元数据规范 [50]，但面向运行时记忆。
• 需要 AgentOS 基准：不仅测任务成功，还测缺页率、上下文切换、污染、内存安全和多租户隔离。
• 需要学习型策略：把换出、预取、目标预算和压缩级别建模为序贯决策；奖励应包含任务成功、token、延迟和安全惩罚。

对产业：

• 模型/推理服务应暴露上下文管理接口：目标预算、前缀缓存、页级计量、污染指标和快照/恢复。
• Agent 平台应把记忆层与执行层解耦：记忆可以是向量库、图数据库、文件系统或企业知识库，但都需要统一的页表和计费。
• 企业采购应关注“每任务成本”和“有效上下文”，而不是只看“支持多长窗口”。一个 32K 窗口如果只能有效利用 8K，按 32K 计费就是资源浪费。
• 安全团队应把 Agent 记忆纳入数据治理：分类、保留期限、删除权、审计和跨租户隔离。

5.4 安全、隐私与伦理

长程 Agent 的记忆会积累大量用户数据、企业机密和工具输出。OS 类比提醒我们，内存管理从来不只是性能问题，也是安全问题：

• 隐私与删除权：用户应能查看、导出和删除 Agent 的长期记忆；删除不仅要删原文，还要删摘要、索引、缓存和派生对象。这类似“被遗忘权”在 Agent 记忆中的实现。
• 租户隔离：多租户 Agent 平台必须保证记忆页不跨租户泄漏；共享前缀缓存需要按租户分区或加密隔离。
• 提示注入与记忆投毒：不可信工具输出进入 Ring 3，必须带污点标记；任何试图提升权限、修改安全策略或写入 Ring 0/1 的内容都应被拦截和审计。
• 可审计性：每个记忆写入、换出、压缩和删除都应有不可篡改的日志；否则出现错误或事故时无法定位。
• 过度依赖与操纵：长期记忆可能让 Agent 形成对用户的过度建模，带来操纵、偏见放大和隐私推断风险。系统应限制记忆类型、保留期限和用途，并提供用户控制。

5.5 开放问题

1. 语义页表怎么写？ 如何表示对象之间的包含、引用、冲突和版本关系？如何处理同一事实的多个来源和矛盾？
2. 换出策略能否学习？ 能否用离线轨迹预训练一个换出评分器，再在线用 bandit 微调？如何保证可解释性和安全约束？
3. 目标预算能否自动校准？ 能否从任务类型、计划长度、工具调用模式和检索成本预测最优 $T_t$？
4. 多 Agent 如何共享记忆？ COW、共享只读页、消息传递和一致性协议如何设计？如何处理并发写入和版本冲突？
5. 如何评测 AgentOS？ 需要一套跨模型、跨任务、跨租户的基准，测量任务成功、有效上下文、成本、延迟和安全事件。
6. 形式化保证？ 能否证明在某些访问分布下，目标预算策略的竞争比或遗憾界？能否证明保护域设计能阻止某类提示注入？

6 Conclusion

本文从“LLM 近似 CPU、上下文窗口近似内存”这一类比出发，把 Agent 的上下文管理形式化为带预算、语义寻址和有损换出的工作集问题。我们提出以有效上下文（原始命中率乘以 1 减污染率）为核心的目标，给出 AgentOS 参考架构，包括 Context MMU、缺页处理、控制页钉住与保护、压缩换出、预取、调度和可观测性，并推导了工作集可行性、有效预算倒 U 形、钉住权衡、命中率与效用不一致以及在线换出不可最优等命题。

在 10 个随机种子的合成机制模拟中，我们观察到：物理窗口从 8K 扩到 32K 会把原始命中率从 0.438 提高到 0.596，但把有效命中率从 0.348 降低到 0.189；在 32K 窗口下把有效预算限制在 8K，可把有效命中率恢复到 0.354。AgentOS 相对 LRU 把有效命中率从 0.348 提到 0.353，把污染率从 0.200 降到 0.150，代价是每步成本增加约 3.0%。这些数字是合成模拟结果，不是 LLM 实证；它们支持机制层面的假设，但不能外推为真实任务收益。

本文的结论不是“AgentOS 已经优于现有方法”，而是：上下文窗口是需要被管理的资源，而不是可以无限填满的容器；有效上下文、污染和成本应当成为 Agent 系统的一等指标。未来工作将沿三条线推进：第一，在 vLLM/SGLang 等推理引擎上实现 AgentOS 原型，测量真实缺页、上下文切换、KV cache 复用和多租户开销；第二，在 LongMemEval、LoCoMo 类评测、τ-bench、AgentBench、OSWorld、SWE-bench 和 TheAgentCompany 上验证有效上下文与任务成功的关系；第三，把换出、预取、目标预算和压缩级别建模为可学习策略，并在安全约束下做在线优化。

References

[1] Denning, P. J. The working set model for program behavior. Communications of the ACM, 11(5):323–333, 1968.

[2] Belady, L. A. A study of replacement algorithms for a virtual-storage computer. IBM Systems Journal, 5(2):78–101, 1966.

[3] Sleator, D. D., & Tarjan, R. E. Amortized efficiency of list update and paging rules. Communications of the ACM, 28(2):202–208, 1985.

[4] Arpaci-Dusseau, R. H., & Arpaci-Dusseau, A. C. Operating Systems: Three Easy Pieces. Arpaci-Dusseau Books, 2018.

[5] Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł., & Polosukhin, I. Attention is all you need. NeurIPS, 2017. arXiv:1706.03762.

[6] Liu, N. F., Lin, K., Hewitt, J., Paranjape, A., Bevilacqua, M., Petroni, F., & Liang, P. Lost in the middle: How language models use long contexts. Transactions of the Association for Computational Linguistics, 12:157–173, 2024. arXiv:2307.03172.

[7] Hsieh, C.-P., Sun, S., Kriman, S., Acharya, S., Rekesh, D., Jia, F., Zhang, Y., & Ginsburg, B. RULER: What’s the real context size of your long-context language models? COLM, 2024. arXiv:2404.06654.

[8] Bai, Y., Lv, X., Zhang, J., Lyu, H., Tang, J., Huang, Z., Du, Z., Liu, X., Zeng, A., Hou, L., Dong, Y., Tang, J., & Li, J. LongBench: A bilingual, multitask benchmark for long context understanding. arXiv:2308.14508, 2023.

[9] Xiao, G., Tian, Y., Chen, B., Han, S., & Lewis, M. Efficient streaming language models with attention sinks. ICLR, 2024. arXiv:2309.17453.

[10] Zhang, Z., Sheng, Y., Zhou, T., Chen, T., Zheng, L., Cai, R., Song, Z., Tian, Y., Ré, C., Barrett, C., Wang, Z., & Chen, B. H2O: Heavy-hitter oracle for efficient generative inference of large language models. NeurIPS, 2023. arXiv:2306.14048.

[11] Kwon, W., Li, Z., Zhuang, S., Sheng, Y., Zheng, L., Yu, C. H., Gonzalez, J. E., Zhang, H., & Stoica, I. Efficient memory management for large language model serving with PagedAttention. SOSP, 2023. arXiv:2309.06180.

[12] Agrawal, A., Kedia, N., Panwar, A., Mohan, J., Kwatra, N., Gulavani, B. S., Tumanov, A., & Ramjee, R. Taming throughput-latency tradeoff in LLM inference with Sarathi-Serve. OSDI, 2024. arXiv:2403.02310.

[13] Zhong, Y., Liu, S., Chen, J., Hu, J., Zhu, Y., Liu, X., Jin, X., & Zhang, H. DistServe: Disaggregating prefill and decoding for goodput-optimized large language model serving. OSDI, 2024. arXiv:2401.09670.

[14] Sun, B., Huang, Z., Zhao, H., Xiao, W., Zhang, X., Li, Y., & Lin, W. Llumnix: Dynamic scheduling for large language model serving. OSDI, 2024. arXiv:2406.03243.

[15] Qin, R., Li, Z., He, W., Zhang, M., Wu, Y., Zheng, W., & Xu, X. Mooncake: A KVCache-centric disaggregated architecture for LLM serving. arXiv:2407.00079, 2024.

[16] Zheng, L., Yin, L., Xie, Z., Huang, J., Sun, C., Yu, C. H., Cao, S., Kozyrakis, C., Stoica, I., Gonzalez, J. E., Barrett, C., & Sheng, Y. SGLang: Efficient execution of structured language model programs. arXiv:2312.07104, 2023.

[17] Gim, I., Chen, G., Lee, S.-s., Sarda, N., Khandelwal, A., & Zhong, L. Prompt Cache: Modular attention reuse for low-latency inference. MLSys, 2024. arXiv:2311.04934.

[18] Packer, C., Wooders, S., Lin, K., Fang, V., Patil, S. G., Stoica, I., & Gonzalez, J. E. MemGPT: Towards LLMs as operating systems. arXiv:2310.08560, 2023.

[19] Mei, K., Zhu, X., Xu, W., Hua, W., Jin, M., Li, Z., Xu, S., Ye, R., Ge, Y., & Zhang, Y. AIOS: LLM agent operating system. COLM, 2025. arXiv:2403.16971.

[20] Sumers, T. R., Yao, S., Narasimhan, K., & Griffiths, T. L. Cognitive architectures for language agents. Transactions on Machine Learning Research, 2024. arXiv:2309.02427.

[21] Park, J. S., O’Brien, J. C., Cai, C. J., Morris, M. R., Liang, P., & Bernstein, M. S. Generative agents: Interactive simulacra of human behavior. UIST, 2023. arXiv:2304.03442.

[22] Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., & Cao, Y. ReAct: Synergizing reasoning and acting in language models. ICLR, 2023. arXiv:2210.03629.

[23] Yang, J., Jimenez, C. E., Wettig, A., Lieret, K., Yao, S., Narasimhan, K., & Press, O. SWE-agent: Agent-computer interfaces enable automated software engineering. arXiv:2405.15793, 2024.

[24] Liu, X., Yu, H., Zhang, H., Xu, Y., Lei, X., Lai, H., Gu, Y., Ding, H., Men, K., Yang, K., Zhang, S., Deng, X., Zeng, A., Du, Z., Zhang, C., Shen, S., Zhang, T., Su, Y., Sun, H., Huang, M., Dong, Y., & Tang, J. AgentBench: Evaluating LLMs as agents. ICLR, 2024. arXiv:2308.03688.

[25] Zhou, S., Xu, F. F., Zhu, H., Zhou, X., Lo, R., Sridhar, A., Cheng, X., Ou, T., Bisk, Y., Fried, D., Alon, U., & Neubig, G. WebArena: A realistic web environment for building autonomous agents. ICLR, 2024. arXiv:2307.13854.

[26] Xie, T., Zhang, D., Chen, J., Li, X., Zhao, S., Cao, R., Hua, T., Cheng, Z., Shin, D., Lei, F., Liu, Y., Xu, Y., Zhou, S., Savarese, S., Xiong, C., Zhong, V., & Yu, T. OSWorld: Benchmarking multimodal agents for open-ended tasks in real computer environments. arXiv:2404.07972, 2024.

[27] Yao, S., Shinn, N., Razavi, P., & Narasimhan, K. τ-bench: A benchmark for tool-agent-user interaction in real-world domains. arXiv:2406.12045, 2024.

[28] Xu, F. F., Song, Y., Li, B., Tang, Y., Jain, K., Bao, M., Wang, Z. Z., Zhou, X., Guo, Z., Cao, M., Yang, M., Lu, H. Y., Martin, A., Su, Z., Maben, L., Mehta, R., Chi, W., Jang, L., Xie, Y., Zhou, S., & Neubig, G. TheAgentCompany: Benchmarking LLM agents on consequential real world tasks. arXiv:2412.14161, 2024.

[29] Zhang, Z., Bo, X., Ma, C., Li, R., Chen, X., Dai, Q., Zhu, J., Dong, Z., & Wen, J.-R. A survey on the memory mechanism of large language model based agents. arXiv:2404.13501, 2024.

[30] Xu, W., Liang, Z., Mei, K., Gao, H., Tan, J., & Zhang, Y. A-Mem: Agentic memory for LLM agents. arXiv:2502.12110, 2025.

[31] Chhikara, P., Khant, D., Aryan, S., Singh, T., & Yadav, D. Mem0: Building production-ready AI agents with scalable long-term memory. arXiv:2504.19413, 2025.

[32] Rasmussen, P., Paliychuk, P., Beauvais, T., Ryan, J., & Chalef, D. Zep: A temporal knowledge graph architecture for agent memory. arXiv:2501.13956, 2025.

[33] Kang, J., Ji, M., Zhao, Z., & Bai, T. Memory OS of AI agent. arXiv:2506.06326, 2025.

[34] Wang, Y., & Chen, X. MIRIX: Multi-agent memory system for LLM-based agents. arXiv:2507.07957, 2025.

[35] Yan, S., Yang, X., Huang, Z., Nie, E., Ding, Z., Li, Z., Ma, X., Bi, J., Kersting, K., Pan, J. Z., Schuetze, H., Tresp, V., & Ma, Y. Memory-R1: Enhancing large language model agents to manage and utilize memories via reinforcement learning. arXiv:2508.19828, 2025.

[36] Wu, D., Wang, H., Yu, W., Zhang, Y., Chang, K.-W., & Yu, D. LongMemEval: Benchmarking chat assistants on long-term interactive memory. ICLR, 2025. arXiv:2410.10813.

[37] Maharana, A., Lee, D.-H., Tulyakov, S., Bansal, M., Barbieri, F., & Fang, Y. Evaluating very long-term conversational memory of LLM agents. arXiv:2402.17753, 2024.

[38] Hu, Y., Wang, Y., & McAuley, J. Evaluating memory in LLM agents via incremental multi-turn interactions. ICLR, 2026. arXiv:2507.05257.

[39] Tan, H., Zhang, Z., Ma, C., Chen, X., Dai, Q., & Dong, Z. MemBench: Towards more comprehensive evaluation on the memory of LLM-based agents. arXiv:2506.21605, 2025.

[40] Dong, L., Lu, Q., & Zhu, L. AgentOps: Enabling observability of LLM agents. arXiv:2411.05285, 2024.

[41] Wang, Z., Li, J., Zhou, Q., Si, H., Liu, Y., Li, J., Xie, G., Sun, F., et al. A survey on AgentOps: Categorization, challenges, and future directions. arXiv:2508.02121, 2025.

[42] Kapoor, S., Stroebl, B., Kirgis, P., Nadgir, N., Siegel, Z. S., Wei, B., Xue, T., Chen, Z., Chen, F., Utpala, S., Ndzomga, F., Oruganty, D., Luskin, S., Liu, K., Yu, B., Arora, A., Hahm, D., Trivedi, H., Sun, H., Lee, J., Jin, T., Mai, Y., Zhou, Y., Zhu, Y., Bommasani, R., Kang, D., Song, D., Henderson, P., Su, Y., Liang, P., & Narayanan, A. Holistic Agent Leaderboard: The missing infrastructure for AI agent evaluation. arXiv:2510.11977, 2025.

[43] Debenedetti, E., Zhang, J., Balunović, M., Beurer-Kellner, L., Fischer, M., & Tramèr, F. AgentDojo: A dynamic environment to evaluate prompt injection attacks and defenses for LLM agents. arXiv:2406.13352, 2024.

[44] Kim, S., Moon, S., Tabrizi, R., Lee, N., Mahoney, M. W., Keutzer, K., & Gholami, A. An LLM compiler for parallel function calling. arXiv:2312.04511, 2023.

[45] Lin, C., Han, Z., Zhang, C., Yang, Y., Yang, F., Chen, C., & Qiu, L. Parrot: Efficient serving of LLM-based applications with semantic variable. arXiv:2405.19888, 2024.

[46] Luo, M., Shi, X., Cai, C., Zhang, T., Wong, J., Wang, Y., Wang, C., Huang, Y., Chen, Z., Gonzalez, J. E., & Stoica, I. Autellix: An efficient serving engine for LLM agents as general programs. arXiv:2502.13965, 2025.

[47] Wu, Z., Han, C., Ding, Z., Weng, Z., Liu, Z., Yao, S., Yu, T., & Kong, L. OS-Copilot: Towards generalist computer agents with self-improvement. arXiv:2402.07456, 2024.

[48] Jimenez, C. E., Yang, J., Wettig, A., Yao, S., Pei, K., Press, O., & Narasimhan, K. SWE-bench: Can language models resolve real-world GitHub issues? ICLR, 2024. arXiv:2310.06770.

[49] Gebru, T., Morgenstern, J., Vecchione, B., Vaughan, J. W., Wallach, H., Daumé III, H., & Crawford, K. Datasheets for datasets. Communications of the ACM, 64(12):86–92, 2021. arXiv:1803.09010.

[50] Akhtar, M., Benjelloun, O., Conforti, C., Foschini, L., Gijsbers, P., Giner-Miguelez, J., Goswami, S., Jain, N., et al. Croissant: A metadata format for ML-ready datasets. arXiv:2403.19546, 2024.

Appendix

A. 命题证明与推导

A.1 命题 1 的证明

设 $P_t$ 与 $W_t$ 不相交（控制页与工作集页不重叠；若重叠，可先去重）。若

$$\sum _{m_i\in P_t}{s}_i+\sum _{m_i\in W_t}{s}_i>B_t,$$

则任何满足 ${\sum }_{m_i\in R_t}{s}_i\le B_t$ 的 $R_t$ 都不能同时包含 $P_t$ 和 $W_t$。因此至少存在一个控制页 $p\in P_t\setminus R_t$ 或一个工作集页 $w\in W_t\setminus R_t$。前者导致控制缺页，后者导致工作集缺页。若工作集对任务进展必要，则工作集缺页会导致任务步骤无法完成或需要额外检索。证毕。

A.2 命题 2 的推导

对 $\tilde{h}(B)=h(B)(1-\rho (B))$ 求导：

$${\tilde{h}}^{\prime }(B)=h^{\prime }(B)(1-\rho (B))-h(B){\rho }^{\prime }(B).$$

令 ${\tilde{h}}^{\prime }(B)<0$，得到

$${\rho }^{\prime }(B)>\frac{h^{\prime }(B)(1-\rho (B))}{h(B)}.$$

证毕。

A.3 命题 3 的推导

对

$$\tilde{h}(p)=q(p)h_{\mathrm{ws}}(B-p)(1-\rho (p))$$

求导：

$${\tilde{h}}^{\prime }(p)=q^{\prime }(p)h_{\mathrm{ws}}(B-p)(1-\rho )-q(p)h_{\mathrm{ws}}^{\prime }(B-p)(1-\rho )-q(p)h_{\mathrm{ws}}(B-p){\rho }^{\prime }(p).$$

令 ${\tilde{h}}^{\prime }(p)=0$，得到正文中的边际条件。证毕。

A.4 命题 5 的归约

给定 0/1 背包实例：物品 $i$ 的重量 $s_i$、价值 $u_i$、容量 $T$。令每个物品对应一个记忆页，保留效用为 $u_i$，大小为 $s_i$，上下文预算为 $T$。选择保留集合最大化 $\sum u_i$ 且满足 $\sum s_i\le T$ 即为背包问题。因此换出选择包含 NP 难问题作为特例。在线分页竞争比下界见 Sleator 与 Tarjan [3]。证毕。

B. 模拟器细节与可复现性

B.1 参数与实现

模拟器为单文件 Python 程序，主要参数如下：

参数	值
记忆对象数	2000
相位数量	8
每相位步数	30
每相位热点页	60
每相位新增页	40
控制页	8
每步所需页	4
页大小	对数正态，截断到 32–512，均值约 128
物理窗口	8192（主实验）
工作集窗 $\Delta$	12
检索成本	每 128 token 8 个基础单位 + 4 个浮动单位
注意力成本	$0.02\times (\mathrm{tokens}/1024{)}^2$
切换成本	每页 1
回写成本	每 128 token 4 个基础单位 + 2 个浮动单位
随机种子	0–9

B.2 访问生成

每步的访问集按混合分布生成：

• 62% 当前相位热点页；
• 16% 上一相位热点页；
• 10% 控制页；
• 12% 全局随机页；
• 额外 8% 概率访问下一相位页。

每个相位的热点集由 40 个新页和至多 20 个上一相位页组成，以模拟任务连续性。页大小在任务开始时一次性生成，之后保持不变。

B.3 策略实现

• FIFO：维护装入顺序，容量不足时换出最早装入页。
• LRU：维护最后访问时间，换出最久未使用页。
• LFU：维护访问计数，换出计数最低页；计数相同则换出最久未使用页。
• CLOCK：维护引用位和环形指针，二次机会换出。
• RAG：每步清空上下文，按 0.85 概率装入所需页，再用当前相位热点页和随机页填满 10 个槽位；污染率按非所需页 token 占比计算。
• Oracle：预计算每个页的下一次使用步，换出下一次使用最远的页。
• AgentOS：钉住控制页；评分包含新近性、频率、相位、重算成本、大小、脏页；当最近至少 10 步（最多 20 步）的平均命中率低于 0.35 时回退到 LRU；在接近容量阈值时主动清理陈旧页；可选预取下一相位页。

B.4 运行与分析

# 主实验 + 窗口扫描 + 有效预算扫描
python3 context_paging_sim.py \
  --seeds 0 1 2 3 4 5 6 7 8 9 \
  --sweep \
  --out context_paging_results.json

# 仅主实验
python3 context_paging_sim.py \
  --seeds 0 1 2 3 4 \
  --out context_paging_results_small.json

结果文件包含 main、ablations、budget_sweep 和 target_sweep 四部分，每项报告均值和总体标准差。本文表 8–11 的数字来自该文件。

C. 真实基准验证协议（待执行）

本节给出真实实验设计。表 C1 中的所有结果均为 ；本文没有伪造任何真实基准数字。

表 C1 真实基准验证计划

基准	任务类型	关键指标	状态
LongMemEval [36]	长期交互记忆（500 题，5 类能力）	准确率、token、有效上下文、污染	[TODO: 实验数据待填]
LoCoMo 类多会话记忆 [37]	多会话对话记忆	F1、BLEU、延迟、成本	[TODO: 实验数据待填]
τ-bench [27]	工具- Agent-用户交互	任务成功率、轮数、成本	[TODO: 实验数据待填]
AgentBench [24]	多环境 Agent	成功率、步数、token	[TODO: 实验数据待填]
OSWorld [26]	真实计算机任务	成功率、步数、恢复率	[TODO: 实验数据待填]
SWE-bench [48]	真实 GitHub issue 修复	解决率、测试通过率、成本	[TODO: 实验数据待填]
TheAgentCompany [28]	真实工作任务	完成率、成本、错误类型	[TODO: 实验数据待填]

实验设计要点：

1. 基线：固定窗口滑动、LRU、RAG top-k、MemGPT 风格自我管理、MemoryOS 风格分层记忆、AgentOS 完整策略。
2. 控制变量：同一模型、同一温度、同一工具集、同一检索器；只改变上下文管理策略。
3. 指标：任务成功、有效上下文（人工或模型判断所需页是否被使用）、污染率、token 成本、墙钟延迟、缺页率、抖动率、安全事件。
4. 统计：每个配置至少 5 个随机种子或 5 次运行，报告均值、标准差和置信区间；预注册主要指标，避免选择性报告。
5. 消融：钉住、相位、预取、压缩、目标预算分别开关；报告成本归一化后的效用。
6. 安全：在 AgentDojo [43] 类提示注入环境中测试保护域和污点标记；记录越权尝试和记忆投毒事件。

可证伪的预测：

• P1：在长程任务上，目标预算小于物理窗口的 AgentOS 配置，其每任务成本低于“填满窗口”配置，任务成功不低；
• P2：在存在大量干扰项的任务上，污染率与任务成功负相关，且相关性强于原始命中率；
• P3：控制页钉住降低控制缺页和安全违规，但过度钉住会挤占工作集；
• P4：计划感知预取在相位明确的超长任务上有正收益，在相位不明确的任务上无收益或负收益。

如果这些预测在真实基准上不成立，本文的框架需要修正；我们会在后续版本中报告负面结果。

D. 系统调用伪代码

# 注册一个记忆对象
handle = ctx.map(
    object_id="episode_42",
    content=text,
    tokens=len(tokens),
    ring=RING_AGENT,
    provenance="tool:web_fetch",
    confidence=0.9
)

# 处理缺页
tokens = ctx.fault(
    handle=handle,
    query_hint="deployment environment",
    deadline_ms=200
)

# 钉住控制页
ctx.pin(handle=goal_handle, ttl=TASK_END)

# 压缩换出
summary = ctx.compact(handle=long_log, level="extractive", budget=256)
ctx.evict(handle=long_log, mode="swap")

# 读取指标
stats = ctx.stats(session_id="s-001", window=50)

E. 术语表

术语	含义
有效上下文	原始命中率乘以（1 − 污染率）的代理指标
上下文污染	驻留上下文中陈旧、无关或重复的 token 占比
工作集	最近一段时间内活跃访问的页集合
抖动	工作集大于可用容量导致的频繁缺页
控制页	目标、约束、安全策略等不可随意换出的页
静默缺页	页在窗口内但模型未使用，或模型在缺页时编造内容
压缩换出	用摘要/结构化表示替换原文并释放 token
目标预算	AgentOS 允许上下文使用的 token 上限，可小于物理窗口

---

写作与证据声明

本文的中文文本、形式化、架构与合成模拟由 DeepThink.ai 完成。模拟结果由随文脚本在本地生成，参数、种子和命令见附录 B；没有调用任何 LLM，也没有使用任何未公开数据。外部事实与数字均尽量引用可验证的 arXiv 或期刊来源；无法核实的内容在正文中以 或 标注。本文不声称“显著优于所有 SOTA”，也不声称“首次提出”；它主张的是一组可检验的设计原则和实验协议。最终投稿、查重和同行评审责任由作者承担。