feat: publish long-horizon agent chapter

2026-07-29 06:54:31 +08:00
parent 6c8c0fb90f
commit 25982cbbb4
25 changed files with 5122 additions and 39 deletions
@@ -16,6 +16,7 @@
 | DeepSeek 专题 | 进行中 | 71% | 补 R1 / DAPO 的逐图训练轨迹与复现对照 |
 | 指令微调与人类偏好 | 完成首版 | 75% | 真实偏好分歧、RM 长度偏置与 PPO/DPO 小模型复现 |
 | 推理与测试时扩展 | 完成首版 | 76% | 真实模型采样曲线、PRM 案例与逐篇图表精读 |
 | 工具使用与长程 Agent | 完成首版 | 74% | 真实环境 traces、cross-harness 对照、Agent RL 曲线与安全案例 |
 | 稀疏计算与 MoE | 完成首版 | 74% | 真实负载 traces 与专家特化案例 |
 | 长上下文专题 | 完成首版 | 72% | 真实模型配置、内核细节与失败案例 |
 | 大规模训练系统 | 完成首版 | 71% | 真实集群 traces、故障案例与精确 topology 配置 |
@@ -33,10 +34,10 @@
 - [x] 提炼参考网站的编辑设计语言。
 - [x] 确认 `git.k1412.top` 为 Gitea/Forgejo 兼容服务且本机 HTTPS 凭据可用于既有仓库。
 - [x] 使用 Grok CLI 检索并形成约 95 篇一手论文的补充路线，主代理已回查关键来源。
- [x] 完成 280 篇关键论文索引，覆盖 14 个标签专题与 Kimi/DeepSeek 聚光主线。
+- [x] 完成 314 篇关键论文索引，覆盖 14 个标签专题与 Kimi/DeepSeek 聚光主线。
 - [x] 完成可检索、可按专题筛选的论文库页面。
- [x] 完成 K3、语言模型前史、Transformer 基础、DeepSeek 谱系、Scaling Laws、数据工程、长上下文、MoE、指令微调与人类偏好、推理、训练系统与数值优化十二篇首版长文。
+- [x] 完成 K3、语言模型前史、Transformer 基础、DeepSeek 谱系、Scaling Laws、数据工程、长上下文、MoE、指令微调与人类偏好、推理、Agent、训练系统与数值优化十三篇首版长文。
- [x] 完成 K3 三轴架构、语言模型前史四联实验、Transformer 四联实验、DeepSeek 谱系、长上下文、MoE 路由、推理三页签，以及训练系统、Scaling、数据工程、数值与 Alignment 专题各四页签等三十五个原创交互视图。
+- [x] 完成 K3 三轴架构、语言模型前史四联实验、Transformer 四联实验、DeepSeek 谱系、长上下文、MoE 路由、推理三页签，以及训练系统、Scaling、数据工程、数值、Alignment 与 Agent 专题各四页签等三十九个原创交互视图。
 - [x] 完成长上下文首版：五张成本账、26 篇一手论文、10+ 机制图与 8 策略交互实验室。
 - [x] 核验 FlashAttention、DeepSeek-V2/V3.2/V4、Kimi Linear/K3 等六份论文原文，并建立长上下文研究账本。
 - [x] 核验 Switch、ST-MoE、DeepSeekMoE、Loss-Free、V3、LatentMoE 与 K3 原文，并建立 MoE 研究账本。
@@ -99,9 +100,18 @@
 - [x] Alignment 真实 Chrome 断言通过：response-only / all-token SFT mask、both-bad preference、DPO 陈旧分布、K3 九教师配方、键盘 tabs 与 390px 移动端均正确响应。
 - [x] Astro 类型检查、生产构建、16 个页面、713 个站内引用和 17 个跨页锚点通过；九套专题公网 Chrome 回归无异常。
 - [x] Alignment 首版以源提交 `8378e2a`、不可变镜像 `20260728T220753Z-8378e2a` 发布；NAS、VPS/Tailscale、NPM、DNS、HTTPS、证书、门户与公开 Forgejo 全链路通过。
 - [x] 启动 Agent 专题：用十四张问题账拆开环境、工具契约、控制循环、执行、验证、可靠性、安全、credit assignment 与长轨迹系统。
 - [x] 使用 Grok Headless 扩展 Agent 候选路线；35 份新增 PDF 与 BFCL 的 ICML/PMLR 正式版本由主代理逐份回查，候选与正式证据永久分离。
 - [x] 建立 Agent 正式研究账本：五层系统模型、五波历史主线、DeepSeek/Kimi 双谱系、四条因果链、四实验合同、常见误解与 52 节点阅读链。
 - [x] 完成 Agent 首版正文与四联实验：控制循环、工具契约、pass@k / pass^k 可靠性、partial rollout / external KV / AgentENV 长程 RL 分开演示。
 - [x] 论文库新增 TextWorld、WebArena、ToolSandbox、AgentDojo、RAGEN、Agent Lightning、AgentENV 等 34 个 Agent 节点，从 280 篇扩充至 314 篇。
 - [x] Agent 真实 Chrome 断言通过：Direct/schema 故障传播、final-state verifier、pass@k / pass^k、非幂等副作用、wait-all 长尾、键盘 tabs 与 390px 移动端均正确响应。
 - [x] Astro 类型检查、生产构建、17 个页面、792 个站内引用和 18 个跨页锚点通过；Agent 与既有九套专题本地 Chrome 全量回归无异常。
 ## 正在进行
 - [ ] Agent 首版生产发布：公开 Forgejo、不可变镜像、NAS、NPM、HTTPS 与十套公网 Chrome 回归。
 - [ ] Agent 二轮：真实环境 traces、cross-harness ablation、Agent RL 训练曲线与提示注入案例。
 - [ ] Transformer 二轮：多头电路逐图、Pre/Post-LN 真实 traces、Flash/KV kernel 与模型配置对照。
 - [ ] 语言模型前史二轮：Kneser–Ney / LSTM / Bahdanau 逐图精读、真实小语料复现与 tokenizer 公平性案例。
 - [ ] Scaling Laws 二轮精读：真实拟合复现、逐篇图表、置信区间、外推失败与更多模型族对照。
@@ -170,6 +180,11 @@
 | 2026-07-29 | Alignment 首版用 44 个一手节点与四个独立实验闭环 | SFT token mask、RM 偏置、PPO/DPO 更新与模型配方分开演示，不合成伪“对齐总分” |
 | 2026-07-29 | 论文库扩充到 280 篇 | 新增 22 个 SFT、偏好、RM、RLAIF、直接偏好优化与后训练评测节点 |
 | 2026-07-29 | Alignment 首版用不可变镜像 `20260728T220753Z-8378e2a` 发布 | OCI digest `sha256:ef3ad2a8…3048a`；复用 `12010→8080`、NPM host 31 / cert 41、门户 order 180 与公开 Forgejo |
 | 2026-07-29 | Agent 按十四张彼此独立的问题账组织 | 模型、harness、工具、环境、验证器、可靠性与安全不再被压成一个 Agent 分数 |
 | 2026-07-29 | Agent 完成必须回到 final state | function schema、工具执行、业务状态、策略合规与 pass^k 分层评价；模型自报完成不作为证据 |
 | 2026-07-29 | DeepSeek 与 Kimi Agent 谱系显式保留系统边界 | V3.2/V4 的训练环境与 DSec、K3 的 white-box harness/AET/AgentENV 分层说明，不把模型、脚手架和基础设施混写 |
 | 2026-07-29 | Grok Agent 线索与正式证据永久分离 | 候选只负责查漏；公式、数字和系统结论必须回到一手论文、正式会议版本或官方报告 |
 | 2026-07-29 | 论文库扩充到 314 篇 | 新增 34 个环境、工具、Web/SWE/桌面 Agent、可靠性、安全与 Agent RL 节点 |
 ## 未决问题
@@ -17,9 +17,9 @@
 - 持续进度：[PROGRESS.md](./PROGRESS.md)
 - 证据与写作规范：[research/METHODOLOGY.md](./research/METHODOLOGY.md)
-当前里程碑包含 16 专题学习地图、280 篇关键论文索引、Kimi K3 完整导读、
+当前里程碑包含 16 专题学习地图、314 篇关键论文索引、Kimi K3 完整导读，
-语言模型前史、Transformer 基础、DeepSeek 技术谱系、Scaling Laws、数据工程、长上下文、MoE、指令微调与人类偏好、推理、训练系统与数值优化深度专题，
+语言模型前史、Transformer 基础、DeepSeek 技术谱系、Scaling Laws、数据工程、长上下文、MoE、指令微调与人类偏好、推理、工具使用与长程 Agent、训练系统与数值优化深度专题，
-以及 35 个覆盖核心机制的原创交互视图。
+以及 39 个覆盖核心机制的原创交互视图。
 其余专题按进度账本持续扩建。
 ## 本地开发
@@ -97,6 +97,13 @@ CoT、自洽性、搜索、验证器、过程奖励、GRPO、DeepSeekMath、Deep
 WebGPT、Toolformer、ReAct、Reflexion、代码 Agent、Computer Use、环境奖励、可验证任务、沙箱、百万 Token 轨迹与 K3 Agentic RL。
 首版已完成：以环境、接口、循环、规划、记忆、执行、验证、轨迹、归因、策略分布、系统、
 可靠性、评测与安全十四张账，串起 2018–2026 的 52 个一手节点。正文把 model、harness、
 tool contract、environment 与 evaluator 拆成五层，覆盖 Web / SWE / 桌面 Agent、pass@k /
 pass^k、提示注入与长程 RL；重点追踪 DeepSeek-V3.2/V4 的 Agent 数据与 DSec，以及
 Kimi K2→K2.5→K3 的 white-box harness、AET、AgentENV 和百万 Token Agentic RL，并提供
 控制循环、工具契约、可靠性与长程 RL 四个独立实验。
 ### 13. 原生多模态
 ViT/CLIP → Flamingo/BLIP-2/LLaVA → 原生多模态与视频；Kimi-VL、MoonViT-V2 和“视觉进入同一主干”的意义。
@@ -18,7 +18,8 @@
    "check:numerics-browser": "node scripts/check-numerics-browser.mjs",
    "check:language-model-history-browser": "node scripts/check-language-model-history-browser.mjs",
    "check:transformer-browser": "node scripts/check-transformer-browser.mjs",
-    "check:alignment-browser": "node scripts/check-alignment-browser.mjs"
+    "check:alignment-browser": "node scripts/check-alignment-browser.mjs",
    "check:agents-browser": "node scripts/check-agents-browser.mjs"
  },
  "dependencies": {
    "@astrojs/sitemap": "3.7.3",
@@ -0,0 +1,120 @@
 # Agent 专题 · Grok 候选召回
 > 生成方式：Grok CLI headless（`--no-subagents`）
 > 日期：2026-07-29
 > 角色：只做宽召回与边界提醒，不作为正式事实来源。进入课程的结论必须回到论文、正式技术报告或官方项目文档核验。
 ## 1. Grok 给出的候选池
 ### 环境与交互前史
 | 年份 | 候选 | 建议定位 |
 |---|---|---|
 | 2018 | TextWorld | 用文本游戏把“语言模型输出”变成可执行动作 |
 | 2019 | Jericho | 交互式小说环境与世界状态 |
 | 2021 | ALFWorld | 文本世界与具身环境对齐 |
 | 2022 | ScienceWorld | 科学实验式交互环境 |
 | 2022 | WebShop | 可扩展、可验证的网页购物环境 |
 | 2022 | WebGPT | 浏览、引用、人类反馈与答案生成闭环 |
 | 2022 | SayCan | 语言可行性 × 机器人 affordance |
 | 2022 | MRKL | LLM 路由外部模块的系统架构 |
 | 2022 | PAL | 把程序执行当作外部计算器 |
 | 2022 | Code as Policies | 用代码表达可组合机器人策略 |
 ### Agent 循环、规划、反思与记忆
 | 年份 | 候选 | 建议定位 |
 |---|---|---|
 | 2022/23 | ReAct | reasoning → acting → observation 的经典循环 |
 | 2023 | Tree of Thoughts | 搜索式思考；不是默认依赖外部环境的 Agent |
 | 2023 | Self-Refine | 单次输出的反馈—改写循环 |
 | 2023 | Reflexion | 语言反思写入 episodic memory；不是参数更新 RL |
 | 2023 | ReWOO | 规划与观测解耦，减少重复调用 |
 | 2023 | LATS | 把推理、行动、规划放进树搜索 |
 | 2023 | Generative Agents | 记忆、反思、计划驱动的社会模拟 |
 | 2023 | MemGPT | 分层记忆与虚拟上下文管理 |
 | 2023 | Voyager | 自动课程、技能库与具身长期学习 |
 ### 工具学习与接口
 | 年份 | 候选 | 建议定位 |
 |---|---|---|
 | 2023 | Toolformer | 自监督筛选工具调用位置与参数 |
 | 2023 | Gorilla / APIBench | API 调用与检索感知的工具模型 |
 | 2023 | ToolLLM / ToolBench | 16K+ REST API 的数据生成、检索与搜索 |
 | 2024 | τ-bench | 工具—用户—策略三方的多轮任务 |
 | 2025 | BFCL | 从 AST/function-call 正确性扩展到多轮 agentic 评测 |
 ### 多 Agent 与编排
 | 年份 | 候选 | 建议定位 |
 |---|---|---|
 | 2023 | CAMEL | role-playing 通信协议 |
 | 2023 | MetaGPT | SOP、角色与文档驱动的软件工作流 |
 | 2023 | AutoGen | 可对话 Agent 的组合式编程框架 |
 | 2023 | HuggingGPT | 单控制器调度模型工具库；与真正对等多 Agent 区分 |
 ### Web、桌面与软件工程
 | 年份 | 候选 | 建议定位 |
 |---|---|---|
 | 2023 | Mind2Web | 真实网站离线轨迹与跨站泛化 |
 | 2023/24 | WebArena | 可自托管真实网站与执行式验证 |
 | 2023/24 | AgentBench | 八类交互环境的综合评测 |
 | 2023/24 | SWE-bench | GitHub issue → 可测试补丁的任务集 |
 | 2024 | VisualWebArena | 视觉落地的真实网页任务 |
 | 2024 | OSWorld | 真实桌面 GUI、多模态观测与执行 |
 | 2024 | SWE-agent | Agent-Computer Interface；不要把 harness 提升算成模型提升 |
 | 2024 | Agentless | 简单定位—修复—验证流水线，提醒“复杂 Agent 不必然更好” |
 | 2024 | ToolSandbox | 有状态、多轮、on-policy 用户模拟与里程碑评测 |
 | 2024 | SWE-Gym | 可执行 SWE 训练环境与 verifier 数据 |
 ### Agent RL、可靠性与安全
 | 年份 | 候选 | 建议定位 |
 |---|---|---|
 | 2024 | AgentDojo | 间接提示注入的可执行工具环境 |
 | 2024 | Agent Security Bench | 攻击与防御分类评测 |
 | 2025 | RAGEN | 多轮 Agent RL、echo trap 与 StarPO |
 | 2025 | τ²-bench | 用户和 Agent 都能改变环境的 dual-control 任务 |
 | 2025 | Agent Lightning | Agent 与训练解耦、MDP 抽象与分层 credit assignment |
 | 2025 | Long-context multi-turn SWE RL | 长上下文软件 Agent 的多轮强化学习 |
 | 2025 | MCPMark | MCP 工具使用的真实压力测试 |
 ### DeepSeek / Kimi 收束线
 | 年份 | 候选 | 建议定位 |
 |---|---|---|
 | 2025 | DeepSeek-V3.2 | agentic task synthesis、code/search/general agent 与混合 RL |
 | 2025 | Kimi K2 | agentic data synthesis、verifiable reward 与工具使用 |
 | 2026 | Kimi K2.5 | visual agentic intelligence 与 Agent Swarm |
 | 2026 | DeepSeek-V4 | interleaved thinking、agent sandbox、search/code harness |
 | 2026 | Kimi K3 | 可组合 white-box harness、AET、cross-scaffold generalization 与 1M Agentic RL |
 ## 2. 候选池暴露出的五个易混层级
 | 层级 | 典型对象 | 不能误写成 |
 |---|---|---|
 | Model | K2、K3、DeepSeek-V3.2 / V4 | 完整 Agent 产品 |
 | Harness | ReAct、SWE-agent、AutoGen | 基座模型能力 |
 | Tool contract | function schema、MCP、ACI | 环境任务成功 |
 | Environment | WebArena、OSWorld、AgentENV | 方法论文或榜单 |
 | Evaluator | tests、final state、pass^k、security cases | 模型自评或字符串相似度 |
 ## 3. 召回后必须二次核验的点
 1. BFCL 使用 ICML 2025 PMLR 论文作为 canonical 来源，不能误用 `2407.21783`。
 2. K3 的 coding / agent 数字必须同时记录模型、harness、工具、交互步数和上下文预算。
 3. SWE-bench 是任务集，SWE-agent 是 ACI/harness；二者不能合成一个“模型分数”。
 4. Reflexion 的 “verbal RL” 不更新模型权重。
 5. `pass@k` 表示给多次机会能否至少成功一次；`pass^k` 表示连续多次是否都成功。
 6. 环境、任务、policy、verifier 和运行预算必须分别建账。
 7. 极新的 OSWorld 2.0 等候选先保留在扩展阅读，不能与旧版本结果直接横比。
 ## 4. 本专题的筛选原则
 - 主脉络只保留能回答某个“Agent 为什么会失败”的论文。
 - 一个里程碑必须能落到可画的状态变化、接口契约或训练信号。
 - 只靠排行榜数字、不说明 harness 与预算的工作不进入核心解释。
 - DeepSeek 与 Kimi 报告进入正文，但官方数字明确标成“报告值”，不伪装成本站复测。
 - 正文控制在约 45–55 个关键节点；其余进入论文图谱或扩展阅读。
@@ -31,3 +31,15 @@ Alignment 首轮缓存位于 `alignment/`（不提交 PDF/TXT）：
 DeepSeek LLM/V2/V3/R1/V3.2/V4、Kimi K2/K2.5/K3 与 MOPD 复用既有本地缓存。
 正式机制、公式、版本边界与 44 节点论文链见 `../ALIGNMENT_RESEARCH.md`；Grok 候选线索单独保存在
 `../ALIGNMENT_GROK_LEADS.md`，不能直接作为正文证据。
 Agent 首轮缓存位于 `agents/`（不提交 PDF/TXT）：
 - TextWorld、Jericho、ALFWorld、ScienceWorld、WebShop 等可执行环境前史；
 - WebGPT、SayCan、ReAct、Toolformer、Reflexion、ToolLLM、WebArena、SWE-agent 与 OSWorld；
 - τ-bench / τ²-bench、AgentDojo、ToolSandbox、BFCL、RAGEN、Agent Lightning 与 AgentENV；
 - DeepSeek-V3.2/V4、Kimi K2/K2.5/K3 等模型族报告中的 Agent 数据、harness、验证器与长轨迹系统。
 首轮共核验 35 份新增 PDF，其中 BFCL 使用 ICML/PMLR 正式版本；DeepSeek、Kimi 与部分既有节点
 复用其他专题缓存。十四张问题账、52 节点论文链、四个交互实验合同与证据边界见
 `../AGENTS_RESEARCH.md`；Grok Headless 只负责扩展召回，未核验候选永久隔离在
 `../AGENTS_GROK_LEADS.md`。
@@ -0,0 +1,243 @@
 import { writeFileSync } from "node:fs";
 const cdpPort = process.env.CDP_PORT ?? "9225";
 const baseUrl = process.env.SITE_URL ?? "http://127.0.0.1:4323";
 const pages = await fetch(`http://127.0.0.1:${cdpPort}/json/list`).then((response) => response.json());
 const page = pages.find((entry) => entry.type === "page");
 if (!page) throw new Error(`CDP ${cdpPort} 没有可用页面`);
 const socket = new WebSocket(page.webSocketDebuggerUrl);
 await new Promise((resolve, reject) => {
  socket.addEventListener("open", resolve, { once: true });
  socket.addEventListener("error", reject, { once: true });
 });
 let nextId = 0;
 const pending = new Map();
 const exceptions = [];
 socket.addEventListener("message", (event) => {
  const message = JSON.parse(event.data);
  if (message.id && pending.has(message.id)) {
    const { resolve, reject } = pending.get(message.id);
    pending.delete(message.id);
    if (message.error) reject(new Error(message.error.message));
    else resolve(message.result);
  }
  if (message.method === "Runtime.exceptionThrown") {
    exceptions.push(message.params.exceptionDetails.exception?.description ?? message.params.exceptionDetails.text);
  }
 });
 const command = (method, params = {}) => new Promise((resolve, reject) => {
  const id = ++nextId;
  pending.set(id, { resolve, reject });
  socket.send(JSON.stringify({ id, method, params }));
 });
 const pause = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
 const evaluate = async (expression) => {
  const result = await command("Runtime.evaluate", { expression, returnByValue: true, awaitPromise: true });
  if (result.exceptionDetails) throw new Error(result.exceptionDetails.exception?.description ?? result.exceptionDetails.text);
  return result.result.value;
 };
 const navigate = async (path) => {
  await command("Page.navigate", { url: `${baseUrl}${path}` });
  for (let attempt = 0; attempt < 70; attempt += 1) {
    await pause(100);
    if (await evaluate("document.readyState === 'complete'")) return;
  }
  throw new Error(`${path} 加载超时`);
 };
 const screenshot = async (path) => {
  const result = await command("Page.captureScreenshot", {
    format: "png",
    captureBeyondViewport: false,
  });
  writeFileSync(path, Buffer.from(result.data, "base64"));
 };
 await command("Page.enable");
 await command("Runtime.enable");
 await command("Emulation.setDeviceMetricsOverride", {
  width: 1440,
  height: 1100,
  deviceScaleFactor: 1,
  mobile: false,
 });
 await navigate("/agents/");
 await screenshot("/tmp/llm-atlas-agents-desktop.png");
 const overview = await evaluate(`(() => ({
  title: document.querySelector("h1")?.textContent.trim(),
  sections: document.querySelectorAll(".article-section").length,
  tocLinks: document.querySelectorAll(".side-rail a").length,
  paperLinks: document.querySelectorAll(".paper-chain a").length,
  labTabs: document.querySelectorAll("[data-agent-tab]").length,
  labPanels: document.querySelectorAll("[data-agent-panel]").length,
  navLinks: document.querySelectorAll(".top-nav a").length,
  documentOverflow: document.documentElement.scrollWidth - document.documentElement.clientWidth,
 }))()`);
 const loop = await evaluate(`(() => {
  const root = document.querySelector("[data-agent-lab]");
  const read = () => ({
    status: root.querySelector("[data-loop-status]").textContent.trim(),
    observation: root.querySelector("[data-loop-observation]").textContent.trim(),
    recovery: root.querySelector("[data-loop-recovery]").textContent.trim(),
    finalState: root.querySelector("[data-loop-final]").textContent.trim(),
    takeaway: root.querySelector("[data-loop-takeaway]").textContent.trim(),
  });
  const initial = read();
  root.querySelector('[data-loop-mode="direct"]').click();
  root.querySelector('[data-loop-fault="schema"]').click();
  root.querySelector("[data-loop-next]").click();
  root.querySelector("[data-loop-next]").click();
  return { initial, directSchema: read() };
 })()`);
 const contract = await evaluate(`(() => {
  const root = document.querySelector("[data-agent-lab]");
  root.querySelector('[data-agent-tab="contract"]').click();
  root.querySelector('[data-contract-case="wrongstate"]').click();
  return {
    syntax: root.querySelector('[data-contract-score="syntax"]').textContent.trim(),
    execution: root.querySelector('[data-contract-score="execution"]').textContent.trim(),
    finalState: root.querySelector('[data-contract-score="final"]').textContent.trim(),
    takeaway: root.querySelector("[data-contract-takeaway]").textContent.trim(),
    visiblePanel: root.querySelector("[data-agent-panel]:not([hidden])").dataset.agentPanel,
  };
 })()`);
 const reliability = await evaluate(`(() => {
  const root = document.querySelector("[data-agent-lab]");
  root.querySelector('[data-agent-tab="reliability"]').click();
  const k = root.querySelector("[data-rel-k]");
  const read = () => ({
    passAt: root.querySelector("[data-rel-pass-at]").textContent.trim(),
    passHat: root.querySelector("[data-rel-pass-hat]").textContent.trim(),
    sideRisk: root.querySelector("[data-rel-side]").textContent.trim(),
    takeaway: root.querySelector("[data-rel-takeaway]").textContent.trim(),
  });
  const initial = read();
  k.value = "2";
  k.dispatchEvent(new Event("input", { bubbles: true }));
  const k2 = read();
  k.value = "8";
  k.dispatchEvent(new Event("input", { bubbles: true }));
  root.querySelector('[data-rel-idempotent="false"]').click();
  const nonIdempotent = read();
  return { initial, k2, nonIdempotent };
 })()`);
 const rl = await evaluate(`(() => {
  const root = document.querySelector("[data-agent-lab]");
  root.querySelector('[data-agent-tab="rl"]').click();
  const read = () => ({
    utilization: root.querySelector("[data-rl-util]").textContent.trim(),
    lostWork: root.querySelector("[data-rl-lost]").textContent.trim(),
    modelState: root.querySelector("[data-rl-model-state]").textContent.trim(),
    worldState: root.querySelector("[data-rl-world-state]").textContent.trim(),
    takeaway: root.querySelector("[data-rl-takeaway]").textContent.trim(),
  });
  const full = read();
  root.querySelector('[data-rl-mode="wait"]').click();
  const wait = read();
  const firstTab = root.querySelector('[data-agent-tab="loop"]');
  firstTab.focus();
  firstTab.dispatchEvent(new KeyboardEvent("keydown", { key: "End", bubbles: true }));
  return {
    full,
    wait,
    keyboardSelected: root.querySelector('[data-agent-tab][aria-selected="true"]').dataset.agentTab,
    keyboardVisible: root.querySelector("[data-agent-panel]:not([hidden])").dataset.agentPanel,
  };
 })()`);
 await evaluate(`document.querySelector("[data-agent-lab]").scrollIntoView({ block: "start", behavior: "instant" })`);
 await pause(180);
 await screenshot("/tmp/llm-atlas-agents-lab-desktop.png");
 await navigate("/");
 const home = await evaluate(`(() => ({
  releaseCards: document.querySelectorAll(".release-card").length,
  firstRelease: document.querySelector(".release-card h2").textContent.trim(),
  firstHref: document.querySelector(".release-card").getAttribute("href"),
  paperCount: document.querySelector(".hero-stats div:nth-child(3) b").textContent.trim(),
  navLinks: document.querySelectorAll(".top-nav a").length,
 }))()`);
 await navigate("/papers/");
 const papers = await evaluate(`(() => {
  const button = [...document.querySelectorAll("[data-filter]")].find((node) => node.textContent.trim() === "Agent");
  button?.click();
  return {
    total: document.querySelectorAll("[data-paper]").length,
    agentVisible: document.querySelectorAll("[data-paper]:not([hidden])").length,
    hasAgentFilter: Boolean(button),
  };
 })()`);
 await command("Emulation.setDeviceMetricsOverride", {
  width: 390,
  height: 844,
  deviceScaleFactor: 1,
  mobile: true,
 });
 await navigate("/agents/");
 const mobile = await evaluate(`(() => {
  const root = document.querySelector("[data-agent-lab]");
  root.scrollIntoView({ block: "start", behavior: "instant" });
  const toggle = document.querySelector("#menu-toggle");
  toggle?.click();
  return {
    documentOverflow: document.documentElement.scrollWidth - document.documentElement.clientWidth,
    menuVisible: getComputedStyle(toggle).display !== "none",
    menuOpen: toggle.getAttribute("aria-expanded"),
    mobileLinks: document.querySelectorAll("#mobile-nav a").length,
    tabs: root.querySelectorAll("[data-agent-tab]").length,
    offenders: [...document.querySelectorAll("body *")]
      .filter((node) => node.getBoundingClientRect().right > document.documentElement.clientWidth + 1)
      .slice(0, 12)
      .map((node) => ({
        tag: node.tagName,
        className: typeof node.className === "string" ? node.className : "",
        right: Math.round(node.getBoundingClientRect().right),
        width: Math.round(node.getBoundingClientRect().width),
      })),
  };
 })()`);
 await pause(180);
 await screenshot("/tmp/llm-atlas-agents-mobile.png");
 const report = { overview, loop, contract, reliability, rl, home, papers, mobile, exceptions };
 console.log(JSON.stringify(report, null, 2));
 const numeric = (value) => Number.parseFloat(value);
 const failures = [];
 if (!overview.title.includes("可靠行动")) failures.push("章节标题异常");
 if (overview.sections !== 28 || overview.tocLinks !== 28) failures.push("章节/目录数量异常");
 if (overview.paperLinks !== 52) failures.push("正式论文链不是 52 个节点");
 if (overview.labTabs !== 4 || overview.labPanels !== 4) failures.push("四联实验结构异常");
 if (overview.navLinks !== 16 || home.navLinks !== 16 || mobile.mobileLinks !== 16) failures.push("全站导航未同步 Agent 专题");
 if (overview.documentOverflow > 1 || mobile.documentOverflow > 1) failures.push("桌面或移动端存在横向溢出");
 if (loop.initial.finalState !== "UNVERIFIED" || loop.directSchema.finalState !== "FAILED") failures.push("控制循环终局状态异常");
 if (!loop.directSchema.observation.includes("ERROR schema") || loop.directSchema.recovery !== "FRAGILE") failures.push("Direct/schema 故障传播异常");
 if (contract.syntax !== "100%" || contract.execution !== "100%" || contract.finalState !== "0%") failures.push("工具契约三层评分异常");
 if (!contract.takeaway.includes("final-state") || contract.visiblePanel !== "contract") failures.push("工具契约终局验证解释异常");
 if (numeric(reliability.initial.passAt) < 99.9 || Math.abs(numeric(reliability.initial.passHat) - 16.78) > 0.02) failures.push("pass@k / pass^k 初始计算异常");
 if (numeric(reliability.initial.passAt) <= numeric(reliability.k2.passAt) || numeric(reliability.initial.passHat) >= numeric(reliability.k2.passHat)) failures.push("k 增长时两类可靠性没有反向变化");
 if (reliability.nonIdempotent.sideRisk === "LOW") failures.push("非幂等写操作风险没有提升");
 if (numeric(rl.wait.utilization) >= numeric(rl.full.utilization) || numeric(rl.wait.lostWork) <= numeric(rl.full.lostWork)) failures.push("wait-all 长尾/重算方向异常");
 if (!rl.wait.takeaway.includes("wait-all") || rl.keyboardSelected !== "rl" || rl.keyboardVisible !== "rl") failures.push("长程 RL 解释或键盘导航异常");
 if (home.releaseCards !== 11 || !home.firstRelease.includes("Agent 不是一个循环") || home.firstHref !== "/agents/") failures.push("首页 Agent 首发入口异常");
 if (home.paperCount !== "314" || papers.total !== 314 || !papers.hasAgentFilter || papers.agentVisible < 52) failures.push("论文库 Agent 标签或论文总数异常");
 if (!mobile.menuVisible || mobile.menuOpen !== "true" || mobile.tabs !== 4) failures.push("移动端导航或实验异常");
 if (exceptions.length) failures.push(`浏览器异常：${exceptions.join(" | ")}`);
 if (failures.length) {
  console.error(`\nFAIL\n- ${failures.join("\n- ")}`);
  process.exitCode = 1;
 } else {
  console.log("\nPASS agents browser regression");
 }
 socket.close();
@@ -216,7 +216,7 @@ if (!overview.title.includes("真正与人协作")) failures.push("章节标题
 if (overview.sections !== 22 || overview.tocLinks !== 22) failures.push("章节/目录数量异常");
 if (overview.paperLinks !== 44) failures.push("正式论文链不是 44 个节点");
 if (overview.labTabs !== 4 || overview.labPanels !== 4) failures.push("四联实验结构异常");
-if (overview.navLinks !== 15 || home.navLinks !== 15 || mobile.mobileLinks !== 15) failures.push("全站导航未同步后训练专题");
+if (overview.navLinks !== 16 || home.navLinks !== 16 || mobile.mobileLinks !== 16) failures.push("全站导航未同步后训练专题");
 if (overview.documentOverflow > 1 || mobile.documentOverflow > 1) failures.push("桌面或移动端存在横向溢出");
 if (sft.initial.active !== "6 / 10" || !sft.initial.lossStates.slice(0, 4).every((value) => value === "MASKED")) failures.push("SFT response-only mask 异常");
 if (sft.unsafeAll.active !== "10 / 10" || numeric(sft.unsafeAll.nll) <= numeric(sft.initial.nll) || !sft.unsafeAll.reading.includes("错误")) failures.push("SFT 全序列/坏示范交互异常");
@@ -226,8 +226,8 @@ if (!update.steps[0].includes("Fixed preference")) failures.push("DPO 更新流
 if (!recipe.family.includes("Multi-effort") || !recipe.regime.includes("9 RL experts") || !recipe.constraints.includes("verbosity")) failures.push("K3 配方合同异常");
 if (!recipe.path.some((step) => step.includes("3 domains × 3 efforts")) || !recipe.path.some((step) => step.includes("MOPD"))) failures.push("K3 配方路径异常");
 if (recipe.keyboardSelected !== "recipe" || recipe.keyboardVisible !== "recipe") failures.push("实验 tab 键盘导航异常");
-if (home.releaseCards !== 10 || !home.firstRelease.includes("DPO 没有") || home.firstHref !== "/post-training/alignment/") failures.push("首页 Alignment 首发入口异常");
+if (home.releaseCards !== 11 || !home.firstRelease.includes("Agent 不是一个循环") || home.firstHref !== "/agents/") failures.push("首页 Alignment 首发入口异常");
-if (home.paperCount !== "280" || papers.total !== 280 || !papers.hasAlignmentFilter || papers.alignmentVisible < 35) failures.push("论文库后训练标签或论文总数异常");
+if (home.paperCount !== "314" || papers.total !== 314 || !papers.hasAlignmentFilter || papers.alignmentVisible < 35) failures.push("论文库后训练标签或论文总数异常");
 if (!mobile.menuVisible || mobile.menuOpen !== "true" || mobile.tabs !== 4) failures.push("移动端导航或实验异常");
 if (exceptions.length) failures.push(`浏览器异常：${exceptions.join(" | ")}`);
@@ -230,15 +230,15 @@ if (transform.keyboard.selected !== "transform" || transform.keyboard.visible !=
 if (layout.articleSections !== 18 || layout.paperLinks !== 31 || layout.labTabs !== 4 || layout.views !== 4) {
  failures.push("章节、论文或实验数量异常");
 }
-if (layout.navLinks !== 15 || mobile.mobileLinks !== 15 || home.navLinks !== 15) failures.push("全站导航未同步数值专题");
+if (layout.navLinks !== 16 || mobile.mobileLinks !== 16 || home.navLinks !== 16) failures.push("全站导航未同步数值专题");
 if (layout.documentOverflow > 0 || mobile.documentOverflow > 0 || home.documentOverflow > 0) failures.push("页面存在横向溢出");
 if (layout.navGap < 0) failures.push(`桌面导航碰撞：${layout.navGap}px`);
 if (!mobile.menuVisible || mobile.menuOpen !== "true") failures.push("移动端菜单不可用");
-if (home.releaseCards !== 10 || !home.firstRelease.includes("DPO 没有") || home.firstHref !== "/post-training/alignment/") {
+if (home.releaseCards !== 11 || !home.firstRelease.includes("Agent 不是一个循环") || home.firstHref !== "/agents/") {
  failures.push("首页 Transformer 新章入口异常");
 }
-if (home.paperCount !== "280") failures.push(`首页论文总数异常：${home.paperCount}`);
+if (home.paperCount !== "314") failures.push(`首页论文总数异常：${home.paperCount}`);
-if (!papers.hasDataFilter || papers.total !== 280 || papers.visible < 25) failures.push("论文库数据标签或论文总数异常");
+if (!papers.hasDataFilter || papers.total !== 314 || papers.visible < 25) failures.push("论文库数据标签或论文总数异常");
 if (exceptions.length) failures.push(`浏览器脚本异常：${exceptions.join("; ")}`);
 socket.close();
@@ -177,7 +177,7 @@ if (layout.documentOverflow > 0 || mobile.documentOverflow > 0 || home.documentO
 }
 if (layout.navGap < 0) failures.push(`桌面导航碰撞：${layout.navGap}px`);
 if (!mobile.menuVisible) failures.push("移动端菜单按钮未显示");
-if (home.releaseCards !== 10) failures.push(`首页新章卡数量异常：${home.releaseCards}`);
+if (home.releaseCards !== 11) failures.push(`首页新章卡数量异常：${home.releaseCards}`);
 if (exceptions.length) failures.push(`浏览器脚本异常：${exceptions.join("; ")}`);
 socket.close();
@@ -273,15 +273,15 @@ if (stability.keyboard.selected !== "stability" || stability.keyboard.visible !=
 if (layout.articleSections !== 19 || layout.paperLinks !== 36 || layout.labTabs !== 4 || layout.views !== 4) {
  failures.push("章节、论文或实验数量异常");
 }
-if (layout.navLinks !== 15 || mobile.mobileLinks !== 15 || home.navLinks !== 15) failures.push("全站导航未同步数值专题");
+if (layout.navLinks !== 16 || mobile.mobileLinks !== 16 || home.navLinks !== 16) failures.push("全站导航未同步数值专题");
 if (layout.documentOverflow > 0 || mobile.documentOverflow > 0 || home.documentOverflow > 0) failures.push("页面存在横向溢出");
 if (layout.navGap < 0) failures.push(`桌面导航碰撞：${layout.navGap}px`);
 if (!mobile.menuVisible || mobile.menuOpen !== "true") failures.push("移动端菜单不可用");
-if (home.releaseCards !== 10 || !home.firstRelease.includes("DPO 没有") || home.firstHref !== "/post-training/alignment/") {
+if (home.releaseCards !== 11 || !home.firstRelease.includes("Agent 不是一个循环") || home.firstHref !== "/agents/") {
  failures.push("首页 Transformer 新章入口异常");
 }
-if (home.paperCount !== "280") failures.push(`首页论文总数异常：${home.paperCount}`);
+if (home.paperCount !== "314") failures.push(`首页论文总数异常：${home.paperCount}`);
-if (!papers.hasOptimizerFilter || papers.total !== 280 || papers.visible < 8) failures.push("论文库优化器标签或论文总数异常");
+if (!papers.hasOptimizerFilter || papers.total !== 314 || papers.visible < 8) failures.push("论文库优化器标签或论文总数异常");
 if (exceptions.length) failures.push(`浏览器脚本异常：${exceptions.join("; ")}`);
 socket.close();
@@ -289,7 +289,7 @@ if (layout.documentOverflow > 0 || mobile.documentOverflow > 0 || home.documentO
 }
 if (layout.navGap < 0) failures.push(`桌面导航碰撞：${layout.navGap}px`);
 if (!mobile.menuVisible || mobile.menuOpen !== "true") failures.push("移动端菜单不可用");
-if (home.releaseCards !== 10 || !home.firstRelease.includes("DPO 没有")) failures.push("首页 Transformer 新章入口异常");
+if (home.releaseCards !== 11 || !home.firstRelease.includes("Agent 不是一个循环")) failures.push("首页 Transformer 新章入口异常");
 if (exceptions.length) failures.push(`浏览器脚本异常：${exceptions.join("; ")}`);
 socket.close();
@@ -269,14 +269,14 @@ if (emergence.paths.some((length) => length < 500)) failures.push("涌现多指
 if (layout.articleSections !== 16 || layout.paperLinks !== 29 || layout.labTabs !== 4 || layout.views !== 4) {
  failures.push("章节、论文或实验数量异常");
 }
-if (layout.navLinks !== 15 || mobile.mobileLinks !== 15 || home.navLinks !== 15) failures.push("全站导航未同步数值专题");
+if (layout.navLinks !== 16 || mobile.mobileLinks !== 16 || home.navLinks !== 16) failures.push("全站导航未同步数值专题");
 if (layout.documentOverflow > 0 || mobile.documentOverflow > 0 || home.documentOverflow > 0) failures.push("页面存在横向溢出");
 if (layout.navGap < 0) failures.push(`桌面导航碰撞：${layout.navGap}px`);
 if (!mobile.menuVisible || mobile.menuOpen !== "true") failures.push("移动端菜单不可用");
-if (home.releaseCards !== 10 || !home.firstRelease.includes("DPO 没有") || home.firstHref !== "/post-training/alignment/") {
+if (home.releaseCards !== 11 || !home.firstRelease.includes("Agent 不是一个循环") || home.firstHref !== "/agents/") {
  failures.push("首页 Transformer 新章入口异常");
 }
-if (home.paperCount !== "280") failures.push(`首页论文总数异常：${home.paperCount}`);
+if (home.paperCount !== "314") failures.push(`首页论文总数异常：${home.paperCount}`);
 if (exceptions.length) failures.push(`浏览器脚本异常：${exceptions.join("; ")}`);
 socket.close();
@@ -233,7 +233,7 @@ if (layout.articleSections !== 16 || layout.paperLinks !== 37 || layout.labTabs
 if (layout.documentOverflow > 0 || mobile.documentOverflow > 0 || home.documentOverflow > 0) failures.push("页面存在横向溢出");
 if (layout.navGap < 0) failures.push(`桌面导航碰撞：${layout.navGap}px`);
 if (!mobile.menuVisible || mobile.menuOpen !== "true") failures.push("移动端菜单不可用");
-if (home.releaseCards !== 10 || !home.firstRelease.includes("DPO 没有")) failures.push("首页 Transformer 新章入口异常");
+if (home.releaseCards !== 11 || !home.firstRelease.includes("Agent 不是一个循环")) failures.push("首页 Transformer 新章入口异常");
 if (exceptions.length) failures.push(`浏览器脚本异常：${exceptions.join("; ")}`);
 socket.close();
@@ -172,7 +172,7 @@ const home = await evaluate(`(() => ({
  releaseCards: document.querySelectorAll(".release-card").length,
  firstRelease: document.querySelector(".release-card h2").textContent,
  firstHref: document.querySelector(".release-card").getAttribute("href"),
-  paperCount: [...document.querySelectorAll(".hero-stats b")].map((node) => node.textContent.trim()).find((value) => value === "280"),
+  paperCount: [...document.querySelectorAll(".hero-stats b")].map((node) => node.textContent.trim()).find((value) => value === "314"),
 }))()`);
 await navigate("/papers/");
@@ -236,8 +236,8 @@ if (block.family.trim() !== "Hybrid MoE" || !block.kv.includes("3 KDA : 1 Gated
 if (!block.path.some((step) => step.includes("KDA × 3")) || !block.note.includes("AttnRes")) failures.push("K3 Block 路径异常");
 if (block.context.trim() !== "128K" || numeric(block.mha) !== 400 || numeric(block.kda) !== 1) failures.push("KV 成本缩放异常");
 if (block.keyboardSelected !== "block" || block.keyboardVisible !== "block") failures.push("实验 tab 键盘导航异常");
-if (home.releaseCards !== 10 || !home.firstRelease.includes("DPO 没有") || home.firstHref !== "/post-training/alignment/") failures.push("首页 Transformer 首发入口异常");
+if (home.releaseCards !== 11 || !home.firstRelease.includes("Agent 不是一个循环") || home.firstHref !== "/agents/") failures.push("首页 Transformer 首发入口异常");
-if (home.paperCount !== "280" || papers.total !== 280 || papers.transformerVisible < 30) failures.push("论文库或首页论文数量异常");
+if (home.paperCount !== "314" || papers.total !== 314 || papers.transformerVisible < 30) failures.push("论文库或首页论文数量异常");
 if (!mobile.menuVisible || mobile.menuOpen !== "true" || mobile.tabs !== 4) failures.push("移动端导航或实验异常");
 if (exceptions.length) failures.push(`浏览器异常：${exceptions.join(" | ")}`);
@@ -0,0 +1,955 @@
 ---
 const loopSteps = Array.from({ length: 7 }, (_, index) => index);
 const contractCases = [
  {
    id: "correct",
    label: "正确串行调用",
    call: 'search_orders(user_id="u-17") → refund_order(order_id="o-42")',
    note: "先读后写，第二个调用使用第一个调用返回的 order_id。",
    syntax: 100,
    execution: 100,
    final: 100,
  },
  {
    id: "malformed",
    label: "参数类型错误",
    call: 'refund_order(order_id=42, reason=true)',
    note: "工具选对了，但 order_id 与 reason 的类型都违反 schema。",
    syntax: 18,
    execution: 0,
    final: 0,
  },
  {
    id: "parallel",
    label: "伪并行依赖",
    call: 'parallel(search_orders("u-17"), refund_order(order_id="$result.id"))',
    note: "第二步依赖第一步的结果，不能在同一并行批次中可靠执行。",
    syntax: 76,
    execution: 24,
    final: 0,
  },
  {
    id: "abstain",
    label: "应追问却调用",
    call: 'book_flight(origin="PVG", destination="SFO", date=null)',
    note: "JSON 可以解析，但缺少关键日期；正确动作是先向用户澄清。",
    syntax: 62,
    execution: 0,
    final: 0,
  },
  {
    id: "wrongstate",
    label: "调用成功，结果错误",
    call: 'cancel_order(order_id="o-42") → {"status":"cancelled"}',
    note: "工具执行成功，但用户要求的是退货而不是取消；业务最终状态错误。",
    syntax: 100,
    execution: 100,
    final: 0,
  },
 ];
 ---
 <figure
  class="agent-lab"
  data-agent-lab
  data-contract-cases={JSON.stringify(contractCases)}
 >
  <div class="lab-heading">
    <div>
      <p>INTERACTIVE / AGENT SYSTEMS LAB</p>
      <h3>把 Agent 从“会说”拆成四套可以操作的系统账</h3>
    </div>
    <p>
      所有数值均为确定性教学模拟，不是任何真实模型跑分。实验专门分开控制循环、工具契约、
      可靠性与百万 Token RL 系统，避免把它们压成一个模糊的“Agent 能力”。
    </p>
  </div>
  <div class="lab-tabs" role="tablist" aria-label="选择 Agent 实验">
    <button type="button" role="tab" data-agent-tab="loop" aria-selected="true">
      <span>01</span><b>控制循环显微镜</b><small>state / action / observation</small>
    </button>
    <button type="button" role="tab" data-agent-tab="contract" aria-selected="false" tabindex="-1">
      <span>02</span><b>工具契约实验</b><small>schema / execution / final state</small>
    </button>
    <button type="button" role="tab" data-agent-tab="reliability" aria-selected="false" tabindex="-1">
      <span>03</span><b>可靠性实验</b><small>pass@k / pass^k / side effects</small>
    </button>
    <button type="button" role="tab" data-agent-tab="rl" aria-selected="false" tabindex="-1">
      <span>04</span><b>长程 RL 控制室</b><small>partial rollout / KV / sandbox</small>
    </button>
  </div>
  <section class="lab-panel" data-agent-panel="loop">
    <div class="panel-intro">
      <div><span>CONTROL LOOP</span><h4>一次工具错误怎样沿长轨迹传播？</h4></div>
      <p>选择 harness 与故障，再逐步推进。观察“想得更长”是否真的修复了坏接口或旧观察。</p>
    </div>
    <div class="button-row" role="group" aria-label="选择 Agent 控制模式">
      <button type="button" data-loop-mode="direct">Direct</button>
      <button type="button" data-loop-mode="plan">Plan → Execute</button>
      <button type="button" data-loop-mode="react" class="active">ReAct</button>
    </div>
    <div class="button-row fault-row" role="group" aria-label="注入环境故障">
      <button type="button" data-loop-fault="none" class="active">无故障</button>
      <button type="button" data-loop-fault="schema">Schema mismatch</button>
      <button type="button" data-loop-fault="tool">Tool timeout</button>
      <button type="button" data-loop-fault="stale">Stale observation</button>
    </div>
    <div class="loop-workbench">
      <div class="loop-state">
        <div class="state-header">
          <span>LIVE TRAJECTORY</span>
          <b data-loop-status>RUNNING · STEP 1 / 7</b>
        </div>
        <div class="loop-timeline" aria-label="Agent 轨迹步骤">
          {loopSteps.map((index) => (
            <i data-loop-step={index}><span>{String(index + 1).padStart(2, "0")}</span><b></b></i>
          ))}
        </div>
        <dl class="loop-readout">
          <div><dt>STATE</dt><dd data-loop-state>订单仍为 delivered，退款未创建</dd></div>
          <div><dt>THOUGHT / PLAN</dt><dd data-loop-thought>先确认订单与退货政策，再执行退款并检查最终状态。</dd></div>
          <div><dt>ACTION</dt><dd data-loop-action>search_orders(user_id="u-17")</dd></div>
          <div><dt>OBSERVATION</dt><dd data-loop-observation>等待工具返回……</dd></div>
        </dl>
        <div class="loop-controls">
          <button type="button" data-loop-reset>重新开始</button>
          <button type="button" data-loop-next>推进一步 →</button>
        </div>
      </div>
      <div class="loop-metrics">
        <article><span>TOOL CALLS</span><b data-loop-calls>1</b><p>已发出的环境动作</p></article>
        <article><span>CONTEXT</span><b data-loop-tokens>1.8K</b><p>累计可见 Token</p></article>
        <article><span>RECOVERY</span><b data-loop-recovery>READY</b><p>是否有可用恢复路径</p></article>
        <article><span>FINAL STATE</span><b data-loop-final>UNVERIFIED</b><p>独立 verifier 的判断</p></article>
      </div>
    </div>
    <div class="lab-takeaway">
      <b data-loop-takeaway>当前结论：ReAct 给错误恢复留下了新回合，但环境必须返回可诊断错误。</b>
      <p>Thought 不改变世界；只有成功执行的 action 才会触发状态转移。</p>
    </div>
  </section>
  <section class="lab-panel" data-agent-panel="contract" hidden>
    <div class="panel-intro">
      <div><span>TOOL CONTRACT</span><h4>格式正确、执行成功、任务完成是三道不同的门</h4></div>
      <p>BFCL 类接口评测与 WebArena、τ-bench 类环境评测并不冲突，它们只是测不同层。</p>
    </div>
    <div class="button-row contract-cases" role="group" aria-label="选择工具调用案例">
      {contractCases.map((item, index) => (
        <button
          type="button"
          data-contract-case={item.id}
          class={index === 0 ? "active" : ""}
        >
          {item.label}
        </button>
      ))}
    </div>
    <div class="contract-layout">
      <div class="tool-catalog">
        <div><span>READ</span><b>search_orders</b><small>user_id: string → Order[]</small></div>
        <div><span>WRITE</span><b>refund_order</b><small>order_id: string · reason: string</small></div>
        <div><span>WRITE</span><b>cancel_order</b><small>order_id: string</small></div>
        <div><span>WRITE</span><b>book_flight</b><small>origin · destination · date</small></div>
      </div>
      <div class="call-console">
        <span>MODEL EMISSION</span>
        <code data-contract-call>search_orders(user_id="u-17") → refund_order(order_id="o-42")</code>
        <p data-contract-note>先读后写，第二个调用使用第一个调用返回的 order_id。</p>
      </div>
    </div>
    <div class="contract-scores">
      <article>
        <span>01 / SCHEMA</span><b data-contract-score="syntax">100%</b>
        <i><em data-contract-meter="syntax"></em></i><p>能否解析、类型是否正确</p>
      </article>
      <article>
        <span>02 / EXECUTION</span><b data-contract-score="execution">100%</b>
        <i><em data-contract-meter="execution"></em></i><p>工具是否真正成功运行</p>
      </article>
      <article>
        <span>03 / FINAL STATE</span><b data-contract-score="final">100%</b>
        <i><em data-contract-meter="final"></em></i><p>业务状态是否满足用户目标</p>
      </article>
    </div>
    <div class="lab-takeaway">
      <b data-contract-takeaway>三个层级都通过，这次调用才构成任务成功。</b>
      <p>若只测 AST 或 JSON，最后一种“调用成功但取消错订单”的失败会完全漏掉。</p>
    </div>
  </section>
  <section class="lab-panel" data-agent-panel="reliability" hidden>
    <div class="panel-intro">
      <div><span>RELIABILITY</span><h4>“多试几次总会成功”与“每次都可靠”可以同时为真</h4></div>
      <p>拖动同一个单次成功率，观察 pass@k 与 pass^k 朝相反方向变化。</p>
    </div>
    <div class="reliability-controls">
      <label>
        <span>单次成功率 p <output data-rel-p-label>80%</output></span>
        <input data-rel-p type="range" min="20" max="98" value="80" step="1" />
      </label>
      <label>
        <span>重复次数 k <output data-rel-k-label>8</output></span>
        <input data-rel-k type="range" min="1" max="12" value="8" step="1" />
      </label>
      <label>
        <span>每次运行成本 <output data-rel-cost-label>¥2.40</output></span>
        <input data-rel-cost type="range" min="20" max="1000" value="240" step="20" />
      </label>
      <label>
        <span>Verifier 误报率 <output data-rel-fp-label>6%</output></span>
        <input data-rel-fp type="range" min="0" max="30" value="6" step="1" />
      </label>
    </div>
    <div class="idempotency-switch" role="group" aria-label="写操作是否幂等">
      <span>写操作重复执行：</span>
      <button type="button" data-rel-idempotent="true" class="active">幂等 / 可去重</button>
      <button type="button" data-rel-idempotent="false">非幂等 / 有副作用</button>
    </div>
    <div class="reliability-visual">
      <article class="coverage-card">
        <span>DISCOVERY / PASS@K</span><b data-rel-pass-at>100.00%</b>
        <div><em data-rel-pass-at-meter></em></div>
        <p>k 次里至少一次成功；增加重试通常会上升。</p>
      </article>
      <div class="versus-axis"><i>同一个 p</i><b>≠</b><i>同一种可靠</i></div>
      <article class="consistency-card">
        <span>CONSISTENCY / PASS^K</span><b data-rel-pass-hat>16.78%</b>
        <div><em data-rel-pass-hat-meter></em></div>
        <p>k 次全部成功；生产一致性要求越高，数字越苛刻。</p>
      </article>
    </div>
    <div class="reliability-metrics">
      <article><span>MAX BUDGET</span><b data-rel-budget>¥19.20</b><p>运行 k 次的上限成本</p></article>
      <article><span>UNTIL SUCCESS</span><b data-rel-expected>¥3.00</b><p>最多 k 次、成功即停的期望成本</p></article>
      <article><span>FALSE COMPLETE</span><b data-rel-false>1.20%</b><p>失败却被 verifier 判成完成</p></article>
      <article><span>SIDE-EFFECT RISK</span><b data-rel-side>LOW</b><p>重试写操作的重复副作用</p></article>
    </div>
    <div class="lab-takeaway">
      <b data-rel-takeaway>系统几乎总能“试出一次成功”，但连续八次都成功的概率只有约 17%。</b>
      <p>τ-bench 引入 pass^k，就是为了让这种差异无法被 best-of-N 掩盖。</p>
    </div>
  </section>
  <section class="lab-panel" data-agent-panel="rl" hidden>
    <div class="panel-intro">
      <div><span>LONG-HORIZON RL</span><h4>一条百万 Token 轨迹，是模型状态与世界状态的双重流水线</h4></div>
      <p>比较 wait-all、partial rollout、外部 KV 和可恢复 sandbox。数值只演示因果方向。</p>
    </div>
    <div class="button-row rl-modes" role="group" aria-label="选择长程 RL 系统方案">
      <button type="button" data-rl-mode="wait">Wait-all</button>
      <button type="button" data-rl-mode="partial">Partial rollout</button>
      <button type="button" data-rl-mode="kv">＋ External KV</button>
      <button type="button" data-rl-mode="full" class="active">K3-like full stack</button>
    </div>
    <div class="rl-controls">
      <label>
        <span>轨迹长度 <output data-rl-horizon-label>800K</output></span>
        <input data-rl-horizon type="range" min="100" max="1000" value="800" step="50" />
      </label>
      <label>
        <span>Checkpoint 间隔 <output data-rl-checkpoint-label>100K</output></span>
        <input data-rl-checkpoint type="range" min="25" max="250" value="100" step="25" />
      </label>
      <label>
        <span>并发 trajectory <output data-rl-concurrency-label>256</output></span>
        <input data-rl-concurrency type="range" min="64" max="512" value="256" step="32" />
      </label>
      <label>
        <span>Policy drift <output data-rl-drift-label>35%</output></span>
        <input data-rl-drift type="range" min="0" max="90" value="35" step="5" />
      </label>
    </div>
    <div class="rl-pipeline" aria-label="长程 Agent RL 流水线">
      <div data-rl-stage="rollout"><span>01</span><b>MODEL ROLLOUT</b><small>tokens + KV</small></div>
      <i>⇄</i>
      <div data-rl-stage="tool"><span>02</span><b>TOOL / WORLD</b><small>files + DB + process</small></div>
      <i>⇄</i>
      <div data-rl-stage="state"><span>03</span><b>STATE STORE</b><small>KV pool + snapshot</small></div>
      <i>→</i>
      <div data-rl-stage="verify"><span>04</span><b>VERIFIER</b><small>final environment</small></div>
    </div>
    <div class="rl-metrics">
      <article><span>GPU UTILIZATION</span><b data-rl-util>84%</b><i><em data-rl-meter="util"></em></i><p>尾部等待与 KV 压力后的模拟利用率</p></article>
      <article><span>STALE SHARE</span><b data-rl-stale>18%</b><i><em data-rl-meter="stale"></em></i><p>跨迭代轨迹的 policy 陈旧比例</p></article>
      <article><span>LOST WORK</span><b data-rl-lost>4.8%</b><i><em data-rl-meter="lost"></em></i><p>故障后必须重算的轨迹比例</p></article>
      <article><span>KV PRESSURE</span><b data-rl-kv>71%</b><i><em data-rl-meter="kv"></em></i><p>长前缀与并发造成的缓存压力</p></article>
    </div>
    <div class="state-ledger">
      <div>
        <span>MODEL TIMELINE</span>
        <b>Token · KV · policy version · reward</b>
        <p data-rl-model-state>inactive prefix 写回 CPU DRAM，复用前 prefetch。</p>
      </div>
      <div>
        <span>WORLD TIMELINE</span>
        <b>Files · DB · processes · permissions</b>
        <p data-rl-world-state>microVM 可 pause / resume / fork / snapshot。</p>
      </div>
    </div>
    <div class="lab-takeaway">
      <b data-rl-takeaway>完整方案同时保存模型前缀和环境状态，才真正减少长轨迹重算。</b>
      <p>partial rollout 解决等待最慢样本，external KV 解决长前缀复用，AgentENV 解决外部世界恢复；三者不是同一个优化。</p>
    </div>
  </section>
  <figcaption>
    <b>HOW TO READ</b>
    四个实验共享同一个结论：可靠 Agent 是 model、harness、tool contract、environment 与 evaluator 的联合系统。
  </figcaption>
 </figure>
 <script>
  type ContractCase = {
    id: string;
    label: string;
    call: string;
    note: string;
    syntax: number;
    execution: number;
    final: number;
  };
  document.querySelectorAll<HTMLElement>("[data-agent-lab]").forEach((root) => {
    const tabs = [...root.querySelectorAll<HTMLButtonElement>("[data-agent-tab]")];
    const panels = [...root.querySelectorAll<HTMLElement>("[data-agent-panel]")];
    const setText = (selector: string, value: string) => {
      const node = root.querySelector<HTMLElement>(selector);
      if (node) node.textContent = value;
    };
    const setMeter = (selector: string, value: number) => {
      const node = root.querySelector<HTMLElement>(selector);
      if (node) node.style.width = `${Math.max(0, Math.min(100, value))}%`;
    };
    const activateTab = (name: string, focus = false) => {
      tabs.forEach((tab) => {
        const active = tab.dataset.agentTab === name;
        tab.setAttribute("aria-selected", String(active));
        tab.tabIndex = active ? 0 : -1;
        if (active && focus) tab.focus();
      });
      panels.forEach((panel) => {
        panel.hidden = panel.dataset.agentPanel !== name;
      });
    };
    tabs.forEach((tab, index) => {
      tab.addEventListener("click", () => activateTab(tab.dataset.agentTab ?? "loop"));
      tab.addEventListener("keydown", (event) => {
        let next = index;
        if (event.key === "ArrowRight") next = (index + 1) % tabs.length;
        else if (event.key === "ArrowLeft") next = (index - 1 + tabs.length) % tabs.length;
        else if (event.key === "Home") next = 0;
        else if (event.key === "End") next = tabs.length - 1;
        else return;
        event.preventDefault();
        activateTab(tabs[next].dataset.agentTab ?? "loop", true);
      });
    });
    type LoopFrame = { state: string; thought: string; action: string; observation: string };
    const loopFrames: LoopFrame[] = [
      {
        state: "订单仍为 delivered，退款未创建",
        thought: "先确认订单与退货政策，再执行退款并检查最终状态。",
        action: 'search_orders(user_id="u-17")',
        observation: "等待工具返回……",
      },
      {
        state: "找到订单 o-42，状态 delivered",
        thought: "读取政策，确认 delivered 订单需要 refund 而不是 cancel。",
        action: 'read_policy(topic="returns")',
        observation: "30 天内可退；写操作前需要用户确认。",
      },
      {
        state: "订单可退款，但尚未获得确认",
        thought: "缺少 consequential action 的确认，先向用户追问。",
        action: "ask_user(confirm_refund=true)",
        observation: "用户确认退款至原支付方式。",
      },
      {
        state: "已授权退款，数据库仍未改变",
        thought: "执行 refund_order，并保留 idempotency key。",
        action: 'refund_order(order_id="o-42", key="r-2026-17")',
        observation: "工具正在执行……",
      },
      {
        state: "refund record 已创建，订单进入 refund_pending",
        thought: "不要相信单次工具回执；重新读取订单与支付记录。",
        action: 'get_order_state(order_id="o-42")',
        observation: 'status="refund_pending", amount=¥328',
      },
      {
        state: "数据库与支付记录一致",
        thought: "调用独立 verifier 检查金额、对象、授权与重复副作用。",
        action: 'verify_final_state(task_id="t-17")',
        observation: "4 / 4 checks passed。",
      },
      {
        state: "目标状态满足，操作可审计",
        thought: "环境已验证完成；现在才可以终止并向用户报告。",
        action: "finish",
        observation: "SUCCESS",
      },
    ];
    let loopMode = "react";
    let loopFault = "none";
    let loopIndex = 0;
    const loopModeButtons = [...root.querySelectorAll<HTMLButtonElement>("[data-loop-mode]")];
    const loopFaultButtons = [...root.querySelectorAll<HTMLButtonElement>("[data-loop-fault]")];
    const renderLoop = () => {
      const maxSteps = loopMode === "direct" ? 3 : loopMode === "plan" ? 5 : 7;
      const logicalIndex = Math.min(loopIndex, maxSteps - 1);
      const sourceIndex = maxSteps === 3
        ? [0, 3, 6][logicalIndex]
        : maxSteps === 5
          ? [0, 1, 3, 5, 6][logicalIndex]
          : logicalIndex;
      const frame = { ...loopFrames[sourceIndex] };
      const faultAt = loopMode === "direct" ? 1 : loopMode === "plan" ? 2 : 3;
      let failed = false;
      if (loopFault !== "none" && logicalIndex >= faultAt) {
        if (loopFault === "schema") {
          frame.observation = 'ERROR schema: "order" must be string; received integer';
          frame.state = "工具拒绝调用，环境状态未改变";
          frame.thought = loopMode === "direct" ? "没有剩余回合可修正参数。" : "读取 schema，修正参数类型后安全重试。";
        } else if (loopFault === "tool") {
          frame.observation = "TIMEOUT · unknown execution status";
          frame.state = "调用结果未知；直接重试可能产生重复退款";
          frame.thought = loopMode === "direct" ? "误把 timeout 当失败并再次写入。" : "先用 idempotency key 查询，再决定是否重试。";
        } else {
          frame.observation = 'cached status="delivered" · age 7m42s';
          frame.state = "观察已经陈旧，真实状态可能已改变";
          frame.thought = loopMode === "direct" ? "依据旧观察错误终止。" : "强制刷新状态并比较 version，再运行 verifier。";
        }
        failed = loopMode === "direct" || logicalIndex === maxSteps - 1;
      }
      const complete = logicalIndex === maxSteps - 1;
      setText("[data-loop-state]", frame.state);
      setText("[data-loop-thought]", frame.thought);
      setText("[data-loop-action]", frame.action);
      setText("[data-loop-observation]", frame.observation);
      setText("[data-loop-status]", `${complete ? "TERMINAL" : "RUNNING"} · STEP ${logicalIndex + 1} / ${maxSteps}`);
      setText("[data-loop-calls]", String(Math.max(1, logicalIndex + (loopMode === "react" ? 1 : 0))));
      setText("[data-loop-tokens]", `${(1.1 + logicalIndex * (loopMode === "react" ? 1.45 : 0.72)).toFixed(1)}K`);
      setText("[data-loop-recovery]", loopMode === "direct" ? "FRAGILE" : loopMode === "plan" ? "CHECKPOINT" : "ADAPTIVE");
      setText("[data-loop-final]", complete ? (failed ? "FAILED" : loopFault === "none" || loopMode !== "direct" ? "VERIFIED" : "FAILED") : "UNVERIFIED");
      setText("[data-loop-takeaway]", loopFault === "none"
        ? `当前结论：${loopMode === "react" ? "ReAct" : loopMode === "plan" ? "Plan → Execute" : "Direct"} 用 ${maxSteps} 个状态转换完成任务；只有最后 verifier 通过才算完成。`
        : failed
          ? "当前结论：控制循环没有留下安全恢复空间，局部故障直接变成最终失败。"
          : "当前结论：更长循环只提供恢复机会；真正的恢复仍依赖结构化错误、幂等调用与新观察。");
      root.querySelectorAll<HTMLElement>("[data-loop-step]").forEach((node, index) => {
        const visible = index < maxSteps;
        node.hidden = !visible;
        node.classList.toggle("done", visible && index < logicalIndex);
        node.classList.toggle("current", visible && index === logicalIndex);
        node.classList.toggle("fault", visible && index === faultAt && loopFault !== "none");
      });
      loopModeButtons.forEach((button) => button.classList.toggle("active", button.dataset.loopMode === loopMode));
      loopFaultButtons.forEach((button) => button.classList.toggle("active", button.dataset.loopFault === loopFault));
    };
    loopModeButtons.forEach((button) => button.addEventListener("click", () => {
      loopMode = button.dataset.loopMode ?? "react";
      loopIndex = 0;
      renderLoop();
    }));
    loopFaultButtons.forEach((button) => button.addEventListener("click", () => {
      loopFault = button.dataset.loopFault ?? "none";
      loopIndex = 0;
      renderLoop();
    }));
    root.querySelector<HTMLButtonElement>("[data-loop-next]")?.addEventListener("click", () => {
      const max = loopMode === "direct" ? 2 : loopMode === "plan" ? 4 : 6;
      loopIndex = Math.min(max, loopIndex + 1);
      renderLoop();
    });
    root.querySelector<HTMLButtonElement>("[data-loop-reset]")?.addEventListener("click", () => {
      loopIndex = 0;
      renderLoop();
    });
    renderLoop();
    const contractCases = JSON.parse(root.dataset.contractCases ?? "[]") as ContractCase[];
    const contractButtons = [...root.querySelectorAll<HTMLButtonElement>("[data-contract-case]")];
    const renderContract = (id: string) => {
      const item = contractCases.find((candidate) => candidate.id === id) ?? contractCases[0];
      contractButtons.forEach((button) => button.classList.toggle("active", button.dataset.contractCase === item.id));
      setText("[data-contract-call]", item.call);
      setText("[data-contract-note]", item.note);
      (["syntax", "execution", "final"] as const).forEach((key) => {
        setText(`[data-contract-score="${key}"]`, `${item[key]}%`);
        setMeter(`[data-contract-meter="${key}"]`, item[key]);
      });
      setText("[data-contract-takeaway]", item.final === 100
        ? "三个层级都通过，这次调用才构成任务成功。"
        : item.syntax < 100
          ? "接口层已经暴露问题；无需等到环境执行后才发现。"
          : item.execution < 100
            ? "格式正确不代表依赖关系与执行时序正确。"
            : "调用本身成功，但独立 final-state verifier 拒绝了错误业务结果。");
    };
    contractButtons.forEach((button) => button.addEventListener("click", () => renderContract(button.dataset.contractCase ?? "correct")));
    renderContract("correct");
    const pInput = root.querySelector<HTMLInputElement>("[data-rel-p]");
    const kInput = root.querySelector<HTMLInputElement>("[data-rel-k]");
    const costInput = root.querySelector<HTMLInputElement>("[data-rel-cost]");
    const fpInput = root.querySelector<HTMLInputElement>("[data-rel-fp]");
    let idempotent = true;
    const renderReliability = () => {
      const p = Number(pInput?.value ?? 80) / 100;
      const k = Number(kInput?.value ?? 8);
      const cost = Number(costInput?.value ?? 240) / 100;
      const fp = Number(fpInput?.value ?? 6) / 100;
      const passAt = 1 - Math.pow(1 - p, k);
      const passHat = Math.pow(p, k);
      const expectedTrials = (1 - Math.pow(1 - p, k)) / Math.max(p, 0.0001);
      const falseComplete = (1 - p) * fp;
      const sideRisk = idempotent ? 0.02 * (k - 1) : (1 - p) * (1 - Math.pow(1 - p, Math.max(0, k - 1)));
      setText("[data-rel-p-label]", `${Math.round(p * 100)}%`);
      setText("[data-rel-k-label]", String(k));
      setText("[data-rel-cost-label]", `¥${cost.toFixed(2)}`);
      setText("[data-rel-fp-label]", `${Math.round(fp * 100)}%`);
      setText("[data-rel-pass-at]", `${(passAt * 100).toFixed(2)}%`);
      setText("[data-rel-pass-hat]", `${(passHat * 100).toFixed(2)}%`);
      setMeter("[data-rel-pass-at-meter]", passAt * 100);
      setMeter("[data-rel-pass-hat-meter]", passHat * 100);
      setText("[data-rel-budget]", `¥${(cost * k).toFixed(2)}`);
      setText("[data-rel-expected]", `¥${(cost * expectedTrials).toFixed(2)}`);
      setText("[data-rel-false]", `${(falseComplete * 100).toFixed(2)}%`);
      setText("[data-rel-side]", sideRisk < 0.08 ? "LOW" : sideRisk < 0.22 ? "MEDIUM" : "HIGH");
      setText("[data-rel-takeaway]", `系统有 ${(passAt * 100).toFixed(1)}% 的机会至少成功一次，但连续 ${k} 次都成功只有 ${(passHat * 100).toFixed(1)}%。`);
      root.querySelectorAll<HTMLButtonElement>("[data-rel-idempotent]").forEach((button) => {
        button.classList.toggle("active", String(idempotent) === button.dataset.relIdempotent);
      });
    };
    [pInput, kInput, costInput, fpInput].forEach((input) => input?.addEventListener("input", renderReliability));
    root.querySelectorAll<HTMLButtonElement>("[data-rel-idempotent]").forEach((button) => button.addEventListener("click", () => {
      idempotent = button.dataset.relIdempotent === "true";
      renderReliability();
    }));
    renderReliability();
    const horizonInput = root.querySelector<HTMLInputElement>("[data-rl-horizon]");
    const checkpointInput = root.querySelector<HTMLInputElement>("[data-rl-checkpoint]");
    const concurrencyInput = root.querySelector<HTMLInputElement>("[data-rl-concurrency]");
    const driftInput = root.querySelector<HTMLInputElement>("[data-rl-drift]");
    let rlMode = "full";
    const renderRl = () => {
      const horizon = Number(horizonInput?.value ?? 800);
      const checkpoint = Number(checkpointInput?.value ?? 100);
      const concurrency = Number(concurrencyInput?.value ?? 256);
      const drift = Number(driftInput?.value ?? 35);
      const gains: Record<string, { util: number; stale: number; lost: number; kv: number }> = {
        wait: { util: 37, stale: 3, lost: 24, kv: 72 },
        partial: { util: 62, stale: 18, lost: 20, kv: 82 },
        kv: { util: 76, stale: 17, lost: 18, kv: 54 },
        full: { util: 88, stale: 13, lost: 5, kv: 49 },
      };
      const profile = gains[rlMode];
      const horizonPenalty = (horizon - 100) / 900;
      const concurrencyPressure = (concurrency - 64) / 448;
      const checkpointRatio = checkpoint / Math.max(horizon, 1);
      const util = Math.max(10, Math.min(96, profile.util - horizonPenalty * 10 - concurrencyPressure * 4 + (rlMode === "full" ? 8 : 0)));
      const stale = Math.max(0, Math.min(90, profile.stale + drift * (rlMode === "wait" ? 0.08 : 0.42) + horizonPenalty * 6));
      const lost = Math.max(0.4, Math.min(80, profile.lost * (0.55 + checkpointRatio * 2.1) + horizonPenalty * 4));
      const kv = Math.max(10, Math.min(98, profile.kv + horizonPenalty * 20 + concurrencyPressure * 18));
      setText("[data-rl-horizon-label]", `${horizon}K`);
      setText("[data-rl-checkpoint-label]", `${checkpoint}K`);
      setText("[data-rl-concurrency-label]", String(concurrency));
      setText("[data-rl-drift-label]", `${drift}%`);
      setText("[data-rl-util]", `${Math.round(util)}%`);
      setText("[data-rl-stale]", `${Math.round(stale)}%`);
      setText("[data-rl-lost]", `${lost.toFixed(1)}%`);
      setText("[data-rl-kv]", `${Math.round(kv)}%`);
      setMeter('[data-rl-meter="util"]', util);
      setMeter('[data-rl-meter="stale"]', stale);
      setMeter('[data-rl-meter="lost"]', lost);
      setMeter('[data-rl-meter="kv"]', kv);
      root.querySelectorAll<HTMLButtonElement>("[data-rl-mode]").forEach((button) => {
        button.classList.toggle("active", button.dataset.rlMode === rlMode);
      });
      const hasPartial = rlMode !== "wait";
      const hasKv = rlMode === "kv" || rlMode === "full";
      const hasEnv = rlMode === "full";
      root.querySelector<HTMLElement>('[data-rl-stage="state"]')?.classList.toggle("active", hasKv || hasEnv);
      setText("[data-rl-model-state]", hasKv
        ? "inactive prefix 写回 CPU DRAM，复用前 prefetch。"
        : hasPartial
          ? "未完成轨迹可跨迭代，但长前缀仍竞争 GPU KV。"
          : "最长轨迹结束前，整个 batch 在同步屏障等待。");
      setText("[data-rl-world-state]", hasEnv
        ? "microVM 可 pause / resume / fork / snapshot。"
        : hasPartial
          ? "模型轨迹可以续跑，但环境故障后仍可能从头重建。"
          : "外部世界没有可恢复快照，失败意味着重做。");
      setText("[data-rl-takeaway]", rlMode === "full"
        ? "完整方案同时保存模型前缀和环境状态，才真正减少长轨迹重算。"
        : rlMode === "kv"
          ? "外部 KV 降低长前缀重算，但环境状态仍需要独立恢复机制。"
          : rlMode === "partial"
            ? "partial rollout 减少 wait-all 尾部等待，却会引入跨迭代陈旧轨迹与 KV 保留压力。"
            : "wait-all 保持样本同步，但吞吐被最慢 trajectory 决定。");
    };
    root.querySelectorAll<HTMLButtonElement>("[data-rl-mode]").forEach((button) => button.addEventListener("click", () => {
      rlMode = button.dataset.rlMode ?? "full";
      renderRl();
    }));
    [horizonInput, checkpointInput, concurrencyInput, driftInput].forEach((input) => input?.addEventListener("input", renderRl));
    renderRl();
  });
 </script>
 <style>
  .agent-lab {
    --navy: #22364a;
    max-width: 1040px;
    margin: 46px 0;
    border: 1px solid var(--line);
    background: var(--paper-raised);
  }
  .lab-heading,
  .panel-intro {
    display: grid;
    grid-template-columns: 1fr minmax(260px, 380px);
    gap: 34px;
    align-items: end;
  }
  .lab-heading {
    padding: 30px;
    border-bottom: 1px solid var(--line);
  }
  .lab-heading > div > p,
  .panel-intro span,
  .lab-tabs span,
  .state-header span,
  .tool-catalog span,
  .call-console > span,
  .contract-scores span,
  .coverage-card > span,
  .consistency-card > span,
  .reliability-metrics span,
  .rl-pipeline span,
  .rl-metrics span,
  .state-ledger span {
    color: var(--copper);
    font: .57rem/1.3 var(--mono);
    letter-spacing: .1em;
  }
  .lab-heading h3 { margin-top: 10px; font-size: 1.56rem; }
  .lab-heading > p,
  .panel-intro > p { color: var(--muted); font-size: .7rem; }
  .lab-tabs {
    display: grid;
    grid-template-columns: repeat(4, minmax(0, 1fr));
    border-bottom: 1px solid var(--line);
  }
  .lab-tabs button {
    display: grid;
    gap: 7px;
    min-height: 94px;
    padding: 15px 17px;
    border: 0;
    border-right: 1px solid var(--line);
    background: transparent;
    color: var(--muted);
    text-align: left;
    cursor: pointer;
  }
  .lab-tabs button:last-child { border-right: 0; }
  .lab-tabs button[aria-selected="true"] { background: var(--navy); color: white; }
  .lab-tabs b { font: 650 .82rem/1.2 var(--display); }
  .lab-tabs small { font: .51rem/1.25 var(--mono); }
  .lab-panel { padding: 30px; }
  .panel-intro { margin-bottom: 26px; }
  .panel-intro h4 { margin-top: 8px; font-size: 1.27rem; }
  .button-row,
  .idempotency-switch {
    display: flex;
    flex-wrap: wrap;
    gap: 8px;
  }
  .button-row button,
  .idempotency-switch button,
  .loop-controls button {
    padding: 9px 12px;
    border: 1px solid var(--line);
    background: var(--paper);
    color: var(--muted);
    font: .57rem var(--mono);
    cursor: pointer;
  }
  .button-row button.active,
  .idempotency-switch button.active {
    border-color: var(--navy);
    background: var(--navy);
    color: white;
  }
  .fault-row { margin-top: 8px; }
  .fault-row button.active:not(:first-child) { border-color: #9e553d; background: #9e553d; }
  .loop-workbench {
    display: grid;
    grid-template-columns: minmax(0, 1fr) 250px;
    gap: 1px;
    margin-top: 22px;
    border: 1px solid var(--line);
    background: var(--line);
  }
  .loop-state,
  .loop-metrics { background: var(--paper); }
  .loop-state { padding: 20px; }
  .state-header { display: flex; justify-content: space-between; gap: 20px; }
  .state-header b { color: var(--navy); font: .59rem var(--mono); }
  .loop-timeline {
    display: flex;
    gap: 5px;
    margin: 18px 0;
  }
  .loop-timeline i {
    position: relative;
    display: grid;
    flex: 1;
    gap: 6px;
    color: var(--muted);
    font: normal .48rem var(--mono);
  }
  .loop-timeline i b { display: block; height: 5px; background: #d7d3cc; }
  .loop-timeline i.done b { background: var(--sage); }
  .loop-timeline i.current b { background: var(--copper); }
  .loop-timeline i.fault b { background: #9e553d; box-shadow: 0 0 0 3px rgba(158, 85, 61, .12); }
  .loop-readout { display: grid; gap: 1px; border: 1px solid var(--line); background: var(--line); }
  .loop-readout div {
    display: grid;
    grid-template-columns: 112px 1fr;
    gap: 15px;
    padding: 12px 14px;
    background: var(--paper-raised);
  }
  .loop-readout dt { color: var(--copper); font: .52rem var(--mono); }
  .loop-readout dd { font-size: .65rem; line-height: 1.5; }
  .loop-controls { display: flex; justify-content: flex-end; gap: 8px; margin-top: 16px; }
  .loop-controls button:last-child { border-color: var(--navy); background: var(--navy); color: white; }
  .loop-metrics { display: grid; gap: 1px; background: var(--line); }
  .loop-metrics article { padding: 17px; background: var(--paper); }
  .loop-metrics span { color: var(--muted); font: .49rem var(--mono); }
  .loop-metrics b { display: block; margin: 8px 0 4px; color: var(--navy); font: 650 1.05rem var(--serif); }
  .loop-metrics p { color: var(--muted); font-size: .56rem; line-height: 1.45; }
  .lab-takeaway {
    margin-top: 20px;
    padding: 17px 20px;
    border-left: 3px solid var(--copper);
    background: #f0e8dc;
  }
  .lab-takeaway b { color: var(--navy); font-size: .74rem; }
  .lab-takeaway p { margin-top: 7px; color: var(--muted); font-size: .64rem; }
  .contract-cases { margin-bottom: 20px; }
  .contract-layout {
    display: grid;
    grid-template-columns: 290px 1fr;
    gap: 1px;
    border: 1px solid var(--line);
    background: var(--line);
  }
  .tool-catalog { display: grid; gap: 1px; background: var(--line); }
  .tool-catalog div { padding: 12px 14px; background: var(--paper); }
  .tool-catalog b { display: block; margin: 5px 0; font: 650 .67rem var(--mono); }
  .tool-catalog small { color: var(--muted); font: .49rem var(--mono); }
  .call-console { display: grid; align-content: center; padding: 28px; background: #24364b; color: white; }
  .call-console code { display: block; margin: 13px 0; color: #f2eee6; font-size: .76rem; overflow-wrap: anywhere; }
  .call-console p { color: #bec9d5; font-size: .65rem; }
  .contract-scores,
  .reliability-metrics,
  .rl-metrics {
    display: grid;
    grid-template-columns: repeat(3, 1fr);
    gap: 1px;
    margin-top: 20px;
    border: 1px solid var(--line);
    background: var(--line);
  }
  .contract-scores article,
  .reliability-metrics article,
  .rl-metrics article { padding: 18px; background: var(--paper); }
  .contract-scores b,
  .reliability-metrics b,
  .rl-metrics b { display: block; margin: 9px 0; color: var(--navy); font: 650 1.2rem var(--serif); }
  .contract-scores i,
  .rl-metrics i { display: block; height: 5px; background: #d8d4cd; }
  .contract-scores em,
  .rl-metrics em { display: block; height: 100%; background: var(--copper); transition: width .18s ease; }
  .contract-scores p,
  .reliability-metrics p,
  .rl-metrics p { margin-top: 8px; color: var(--muted); font-size: .57rem; }
  .reliability-controls,
  .rl-controls {
    display: grid;
    grid-template-columns: repeat(4, 1fr);
    gap: 14px;
    padding: 18px;
    border: 1px solid var(--line);
    background: #f6f2ea;
  }
  .reliability-controls label,
  .rl-controls label { display: grid; gap: 9px; color: var(--muted); font: .57rem var(--mono); }
  input[type="range"] { width: 100%; accent-color: var(--copper); }
  output { color: var(--navy); font-weight: 700; }
  .idempotency-switch { align-items: center; margin-top: 14px; }
  .idempotency-switch > span { margin-right: 5px; color: var(--muted); font-size: .62rem; }
  .reliability-visual {
    display: grid;
    grid-template-columns: 1fr 120px 1fr;
    gap: 1px;
    margin-top: 20px;
    border: 1px solid var(--line);
    background: var(--line);
  }
  .coverage-card,
  .consistency-card { padding: 24px; background: var(--paper); }
  .coverage-card b,
  .consistency-card b { display: block; margin: 14px 0; color: var(--navy); font: 650 1.8rem var(--serif); }
  .coverage-card > div,
  .consistency-card > div { height: 8px; background: #d8d4cd; }
  .coverage-card em,
  .consistency-card em { display: block; height: 100%; background: var(--sage); transition: width .18s ease; }
  .consistency-card em { background: var(--copper); }
  .coverage-card p,
  .consistency-card p { margin-top: 12px; color: var(--muted); font-size: .62rem; }
  .versus-axis {
    display: grid;
    place-content: center;
    gap: 8px;
    background: var(--navy);
    color: white;
    text-align: center;
  }
  .versus-axis b { color: var(--copper); font: 650 1.5rem var(--serif); }
  .versus-axis i { font: normal .5rem var(--mono); }
  .reliability-metrics { grid-template-columns: repeat(4, 1fr); }
  .rl-modes { margin-bottom: 18px; }
  .rl-pipeline {
    display: flex;
    align-items: stretch;
    gap: 8px;
    margin-top: 20px;
  }
  .rl-pipeline div {
    display: grid;
    flex: 1;
    align-content: center;
    gap: 7px;
    min-height: 118px;
    padding: 14px;
    border: 1px solid var(--line);
    background: var(--paper);
  }
  .rl-pipeline div.active { box-shadow: inset 0 -4px var(--sage); }
  .rl-pipeline b { font-size: .63rem; }
  .rl-pipeline small { color: var(--muted); font: .49rem var(--mono); }
  .rl-pipeline > i { align-self: center; color: var(--copper); font-style: normal; }
  .rl-metrics { grid-template-columns: repeat(4, 1fr); }
  .state-ledger {
    display: grid;
    grid-template-columns: 1fr 1fr;
    gap: 1px;
    margin-top: 20px;
    border: 1px solid var(--line);
    background: var(--line);
  }
  .state-ledger div { padding: 18px; background: #24364b; color: white; }
  .state-ledger b { display: block; margin: 9px 0; font-size: .7rem; }
  .state-ledger p { color: #bec9d5; font-size: .61rem; }
  figcaption {
    padding: 17px 30px;
    border-top: 1px solid var(--line);
    color: var(--muted);
    font-size: .62rem;
  }
  figcaption b { margin-right: 9px; color: var(--copper); font-family: var(--mono); }
  @media (max-width: 860px) {
    .lab-heading,
    .panel-intro,
    .loop-workbench,
    .contract-layout { grid-template-columns: 1fr; }
    .lab-tabs { grid-template-columns: 1fr 1fr; }
    .lab-tabs button:nth-child(2) { border-right: 0; }
    .loop-metrics { grid-template-columns: 1fr 1fr; }
    .reliability-controls,
    .rl-controls { grid-template-columns: 1fr 1fr; }
    .reliability-visual { grid-template-columns: 1fr; }
    .versus-axis { min-height: 96px; }
    .rl-pipeline { display: grid; grid-template-columns: 1fr 1fr; }
    .rl-pipeline > i { display: none; }
  }
  @media (max-width: 540px) {
    .lab-heading,
    .lab-panel { padding: 20px; }
    .lab-tabs,
    .loop-metrics,
    .contract-scores,
    .reliability-controls,
    .rl-controls,
    .reliability-metrics,
    .rl-metrics,
    .state-ledger,
    .rl-pipeline { grid-template-columns: 1fr; }
    .lab-tabs button { border-right: 0; border-bottom: 1px solid var(--line); }
    .loop-readout div { grid-template-columns: 1fr; gap: 6px; }
    .state-header { display: grid; }
  }
  @media (prefers-reduced-motion: reduce) {
    .contract-scores em,
    .rl-metrics em,
    .coverage-card em,
    .consistency-card em { transition: none; }
  }
 </style>
@@ -16,6 +16,7 @@ const items = [
  { id: "long-context", href: "/long-context/", label: "长上下文" },
  { id: "alignment", href: "/post-training/alignment/", label: "后训练" },
  { id: "reasoning", href: "/reasoning/", label: "推理" },
  { id: "agents", href: "/agents/", label: "Agent" },
  { id: "training-systems", href: "/training-systems/", label: "训练系统" },
  { id: "numerics", href: "/systems/numerics/", label: "数值" },
  { id: "papers", href: "/papers/", label: "论文库" },
@@ -177,12 +177,12 @@ export const chapters: Chapter[] = [
    title: "工具使用与长程 Agent",
    kicker: "AGENTS",
    question: "生成一段文字，怎样变成持续数小时的可靠行动？",
-    summary: "讨论工具协议、行动—观察循环、环境奖励、沙箱、可验证任务与百万 Token 轨迹。",
+    summary: "用十四张账拆开模型、harness、工具、环境、验证、可靠性与安全，沿 ReAct、Agent RL、DeepSeek 与 K3 走到百万 Token 轨迹。",
-    status: "queued",
+    status: "published",
-    progress: 14,
+    progress: 74,
-    papers: 22,
+    papers: 52,
    prerequisites: ["10", "11"],
-    highlights: ["ReAct", "沙箱", "长轨迹 RL"],
+    highlights: ["十四张 Agent 账", "四联实验", "DeepSeek / K3"],
  },
  {
    number: "13",
@@ -2144,6 +2144,278 @@ export const papers: Paper[] = [
    spotlight: "Kimi",
    verified: true,
  },
  {
    year: 2018,
    title: "TextWorld: A Learning Environment for Text-based Games",
    url: "https://arxiv.org/abs/1806.11532",
    topics: ["Agent"],
    contribution: "用可程序生成的文字世界、状态与动作接口，为语言 Agent 建立可控交互环境。",
    verified: true,
  },
  {
    year: 2019,
    title: "Jericho: A Learning Environment for Interactive Fiction Games",
    url: "https://arxiv.org/abs/1909.05398",
    topics: ["Agent"],
    contribution: "把真实交互式小说标准化为含世界状态与语言动作的强化学习环境。",
    verified: true,
  },
  {
    year: 2020,
    title: "ALFWorld: Aligning Text and Embodied Environments for Interactive Learning",
    url: "https://arxiv.org/abs/2010.03768",
    topics: ["Agent"],
    contribution: "对齐抽象文本环境与具身家务环境，让文字策略能迁移到更真实的交互世界。",
    verified: true,
  },
  {
    year: 2022,
    title: "ScienceWorld: Is your Agent Smarter than a 5th Grader?",
    url: "https://arxiv.org/abs/2203.07540",
    topics: ["Agent", "评测"],
    contribution: "用需要多步实验和科学知识的文本环境评估语言 Agent 的交互推理。",
    verified: true,
  },
  {
    year: 2022,
    title: "WebShop: Towards Scalable Real-World Web Interaction with Grounded Language Agents",
    url: "https://arxiv.org/abs/2207.01206",
    topics: ["Agent", "评测"],
    contribution: "以 1.18M 商品、12K 指令和可计算 reward 构造大规模网页购物环境。",
    verified: true,
  },
  {
    year: 2022,
    title: "Do As I Can, Not As I Say: Grounding Language in Robotic Affordances",
    url: "https://arxiv.org/abs/2204.01691",
    topics: ["Agent"],
    contribution: "SayCan 将 LLM 给出的任务相关性与技能 value/affordance 相乘，过滤语言合理但世界中不可行的动作。",
    verified: true,
  },
  {
    year: 2022,
    title: "MRKL Systems: A modular, neuro-symbolic architecture that combines large language models, external knowledge sources and discrete reasoning",
    url: "https://arxiv.org/abs/2205.00445",
    topics: ["Agent"],
    contribution: "让 LLM 作为路由器组合计算器、知识库与离散推理模块，建立模块化工具系统主线。",
    verified: true,
  },
  {
    year: 2022,
    title: "PAL: Program-aided Language Models",
    url: "https://arxiv.org/abs/2211.10435",
    topics: ["推理", "Agent"],
    contribution: "让语言模型生成程序作为中间表示，再由解释器承担精确执行。",
    verified: true,
  },
  {
    year: 2022,
    title: "Code as Policies: Language Model Programs for Embodied Control",
    url: "https://arxiv.org/abs/2209.07753",
    topics: ["Agent"],
    contribution: "用可组合代码表达机器人策略，把自然语言任务映射到可执行控制程序。",
    verified: true,
  },
  {
    year: 2023,
    title: "Generative Agents: Interactive Simulacra of Human Behavior",
    url: "https://arxiv.org/abs/2304.03442",
    topics: ["Agent"],
    contribution: "用记忆流、反思与计划驱动长期社会行为，建立 Agent 记忆系统的经典结构。",
    verified: true,
  },
  {
    year: 2023,
    title: "ReWOO: Decoupling Reasoning from Observations for Efficient Augmented Language Models",
    url: "https://arxiv.org/abs/2305.18323",
    topics: ["Agent", "推理"],
    contribution: "先由 Planner 写含变量依赖的计划，再由 Worker 执行工具，减少重复 observation 与模型调用。",
    verified: true,
  },
  {
    year: 2023,
    title: "ToolLLM: Facilitating Large Language Models to Master 16000+ Real-world APIs",
    url: "https://arxiv.org/abs/2307.16789",
    topics: ["Agent", "数据"],
    contribution: "从 16,464 个真实 REST APIs 合成指令与调用路径，并训练检索增强的 ToolLLaMA。",
    verified: true,
  },
  {
    year: 2023,
    title: "HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face",
    url: "https://arxiv.org/abs/2303.17580",
    topics: ["Agent", "多模态"],
    contribution: "以语言模型为控制器，规划并调度模型工具库完成跨模态任务。",
    verified: true,
  },
  {
    year: 2023,
    title: "CAMEL: Communicative Agents for Mind Exploration of Large Scale Language Model Society",
    url: "https://arxiv.org/abs/2303.17760",
    topics: ["Agent"],
    contribution: "用 inception prompting 与角色扮演协议研究多 Agent 自主通信和任务协作。",
    verified: true,
  },
  {
    year: 2023,
    title: "MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework",
    url: "https://arxiv.org/abs/2308.00352",
    topics: ["Agent"],
    contribution: "把软件工程 SOP、角色和中间文档写入多 Agent 协作流程。",
    verified: true,
  },
  {
    year: 2023,
    title: "AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation",
    url: "https://arxiv.org/abs/2308.08155",
    topics: ["Agent"],
    contribution: "用可对话 Agent 抽象组合模型、工具、人类与多种交互拓扑。",
    verified: true,
  },
  {
    year: 2023,
    title: "Language Agent Tree Search Unifies Reasoning, Acting, and Planning in Language Models",
    url: "https://arxiv.org/abs/2310.04406",
    topics: ["Agent", "推理"],
    contribution: "LATS 用树搜索、环境反馈和 value judgment 统一 reasoning、acting 与 planning。",
    verified: true,
  },
  {
    year: 2023,
    title: "MemGPT: Towards LLMs as Operating Systems",
    url: "https://arxiv.org/abs/2310.08560",
    topics: ["Agent", "长上下文"],
    contribution: "用 main、recall 与 archival memory 分层管理有效上下文，类比操作系统虚拟内存。",
    verified: true,
  },
  {
    year: 2023,
    title: "Mind2Web: Towards a Generalist Agent for the Web",
    url: "https://arxiv.org/abs/2306.06070",
    topics: ["Agent", "评测"],
    contribution: "以真实网站轨迹研究 element selection、action prediction 与跨任务/站点/领域泛化。",
    verified: true,
  },
  {
    year: 2023,
    title: "WebArena: A Realistic Web Environment for Building Autonomous Agents",
    url: "https://arxiv.org/abs/2307.13854",
    topics: ["Agent", "评测"],
    contribution: "提供可自托管、功能完整的多站点环境，并以数据库和页面状态检查任务结果。",
    verified: true,
  },
  {
    year: 2023,
    title: "GAIA: A Benchmark for General AI Assistants",
    url: "https://arxiv.org/abs/2311.12983",
    topics: ["Agent", "评测"],
    contribution: "用 466 个真实助手问题联合考察推理、检索、工具与多步执行。",
    verified: true,
  },
  {
    year: 2024,
    title: "VisualWebArena: Evaluating Multimodal Agents on Realistic Visually Grounded Web Tasks",
    url: "https://arxiv.org/abs/2401.13649",
    topics: ["Agent", "多模态", "评测"],
    contribution: "把视觉 grounding、图片与布局信息加入可执行的真实网页任务。",
    verified: true,
  },
  {
    year: 2024,
    title: "AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses for LLM Agents",
    url: "https://arxiv.org/abs/2406.13352",
    topics: ["Agent", "评测"],
    contribution: "以 97 个任务和 629 个安全测试，在动态工具环境中同时测 utility 与间接提示注入。",
    verified: true,
  },
  {
    year: 2024,
    title: "Agentless: Demystifying LLM-based Software Engineering Agents",
    url: "https://arxiv.org/abs/2407.01489",
    topics: ["Agent", "评测"],
    contribution: "以定位、修复、验证三阶段简化流程，证明复杂自治 harness 并非默认更优。",
    verified: true,
  },
  {
    year: 2024,
    title: "ToolSandbox: A Stateful, Conversational, Interactive Evaluation Benchmark for LLM Tool Use Capabilities",
    url: "https://arxiv.org/abs/2408.04682",
    topics: ["Agent", "评测"],
    contribution: "引入隐式状态依赖、on-policy 用户模拟、milestone、minefield 与动态轨迹评测。",
    verified: true,
  },
  {
    year: 2024,
    title: "Agent Security Bench: Formalizing and Benchmarking Attacks and Defenses in LLM-based Agents",
    url: "https://arxiv.org/abs/2410.02644",
    topics: ["Agent", "评测"],
    contribution: "跨 system/user prompt、工具与记忆形式化 Agent 攻击面，并联合评估效用与安全。",
    verified: true,
  },
  {
    year: 2024,
    title: "Training Software Engineering Agents and Verifiers with SWE-Gym",
    url: "https://arxiv.org/abs/2412.21139",
    topics: ["Agent", "后训练", "评测"],
    contribution: "构建 2,438 个可执行 Python 软件任务，用于训练软件 Agent 与 verifier。",
    verified: true,
  },
  {
    year: 2025,
    title: "The Berkeley Function Calling Leaderboard: From Tool Use to Agentic Evaluation of Large Language Models",
    url: "https://proceedings.mlr.press/v267/patil25a.html",
    topics: ["Agent", "评测"],
    contribution: "以 AST 与执行检查覆盖串行、并行、abstention 和多轮 function calling。",
    verified: true,
  },
  {
    year: 2025,
    title: "τ²-bench: Evaluating Conversational Agents in a Dual-Control Environment",
    url: "https://arxiv.org/abs/2506.07982",
    topics: ["Agent", "评测"],
    contribution: "用 Dec-POMDP 建模 Agent 与用户双方都能调用工具、共同改变环境的双控制任务。",
    verified: true,
  },
  {
    year: 2025,
    title: "RAGEN: Understanding Self-Evolution in LLM Agents via Multi-Turn Reinforcement Learning",
    url: "https://arxiv.org/abs/2504.20073",
    topics: ["Agent", "后训练", "推理"],
    contribution: "提出 StarPO，并用 Echo Trap 揭示多轮 Agent RL 的 reward cliff、梯度 spike 与 collapse。",
    verified: true,
  },
  {
    year: 2025,
    title: "Agent Lightning: Train ANY AI Agents with Reinforcement Learning",
    url: "https://arxiv.org/abs/2508.03680",
    topics: ["Agent", "后训练", "训练系统"],
    contribution: "以统一 transition 接口、分层 credit assignment 和训练—Agent 解耦连接任意运行时与 RL。",
    verified: true,
  },
  {
    year: 2025,
    title: "Training Long-Context, Multi-Turn Software Engineering Agents with Reinforcement Learning",
    url: "https://arxiv.org/abs/2508.03501",
    topics: ["Agent", "后训练", "长上下文", "训练系统"],
    contribution: "在 131K context 的可执行 SWE 环境中研究终局测试奖励、长轨迹与多轮 RL。",
    verified: true,
  },
  {
    year: 2025,
    title: "MCPMark: A Benchmark for Stress-Testing Realistic and Comprehensive MCP Use",
    url: "https://arxiv.org/abs/2509.24002",
    topics: ["Agent", "评测"],
    contribution: "在真实 MCP 工具协议与服务器生态中压力测试选择、组合和长程执行。",
    verified: true,
  },
  {
    year: 2026,
    title: "AgentENV",
    url: "https://github.com/kvcache-ai/AgentENV",
    topics: ["Agent", "训练系统"],
    contribution: "面向 Agentic AI 的 Firecracker microVM 环境，支持 pause、resume、fork、snapshot 与高密度运行。",
    verified: true,
  },
  {
    year: 2020,
    title: "An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale",
@@ -2270,7 +2542,7 @@ export const papers: Paper[] = [
    year: 2026,
    title: "DeepSeek-V4: Towards Highly Efficient Million-Token Context Intelligence",
    url: "https://arxiv.org/abs/2606.19348",
-    topics: ["基础", "长上下文", "MoE", "数据", "训练系统", "推理"],
+    topics: ["基础", "长上下文", "MoE", "数据", "训练系统", "推理", "Agent"],
    contribution: "32/33T 长文与 agentic 数据、CSA/HCA、mHC、Muon 和 1M 上下文双模型。",
    spotlight: "DeepSeek",
    verified: true,
@@ -342,6 +342,7 @@ const toc = [
        <p>
          Agent 方面，V3.2 的任务合成管线系统地产生复杂、交互式工具任务，让思考与 tool use 交织。
          这与 K3 的 white-box harness、知识图谱任务合成和可验证环境形成同期对照：前沿模型竞争正在从静态题库转向训练环境。
          <a href="/agents/#deepseek-v32">进入 Agent 专题查看 V3.2 的 search/code/general-agent 合成管线 →</a>
        </p>
      </section>
@@ -14,6 +14,7 @@ const routes: Record<string, string> = {
  "long-context": "/long-context/",
  "post-training/alignment": "/post-training/alignment/",
  reasoning: "/reasoning/",
  agents: "/agents/",
  "training-systems": "/training-systems/",
  "systems/numerics": "/systems/numerics/",
 };
@@ -91,6 +92,7 @@ const paths = [
          <a class="button" href="/long-context/">长上下文专题</a>
          <a class="button" href="/post-training/alignment/">后训练与偏好专题</a>
          <a class="button" href="/reasoning/">推理专题</a>
          <a class="button" href="/agents/">Agent 专题</a>
          <a class="button" href="/training-systems/">训练系统专题</a>
          <a class="button" href="/systems/numerics/">数值与优化专题</a>
        </div>
@@ -102,7 +104,7 @@ const paths = [
        <div class="hero-stats">
          <div><b>16</b><span>核心专题</span></div>
          <div><b>151</b><span>K3 报告来源</span></div>
-          <div><b>280</b><span>关键论文索引</span></div>
+          <div><b>314</b><span>关键论文索引</span></div>
          <div><b>47p</b><span>K3 技术报告</span></div>
        </div>
      </aside>
@@ -116,6 +118,22 @@ const paths = [
  <section class="section compact release-section" id="new-chapters">
    <div class="release-grid">
      <a class="release-card agent-release" href="/agents/">
        <div>
          <p class="eyebrow"><span>NEW / CHAPTER 12</span> AGENTS · TOOL USE · ENVIRONMENTS</p>
          <h2>Agent 不是一个循环：格式正确、执行成功和任务完成是三道不同的门</h2>
          <p>
            用环境、工具、循环、规划、记忆、执行、验证、轨迹、归因、分布、系统、可靠性、评测与安全十四张账，
            从 TextWorld、ReAct 和 Toolformer 走到 DeepSeek-V4 DSec 与 Kimi K3 百万 Token Agentic RL。
          </p>
        </div>
        <dl>
          <div><dt>LINEAGE</dt><dd>2018 → 2026</dd></div>
          <div><dt>NODES</dt><dd>52 个一手节点</dd></div>
          <div><dt>LAB</dt><dd>循环 · 契约 · 可靠性 · 长程 RL</dd></div>
        </dl>
        <span class="release-arrow" aria-hidden="true">从生成文字进入可验证行动 →</span>
      </a>
      <a class="release-card alignment-release" href="/post-training/alignment/">
        <div>
          <p class="eyebrow"><span>NEW / CHAPTER 10</span> ALIGNMENT · PREFERENCE</p>
@@ -509,6 +527,7 @@ const paths = [
      transition: transform 180ms ease, border-color 180ms ease;
    }
    .agent-release,
    .alignment-release,
    .transformer-release,
    .foundation-release,
@@ -521,6 +540,14 @@ const paths = [
      min-height: 510px;
    }
    .agent-release {
      background:
        radial-gradient(circle at 82% 18%, rgba(56, 91, 128, 0.2), transparent 30%),
        radial-gradient(circle at 62% 74%, rgba(76, 118, 112, 0.16), transparent 28%),
        repeating-linear-gradient(90deg, transparent 0 58px, rgba(56, 91, 128, 0.04) 58px 59px),
        var(--paper-raised);
    }
    .alignment-release {
      background:
        radial-gradient(circle at 82% 18%, rgba(134, 76, 76, 0.2), transparent 30%),
@@ -418,6 +418,7 @@ const toc = [
          <p>
            可靠 Agent 的学习单位不是“一条漂亮回答”，而是状态明确、动作可执行、反馈可验证的一整段轨迹。
            Harness 多样化、持久环境和独立 verifier，分别处理接口过拟合、短视行为和自我宣告成功。
            <a href="/agents/#k3-whitebox">进入 Agent 专题，完整拆解 white-box harness、AET 与 AgentENV →</a>
          </p>
        </div>
      </section>
@@ -17,6 +17,7 @@ const workstreams = [
  { label: "DeepSeek 专题", value: 71, next: "补 R1 / DAPO 的逐图训练轨迹与复现对照" },
  { label: "指令微调与人类偏好", value: 75, next: "加入真实偏好分歧样本、RM 长度偏置与 PPO/DPO 小模型复现" },
  { label: "推理与测试时扩展", value: 76, next: "真实模型采样曲线、PRM 案例与逐篇图表精读" },
  { label: "工具使用与长程 Agent", value: 74, next: "补真实环境 traces、cross-harness 对照、Agent RL 训练曲线与安全案例" },
  { label: "稀疏计算与 MoE", value: 74, next: "补充真实集群 traces 与专家特化案例" },
  { label: "长上下文专题", value: 72, next: "加入更多论文逐图笔记与真实模型配置对比" },
  { label: "大规模训练系统", value: 71, next: "补真实集群 traces、故障案例与精确 topology 配置" },
@@ -45,7 +46,7 @@ const workstreams = [
        <div><dt>OVERALL</dt><dd>专题平均 {average}%</dd></div>
        <div><dt>READABLE</dt><dd>{published} 个首版可读专题</dd></div>
        <div><dt>ACTIVE</dt><dd>{researching} 个研究/写作中</dd></div>
-        <div><dt>UPDATED</dt><dd>2026-07-29 05:59 CST</dd></div>
+        <div><dt>UPDATED</dt><dd>2026-07-29 06:56 CST</dd></div>
        <div><dt>MODE</dt><dd>持续迭代，不锁死版本</dd></div>
      </dl>
    </div>
@@ -55,7 +56,7 @@ const workstreams = [
    <div class="section-heading">
      <div>
        <p class="eyebrow"><span>01</span> WORKSTREAMS</p>
-        <h2>十六条工作流同时推进，但不混淆“有页面”和“已核验”</h2>
+        <h2>十七条工作流同时推进，但不混淆“有页面”和“已核验”</h2>
      </div>
      <p class="section-lead">
        内容首版优先打通全局脉络；随后每轮迭代选择一个专题推进到论文/工程层，并做独立事实复核。
@@ -92,8 +93,8 @@ const workstreams = [
      <article><span>✓</span><h3>K3 报告已结构化拆解</h3><p>47 页报告目录、151 条参考来源和架构/后训练/系统主线已经提取。</p></article>
      <article><span>✓</span><h3>16 专题知识图</h3><p>从语言模型基础到评测安全，包含先修依赖和三条贯穿案例。</p></article>
      <article><span>✓</span><h3>编辑式网站系统</h3><p>响应式导航、章节模板、侧栏、进度、论文链和证据提示组件。</p></article>
-      <article><span>✓</span><h3>三十五个原创交互视图</h3><p>K3、语言模型前史、Transformer、DeepSeek、长上下文、MoE、推理，以及训练系统、Scaling、数据工程、数值和 Alignment 专题。</p></article>
+      <article><span>✓</span><h3>三十九个原创交互视图</h3><p>K3、语言模型前史、Transformer、DeepSeek、长上下文、MoE、推理、Agent，以及训练系统、Scaling、数据工程、数值和 Alignment 专题。</p></article>
-      <article><span>✓</span><h3>十二篇首版长文</h3><p>K3、语言模型前史、Transformer、DeepSeek、Scaling、数据工程、长上下文、MoE、后训练、推理、训练系统与数值优化专题。</p></article>
+      <article><span>✓</span><h3>十三篇首版长文</h3><p>K3、语言模型前史、Transformer、DeepSeek、Scaling、数据工程、长上下文、MoE、后训练、推理、Agent、训练系统与数值优化专题。</p></article>
      <article><span>✓</span><h3>语言模型前史深度专题</h3><p>八张独立问题账、33 个正式节点、20 段长文与概率—向量—记忆—对齐四联实验。</p></article>
      <article><span>✓</span><h3>Transformer 深度专题</h3><p>十张独立问题账、40 个正式节点、21 段正文与 QKV—Mask—多头位置—Block 成本四联实验。</p></article>
      <article><span>✓</span><h3>Scaling Laws 深度专题</h3><p>九张账、29 个一手节点、DeepSeek/Kimi 双谱系与曲面—部署—复用—涌现四联实验。</p></article>
@@ -104,7 +105,8 @@ const workstreams = [
      <article><span>✓</span><h3>训练系统深度专题</h3><p>九张账、37 个一手节点、DeepSeek/Kimi 双谱系与显存—网格—气泡—通信实验室。</p></article>
      <article><span>✓</span><h3>数值、优化器与稳定性深度专题</h3><p>十张账、36 个一手节点、K2/K3 与 DeepSeek-V3/V4 双谱系，以及格式—状态—更新—失稳四联实验。</p></article>
      <article><span>✓</span><h3>指令微调与人类偏好深度专题</h3><p>十二张账、44 个一手节点、DeepSeek/Kimi 后训练双谱系，以及 SFT—RM—PPO/DPO—配方四联实验。</p></article>
-      <article><span>✓</span><h3>280 篇关键论文索引</h3><p>新增人类偏好学习、HH-RLHF、LIMA、RewardBench、RLAIF、KTO、ORPO、SimPO 等 22 个后训练节点。</p></article>
+      <article><span>✓</span><h3>工具使用与长程 Agent 深度专题</h3><p>十四张账、52 个一手节点、DeepSeek/Kimi Agent 双谱系，以及循环—工具契约—可靠性—长程 RL 四联实验。</p></article>
      <article><span>✓</span><h3>314 篇关键论文索引</h3><p>新增 TextWorld、WebArena、ToolSandbox、AgentDojo、RAGEN、Agent Lightning、AgentENV 等 34 个 Agent 节点。</p></article>
      <article><span>✓</span><h3>公开仓库与自托管发布</h3><p>源码公开到 git.k1412.top，网站由不可变镜像、Compose Manager 与 HTTPS 交付。</p></article>
    </div>
  </section>
@@ -129,6 +131,7 @@ const workstreams = [
      <div><span>P1</span><strong>MoE 二轮深化</strong><p>真实负载 traces → 专家特化可解释性 → 共享专家语义</p><em>案例库 + 集群证据</em></div>
      <div><span>P1</span><strong>推理二轮深化</strong><p>真实 pass@k 曲线 → PRM 失败案例 → 逐篇图表精读</p><em>案例库 + 真实 traces</em></div>
      <div><span>P1</span><strong>Alignment 二轮深化</strong><p>真实偏好分歧 → RM 长度偏置 → PPO/DPO 小模型复现</p><em>数据案例 + 可复现实验</em></div>
      <div><span>P1</span><strong>Agent 二轮深化</strong><p>真实环境 traces → cross-harness ablation → Agent RL 曲线与提示注入案例</p><em>运行证据 + 安全案例库</em></div>
      <div><span>P2</span><strong>原生多模态</strong><p>ViT/CLIP → connector VLM → Kimi-VL/MoonViT-V2</p><em>视觉 Token 流程图</em></div>
    </div>
  </section>
@@ -179,6 +182,8 @@ const workstreams = [
      <div><time>2026-07-29</time><b>NTP、MTP 与多模态永久分角色</b><p>K3 的统一视觉/文本 next-token objective、one MTP layer 与 EAGLE-3 draft bridge 分开记账；DeepSeek MTP 也不写成取代自回归。</p></div>
      <div><time>2026-07-29</time><b>Transformer 按十张账组织</b><p>信息路径、几何、可见性、多头、位置、局部计算、深度、目标、系统成本与当代映射不再混成一个 Block。</p></div>
      <div><time>2026-07-29</time><b>Attention 权重与因果解释永久分离</b><p>热力图可描述中间权重和提出假设；因果结论必须补消融、patching 或反事实干预。</p></div>
      <div><time>2026-07-29</time><b>Agent 按十四张账组织</b><p>模型、harness、工具契约、环境、评测器、可靠性与安全不再被压成一个 Agent 分数。</p></div>
      <div><time>2026-07-29</time><b>Agent 完成必须回到 final state</b><p>function schema、工具执行、业务状态、策略合规与 pass^k 分层评价；模型自报完成不作为证据。</p></div>
    </div>
  </section>