Long-running work accumulates material: the original goal, later constraints, attempted routes, failed experiments and current progress. Sending everything again on each continuation repeats more and more content; keeping only a summary can make the original basis of a decision difficult to recover.
Selective JSON Pointer lookup by itself is straightforward—it folds long-tail history not needed for the immediate decision. The core mechanism in LoopX's context delivery is compaction-cycle-bounded structured delta context : complete sources are saved first, unchanged typed subtrees are reused exactly against a verified baseline within the active context_epoch, and any host compaction or digest mismatch atomically resets to a fresh complete baseline rather than chaining dangling deltas.
Results first: four-stage step-down, compaction-cycle deltas and task ablation
-Step-down from 100%: All → Progressive → Compaction-Cycle Structured Delta → First Read
-When stacked in pipeline order, context payload bytes step down monotonically from 100% complete capture (All) to the Progressive necessary view , then to compaction-cycle structured delta on top of Progressive (Progressive + Delta) , and finally to the byte-budgeted --initial-read entrypoint (Progressive + Delta First Read)
-Step-down from 100%: deterministic 4-stage pipeline and 18h compaction-cycle delta audit
A: Same-source four-stage cascade from measurements.json (single 57,014 B denominator), where stacking compaction-cycle structured Delta cuts Progressive (9.7%) by a further 61.0% (to 3.8%) and first-read body reaches 1.2%. B1: ANN 18h paired trajectory stacking compaction-cycle structured Delta on selected packets (3.09 MB), cutting all 46 paired events by 38.54% and the 24 in-cycle delta wakes by 74.25%. B2: Eight-task cohort shares over 213 wakes (Progressive 32.5%) and 112 in-cycle continuations (Prog+Delta first-read 3.0% body / 5.0% CLI), each kept on its own denominator. Four mechanisms, with separate measurement baselines
+Complete capture, Progressive views, compaction-cycle structured Delta and a bounded --initial-read are composable mechanisms, but their bytes do not decrease monotonically for every input. Delta requires a verified same-cycle baseline; a new epoch, mismatch or smaller full representation uses complete delivery. The archived tutorial below measures three independent comparisons, not a same-source four-stage cascade .
+Separate tutorial comparisons and 18h compaction-cycle Delta observations
A: Three archived tutorial comparisons from measurements.json: the necessary view is 5,107 / 57,014 B (9.0%); the next capture's Delta file is 2,164 / 5,543 B of its full Progressive delivery file (39.0%); manually selecting three paths from the separate 51,547 B capture.json returns 674 B (1.3% body), or 1,362 B including CLI metadata (2.6%). The 674 B is not a measured --initial-read after Progressive + Delta. These saved observations belong to the revision recorded in measurements.json; output size may change with source revision and reader paths. B1: ANN's archived 18h pairs compare Delta against selected packets, with 38.54% reduction across 46 events and 74.25% across 24 in-cycle Delta events. B2: Eight-task aggregates retain the separate 213-wake and 112-continuation denominators; their percentages cannot be chained into this tutorial. Eight tasks: single-layer payloads (Progressive / lossless Delta file) vs stacked first-read
When reading the published eight-task Four-Arm Context ON 18h table below, separate single-layer file payloads from the stacked first-read entrypoint . Across 213 model-facing wakes (101 new-session or post-compaction baseline reads and 112 in-cycle continuations), the published “In-cycle Delta payload” column (4.49 MB / ≈ 12.53 MB = 35.8% ) measures the unprojected lossless delivery.json file on disk (All → Delta) —a parallel single-layer cut alongside “Progressive projection” (7.29 / 22.41 MB = 32.5% , All → Progressive), not stacked Progressive + Delta. Both mechanisms stack in the final column, Prog+Delta first-screen (3.0% body / 5.0% CLI) . Per-task cells retain the published values; totals are recomputed from those cells without raw per-wake logs.
diff --git a/apps/presentation/site/public/blog/images/context-delivery/context-cascade-en.svg b/apps/presentation/site/public/blog/images/context-delivery/context-cascade-en.svg
index f3df3df230..c2594e7ec0 100644
--- a/apps/presentation/site/public/blog/images/context-delivery/context-cascade-en.svg
+++ b/apps/presentation/site/public/blog/images/context-delivery/context-cascade-en.svg
@@ -93,85 +93,68 @@ L 374.277959 109.296
- Share of complete source bytes (%)
+ Share of each row's own baseline bytes (%)
- 1. All · Full source
+ Progressive view / original capture
- 2. Progressive · Fold tail
+ In-cycle Delta / full delivery
- 3. Prog + In-cycle Delta
-
-
-
-
- 4. Prog + Delta First read
+ Manual selection / tutorial capture
-
-
-
-
+
-
-
+
+
+ 9.0% (5,107 / 57,014 B)
+
- 100.0% (57,014 B)
+ 39.0% (2,164 / 5,543 B)
- 9.7% (5,543 B · fold long tail)
+ 1.3% (674 / 51,547 B · 2.6% CLI)
- 3.8% (2,164 B · −61.0% vs Prog)
-
-
- 1.2% (674 B body / 2.4% CLI)
-
-
- A. Same-source 4-stage cascade
+ A. Three independent archived tutorial comparisons
-
+
-
+
-
+
0
-
+
-
+
25
-
+
-
+
50
-
+
-
+
75
-
+
-
+
100
-
+
Share of Progressive selected bytes (%)
-
-
+
+
Progressive selected (46)
-
-
+
+
+ In-cycle Delta (all 46)
-
-
+
+
+ In-cycle Delta (24 delta)
-
+
-
+
-
+
-
+
100.0% (3.09 MB selected base)
-
+
61.5% (1.90 MB · −38.54%)
-
+
25.75% (in-cycle −74.25%)
-
+
B1. 18h core layer: stacking compaction-cycle Delta (ANN)
-
+
-
+
-
+
0
-
+
-
+
25
-
+
-
+
50
-
+
-
+
75
-
+
-
+
100
-
+
Share of cohort Full bytes (%)
-
-
+
+
All · Full packets
-
-
+
+
Progressive · 213 wakes
-
-
+
+
Prog+Delta First read · 112
-
+
-
+
-
+
-
+
100.0% (22.41 MB / in-cycle ≈12.53 MB)
-
+
32.5% (7.29 MB · −67.5%)
-
+
≈ 3.0% body / ≈ 5.0% CLI (−97% / −95%)
-
+
B2. 8-task 18h cohorts: 100% Full to Prog+Delta entry
-
- Step-Down from 100%: All → Progressive → Compaction-Cycle Structured Delta → First Read
+
+ Layered context: separate tutorial comparisons and 18h in-cycle Delta observations
-
- Progressive lookup folds long-tail history; the core mechanism reuses verified subtrees within a compaction epoch and resets on compaction.
+
+ Progressive views retain necessary facts; in-cycle Delta reuses verified subtrees. Compaction or mismatch restores the complete baseline.
-
- A: exact same-source pipeline (measurements.json, single 57,014 B denominator). B1: ANN 18h paired trajectory stacking compaction-cycle Delta on selected packets.
+
+ A: independent archived comparisons in measurements.json; 674 B is a manual three-path selection, not a measured stacked --initial-read.
B2: 8-task shares over 213 wakes (Progressive) and 112 in-cycle continuations (Prog+Delta first-read); each cohort keeps its own denominator.
diff --git a/apps/presentation/site/public/blog/images/context-delivery/context-cascade-zh.svg b/apps/presentation/site/public/blog/images/context-delivery/context-cascade-zh.svg
index 264323ee54..465b77db9e 100644
--- a/apps/presentation/site/public/blog/images/context-delivery/context-cascade-zh.svg
+++ b/apps/presentation/site/public/blog/images/context-delivery/context-cascade-zh.svg
@@ -93,85 +93,68 @@ L 374.277959 109.296
- 占完整原始捕获字节 (%)
+ 占各行自身对照基线的字节 (%)
- 1. All · 完整上下文
+ Progressive 必要视图 / 原捕获
- 2. Progressive · 渐进折叠
+ 周期内 Delta / 本轮完整交付
- 3. Prog + 周期内结构化 Delta
-
-
-
-
- 4. Prog + Delta First Read
+ 手工批量选读 / 教程捕获
-
-
-
-
+
-
-
+
+
+ 9.0% (5,107 / 57,014 B)
+
- 100.0% (57,014 B)
+ 39.0% (2,164 / 5,543 B)
- 9.7% (5,543 B · 按需折叠长尾)
+ 1.3% (674 / 51,547 B · 2.6% CLI)
- 3.8% (2,164 B · 较 Prog 再减 −61.0%)
-
-
- 1.2% (674 B 正文 / 2.4% CLI)
-
-
- A. 同源流水线四阶叠加削减（固定基准）
+ A. 归档教程的三组独立对照
-
+
-
+
-
+
0
-
+
-
+
25
-
+
-
+
50
-
+
-
+
75
-
+
-
+
100
-
+
占 Progressive 选中字节 (%)
-
-
+
+
Progressive 选中包 (46 轮)
-
-
+
+
+ 周期内 Delta (全 46 轮)
-
-
+
+
+ 周期内 Delta (24 增量轮)
-
+
-
+
-
+
-
+
100.0% (3.09 MB 选中基线)
-
+
61.5% (1.90 MB · 再减 −38.54%)
-
+
25.75% (同周期再减 −74.25%)
-
+
B1. 18h 实测核心增量：叠加压缩周期内结构化 Delta（ANN）
-
+
-
+
-
+
0
-
+
-
+
25
-
+
-
+
50
-
+
-
+
75
-
+
-
+
100
-
+
占对应唤醒组 Full 字节 (%)
-
-
+
+
All · 完整决策包
-
-
+
+
Progressive · 213 次
-
-
+
+
Prog+Delta 首读 · 112 次
-
+
-
+
-
+
-
+
100.0% (22.41 MB / 续跑 ≈12.53 MB)
-
+
32.5% (7.29 MB · 净减 −67.5%)
-
+
≈ 3.0% 正文 / ≈ 5.0% CLI (−97% / −95%)
-
+
B2. 八题 18h 队列汇总：从 100% 到叠加首读入口
-
- 从 100% 逐层削减：All → Progressive → 压缩周期内结构化 Delta → First Read
+
+ 分层上下文：独立教程对照与 18h 周期内差分观测
-
- 渐进选读仅按需折叠历史长尾；核心机制是在有效 Compaction 周期内精确复用不变结构子树，并在压缩或失配时原子恢复完整基线。
+
+ 渐进视图保留必要事实；周期内结构化 Delta 复用已验证子树。压缩或失配恢复完整基线，不保证任意输入逐级变小。
-
- A：同源固定流水线（measurements.json，同一 57,014 B 分母）。B1：ANN 18h 配对轨迹在选中包（3.09 MB）上叠加周期内结构化 Delta 的进一步削减。
+
+ A：measurements.json 的独立归档对照，各行分母不同；674 B 为三个 --select 的手工选读，未测同源四阶段的 --initial-read。
B2：八题 213 次唤醒（Progressive）与 112 次同周期续跑（Prog+Delta 首读）各自相对原分母的比例；跨队列分母分开列出，不做混乘。
diff --git a/apps/presentation/site/public/blog/zh/context-delivery/index.html b/apps/presentation/site/public/blog/zh/context-delivery/index.html
index 80af5c8898..17e0b293b7 100644
--- a/apps/presentation/site/public/blog/zh/context-delivery/index.html
+++ b/apps/presentation/site/public/blog/zh/context-delivery/index.html
@@ -6,13 +6,13 @@
跳至正文
-← 全部文章 Context delivery
Agent 读上下文，也需要一套“查书”的方法 从 100% 全量捕获逐层削减：按需渐进折叠长尾，在有效 compaction 周期内交付结构化差分上下文，并在压缩后无损恢复基线。
LoopX · 2026 年 11 月 1 日 · 11 月 12 日更新 Agent 做长任务，资料会越来越多：原目标、后来追加的约束、试过的方案、失败的实验、当前做到哪里。每次继续都把整份材料再塞一遍，重复会不断累积；只留一段摘要，又可能找不回决定所依赖的原话。
+← 全部文章 Context delivery
Agent 读上下文，也需要一套“查书”的方法 先读必要事实，在有效 compaction 周期内复用已验证的结构；连续性丢失时恢复完整基线。
LoopX · 2026 年 11 月 1 日 · 11 月 12 日更新 Agent 做长任务，资料会越来越多：原目标、后来追加的约束、试过的方案、失败的实验、当前做到哪里。每次继续都把整份材料再塞一遍，重复会不断累积；只留一段摘要，又可能找不回决定所依赖的原话。
按 JSON Pointer 渐进选读本身并不复杂，主要用来折叠当前决定暂不需要的历史长尾；LoopX 上下文交付真正的机制重心，是受 compaction 周期约束的结构化差分上下文（compaction-cycle structured delta） ：完整来源先落盘存证，在同一个已核验的 context_epoch 内精确复用未变化的结构子树、只编码本轮结构增删改；一旦宿主发生上下文压缩或基线摘要失配，立即原子切换回新的完整基线，绝不悬空叠加旧差分。
先看数据：从 100% 逐层削减、周期内结构化差分与任务消融
-四阶叠加流水线：All → Progressive → 压缩周期内结构化 Delta → First Read
-按实际叠加顺序看，上下文体积沿着四级流水线单调递减：先从 100% 完整捕获（All） 折叠长尾得到 Progressive 必要视图 ，再在同一有效 compaction 周期内叠加结构化差分（Progressive + Delta） ，最后以受字节预算保护的 --initial-read 首读入口（Progressive + Delta First Read）
-从 100% 逐层削减：同源四阶流水线与 18h 轨迹周期内差分实测
A：后文同源固定流水线（measurements.json，同一 57,014 B 分母）的四阶单调削减，在 Progressive（9.7%）之上叠加周期内结构化 Delta 再减 61.0%（至 3.8%），首读正文降至 1.2%。B1：ANN 18h 配对轨迹在 Progressive 选中包（3.09 MB）上叠加周期内结构化 Delta，全 46 轮再减 38.54%，24 个同周期增量轮再减 74.25%。B2：八题 213 次唤醒（Progressive 32.5%）与 112 次同周期续跑（Prog+Delta 首读正文 3.0% / CLI 5.0%）各自相对原分母的比例。 四种机制，分别核对测量基线
+完整捕获、Progressive 必要视图、压缩周期内结构化 Delta 与受预算保护的 --initial-read 可以组合，但不保证任意输入的字节数逐级单调递减。Delta 依赖同周期内已验证的基线；新周期、摘要失配或完整表示更小时，恢复完整交付。下图教程数据是三组独立对照，不是同源四阶实测流水线 。
+独立教程对照与 18h 压缩周期内差分观测
A：measurements.json 的三组归档教程对照：必要视图为 5,107 / 57,014 B（9.0%）；下一份捕获的 Delta 文件为 2,164 / 5,543 B，相对本轮完整 Progressive 交付文件保留 39.0%；另一份 51,547 B 的 capture.json 手工选择三个路径，返回 674 B 正文（1.3%），含 CLI 元数据为 1,362 B（2.6%）。674 B 不是 Progressive＋Delta 后执行 --initial-read 的实测。这里保留的是 measurements.json 所注明源码版本的历史观测，输出大小可能随源码版本和读取路径变化。B1：ANN 归档 18h 配对以选中包为基线，全 46 轮再减 38.54%，24 个周期内增量轮再减 74.25%。B2：八题的 213 次唤醒与 112 次续跑各用原分母，不与教程数字串成一条削减链。 八题对照：区分单层载荷（Progressive / 无损 Delta 文件）与叠加首读
阅读下方已公开的八题四臂 Context ON 18h 聚合表时，需要区分单层文件载荷 与双层叠加首读 ：原表共覆盖 213 次模型侧唤醒（101 次新会话或压缩后的基线读取 + 112 次同周期续跑），其中「同周期 Delta 载荷」列（4.49 MB / 约 12.53 MB = 35.8% ）统计的是磁盘上尚未叠加渐进裁剪的单路无损 delivery.json 文件（All → Delta） ，与「Progressive 必要视图」（7.29 / 22.41 MB = 32.5% ，All → Progressive）属于平行的单层裁剪，而非叠加后的 Progressive + Delta；把渐进选读与周期内差分真正叠在一起的，是最后一列 Prog+Delta 首读入口（3.0% 正文 / 5.0% 含 CLI 封装） 。逐题单元格保留来源原值，合计按表重算；这里不附原始逐 wake 日志。
diff --git a/apps/presentation/site/scripts/generate-long-horizon-audit.py b/apps/presentation/site/scripts/generate-long-horizon-audit.py
index f023d79692..4acda82a8c 100644
--- a/apps/presentation/site/scripts/generate-long-horizon-audit.py
+++ b/apps/presentation/site/scripts/generate-long-horizon-audit.py
@@ -32,11 +32,14 @@ def save(fig, relative):
for language in ("en", "zh"):
zh = language == "zh"
- # 1. Four-stage monotonic step-down cascade:
- # All (100%) -> Progressive -> Progressive + Compaction-Cycle Structured Delta -> First Read
+ # 1. Independent archived tutorial comparisons, not one measured cascade.
+ # Each numerator is paired with its own recorded baseline. In particular,
+ # a manual --select response is not a native --initial-read measurement.
orig_b = LESSON["native_projection"]["original_bytes"]
+ required_b = LESSON["native_projection"]["required_bytes"]
prog_b = LESSON["cycle_codec"]["current_full_bytes"]
pdelta_b = LESSON["cycle_codec"]["delta_bytes"]
+ manual_source_b = next(r for r in LESSON["reader_rows"] if r["case"] == "complete_capture")["body_bytes"]
batch_row = next(r for r in LESSON["reader_rows"] if r["case"] == "one_batched_select")
first_body_lesson = batch_row["body_bytes"]
first_cli_lesson = batch_row["output_bytes"]
@@ -50,49 +53,38 @@ def save(fig, relative):
right_top = fig.add_subplot(gs[0, 1])
right_bot = fig.add_subplot(gs[1, 1])
- cascade_vals = [100.0, 100 * prog_b / orig_b, 100 * pdelta_b / orig_b, 100 * first_body_lesson / orig_b]
+ cascade_vals = [100 * required_b / orig_b, 100 * pdelta_b / prog_b,
+ 100 * first_body_lesson / manual_source_b]
cascade_labels = (
[
- "1. All · 完整上下文",
- "2. Progressive · 渐进折叠",
- "3. Prog + 周期内结构化 Delta",
- "4. Prog + Delta First Read",
+ "Progressive 必要视图 / 原捕获",
+ "周期内 Delta / 本轮完整交付",
+ "手工批量选读 / 教程捕获",
]
if zh else
[
- "1. All · Full source",
- "2. Progressive · Fold tail",
- "3. Prog + In-cycle Delta",
- "4. Prog + Delta First read",
+ "Progressive view / original capture",
+ "In-cycle Delta / full delivery",
+ "Manual selection / tutorial capture",
]
)
- cascade_notes = (
- [
- f"100.0% ({orig_b:,} B)",
- f"{cascade_vals[1]:.1f}% ({prog_b:,} B · 按需折叠长尾)",
- f"{cascade_vals[2]:.1f}% ({pdelta_b:,} B · 较 Prog 再减 −61.0%)",
- f"{cascade_vals[3]:.1f}% ({first_body_lesson:,} B 正文 / {100*first_cli_lesson/orig_b:.1f}% CLI)",
- ]
- if zh else
- [
- f"100.0% ({orig_b:,} B)",
- f"{cascade_vals[1]:.1f}% ({prog_b:,} B · fold long tail)",
- f"{cascade_vals[2]:.1f}% ({pdelta_b:,} B · −61.0% vs Prog)",
- f"{cascade_vals[3]:.1f}% ({first_body_lesson:,} B body / {100*first_cli_lesson/orig_b:.1f}% CLI)",
- ]
- )
- left.barh(range(4), cascade_vals, color=[SLATE, BLUE, TEAL, PURPLE], height=.50)
- left.set_yticks(range(4), cascade_labels, fontsize=10.2)
+ cascade_notes = [
+ f"{cascade_vals[0]:.1f}% ({required_b:,} / {orig_b:,} B)",
+ f"{cascade_vals[1]:.1f}% ({pdelta_b:,} / {prog_b:,} B)",
+ f"{cascade_vals[2]:.1f}% ({first_body_lesson:,} / {manual_source_b:,} B · {100*first_cli_lesson/manual_source_b:.1f}% CLI)",
+ ]
+ left.barh(range(3), cascade_vals, color=[BLUE, TEAL, PURPLE], height=.50)
+ left.set_yticks(range(3), cascade_labels, fontsize=10.2)
left.invert_yaxis()
left.set_xlim(0, 168)
- left.set_xlabel("占完整原始捕获字节 (%)" if zh else "Share of complete source bytes (%)", fontsize=9.8)
+ left.set_xlabel("占各行自身对照基线的字节 (%)" if zh else "Share of each row's own baseline bytes (%)", fontsize=9.8)
left.set_title(
- "A. 同源流水线四阶叠加削减（固定基准）" if zh else "A. Same-source 4-stage cascade",
+ "A. 归档教程的三组独立对照" if zh else "A. Three independent archived tutorial comparisons",
loc="left", pad=14, fontsize=11.5, fontweight="bold",
)
for idx, (val, note) in enumerate(zip(cascade_vals, cascade_notes)):
- weight = "bold" if idx == 2 else "normal"
- color = "#0f766e" if idx == 2 else "#0f172a"
+ weight = "bold" if idx == 1 else "normal"
+ color = "#0f766e" if idx == 1 else "#0f172a"
left.text(val + 2.2, idx, note, va="center", fontsize=9.6, fontweight=weight, color=color)
# Panel B1: Real 18h ANN paired audit — stacking Compaction-Cycle Structured Delta on top of Progressive
@@ -195,22 +187,22 @@ def save(fig, relative):
axis.set_xticks([0, 25, 50, 75, 100])
fig.suptitle(
- "从 100% 逐层削减：All → Progressive → 压缩周期内结构化 Delta → First Read"
+ "分层上下文：独立教程对照与 18h 周期内差分观测"
if zh else
- "Step-Down from 100%: All → Progressive → Compaction-Cycle Structured Delta → First Read",
+ "Layered context: separate tutorial comparisons and 18h in-cycle Delta observations",
fontsize=15.0, fontweight="bold", y=.955,
)
sub = (
- "渐进选读仅按需折叠历史长尾；核心机制是在有效 Compaction 周期内精确复用不变结构子树，并在压缩或失配时原子恢复完整基线。"
+ "渐进视图保留必要事实；周期内结构化 Delta 复用已验证子树。压缩或失配恢复完整基线，不保证任意输入逐级变小。"
if zh else
- "Progressive lookup folds long-tail history; the core mechanism reuses verified subtrees within a compaction epoch and resets on compaction."
+ "Progressive views retain necessary facts; in-cycle Delta reuses verified subtrees. Compaction or mismatch restores the complete baseline."
)
fig.text(.5, .87, sub, ha="center", fontsize=10.2, color="#475569")
footer_cascade = (
- "A：同源固定流水线（measurements.json，同一 57,014 B 分母）。B1：ANN 18h 配对轨迹在选中包（3.09 MB）上叠加周期内结构化 Delta 的进一步削减。\n"
+ "A：measurements.json 的独立归档对照，各行分母不同；674 B 为三个 --select 的手工选读，未测同源四阶段的 --initial-read。\n"
"B2：八题 213 次唤醒（Progressive）与 112 次同周期续跑（Prog+Delta 首读）各自相对原分母的比例；跨队列分母分开列出，不做混乘。"
if zh else
- "A: exact same-source pipeline (measurements.json, single 57,014 B denominator). B1: ANN 18h paired trajectory stacking compaction-cycle Delta on selected packets.\n"
+ "A: independent archived comparisons in measurements.json; 674 B is a manual three-path selection, not a measured stacked --initial-read.\n"
"B2: 8-task shares over 213 wakes (Progressive) and 112 in-cycle continuations (Prog+Delta first-read); each cohort keeps its own denominator."
)
fig.text(.03, .03, footer_cascade, fontsize=9.4, color="#475569", linespacing=1.5)
diff --git a/examples/blog-bilingual-index-smoke.mjs b/examples/blog-bilingual-index-smoke.mjs
index 9f213617d9..d99c731653 100644
--- a/examples/blog-bilingual-index-smoke.mjs
+++ b/examples/blog-bilingual-index-smoke.mjs
@@ -109,13 +109,23 @@ export async function validateBilingualBlog(blogDir) {
assertIncludes(article, "32.5%", "The weighted share matches the public rows");
const langSuffix = locale === "zh/" ? "zh" : "en";
assertIncludes(article, `context-cascade-${langSuffix}.svg`,
- "Both published editions must embed the 100% four-stage cascade chart");
+ "Both published editions must embed the context measurement comparisons");
const cascadeSvg = await readFile(
resolve(blogDir, `images/context-delivery/context-cascade-${langSuffix}.svg`),
"utf8",
);
- for (const token of ["100.0%", "−61.0%", "−74.25%"]) {
- assertIncludes(cascadeSvg, token, `Cascade chart must retain verified step-down figure: ${langSuffix} ${token}`);
+ const lesson = JSON.parse(await readFile(resolve(blogDir, "context-delivery/measurements.json"), "utf8"));
+ const manual = lesson.reader_rows.find(row => row.case === "one_batched_select");
+ const full = lesson.reader_rows.find(row => row.case === "complete_capture");
+ for (const [method, numerator, denominator] of [
+ ["progressive", lesson.native_projection.required_bytes, lesson.native_projection.original_bytes],
+ ["cycle-delta", lesson.cycle_codec.delta_bytes, lesson.cycle_codec.current_full_bytes],
+ ["manual-select", manual.body_bytes, full.body_bytes],
+ ]) {
+ assertIncludes(article, `data-comparison-${method}="${numerator}/${denominator}"`,
+ "Each comparison must retain its own measured numerator and denominator");
+ const pair = [numerator, denominator].map(value => value.toLocaleString("en-US")).join(" / ");
+ assertIncludes(cascadeSvg, pair, `Chart and article must agree on the measured pair: ${method}`);
}
const multitaskSvg = await readFile(
resolve(blogDir, `images/context-delivery/multitask-byte-ratios-${langSuffix}.svg`),
From 0a1c4a31c815d61fa3edc507dcb555df615acfe9 Mon Sep 17 00:00:00 2001
From: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
Date: Thu, 12 Nov 2026 02:50:48 +0800
Subject: [PATCH 3/3] docs(blog): align entry summaries with independent
comparisons
Signed-off-by: LoopX Agent <337587101+loopx-agent@users.noreply.github.com>
---
apps/presentation/site/public/blog/context-delivery/index.html | 2 +-
apps/presentation/site/public/blog/index.html | 2 +-
.../site/public/blog/zh/context-delivery/index.html | 2 +-
apps/presentation/site/public/blog/zh/index.html | 2 +-
4 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/apps/presentation/site/public/blog/context-delivery/index.html b/apps/presentation/site/public/blog/context-delivery/index.html
index c40a10cd00..cfc155b805 100644
--- a/apps/presentation/site/public/blog/context-delivery/index.html
+++ b/apps/presentation/site/public/blog/context-delivery/index.html
@@ -9,7 +9,7 @@
← All articles Context delivery
An Agent needs a way to look things up, too Read necessary facts first, reuse verified structures within a compaction cycle, and recover the complete baseline when continuity is lost.
LoopX · November 1, 2026 · Updated November 12 Long-running work accumulates material: the original goal, later constraints, attempted routes, failed experiments and current progress. Sending everything again on each continuation repeats more and more content; keeping only a summary can make the original basis of a decision difficult to recover.
Selective JSON Pointer lookup by itself is straightforward—it folds long-tail history not needed for the immediate decision. The core mechanism in LoopX's context delivery is compaction-cycle-bounded structured delta context : complete sources are saved first, unchanged typed subtrees are reused exactly against a verified baseline within the active context_epoch, and any host compaction or digest mismatch atomically resets to a fresh complete baseline rather than chaining dangling deltas.
-Results first: four-stage step-down, compaction-cycle deltas and task ablation
+Evidence: separate context comparisons, cycle deltas and task ablation
Four mechanisms, with separate measurement baselines
Complete capture, Progressive views, compaction-cycle structured Delta and a bounded --initial-read are composable mechanisms, but their bytes do not decrease monotonically for every input. Delta requires a verified same-cycle baseline; a new epoch, mismatch or smaller full representation uses complete delivery. The archived tutorial below measures three independent comparisons, not a same-source four-stage cascade .
Separate tutorial comparisons and 18h compaction-cycle Delta observations
A: Three archived tutorial comparisons from measurements.json: the necessary view is 5,107 / 57,014 B (9.0%); the next capture's Delta file is 2,164 / 5,543 B of its full Progressive delivery file (39.0%); manually selecting three paths from the separate 51,547 B capture.json returns 674 B (1.3% body), or 1,362 B including CLI metadata (2.6%). The 674 B is not a measured --initial-read after Progressive + Delta. These saved observations belong to the revision recorded in measurements.json; output size may change with source revision and reader paths. B1: ANN's archived 18h pairs compare Delta against selected packets, with 38.54% reduction across 46 events and 74.25% across 24 in-cycle Delta events. B2: Eight-task aggregates retain the separate 213-wake and 112-continuation denominators; their percentages cannot be chained into this tutorial. Read by question
Context delivery · Mechanisms and examples
November 1, 2026 · Updated November 12
Step down from 100% saved context: fold long-tail history (32.5% across 213 wakes), stack compaction-cycle structured deltas (−74.25% on ANN in-cycle wakes; ≈ 3.0% / 5.0% 8-task first-read entry), and reset cleanly on compaction.
Read article ↗ Read progressive views and compaction-cycle deltas with their own measurement baselines: 32.5% across 213 wakes, −74.25% on ANN in-cycle wakes, and ≈ 3.0% / 5.0% eight-task first-read entry. Compaction resets the complete baseline; these cohorts are separate comparisons.
Read article ↗
Research notes · EdgeBench and LHTB
October 16, 2026
← 全部文章 Context delivery
Agent 读上下文，也需要一套“查书”的方法 先读必要事实，在有效 compaction 周期内复用已验证的结构；连续性丢失时恢复完整基线。
LoopX · 2026 年 11 月 1 日 · 11 月 12 日更新 Agent 做长任务，资料会越来越多：原目标、后来追加的约束、试过的方案、失败的实验、当前做到哪里。每次继续都把整份材料再塞一遍，重复会不断累积；只留一段摘要，又可能找不回决定所依赖的原话。
按 JSON Pointer 渐进选读本身并不复杂，主要用来折叠当前决定暂不需要的历史长尾；LoopX 上下文交付真正的机制重心，是受 compaction 周期约束的结构化差分上下文（compaction-cycle structured delta） ：完整来源先落盘存证，在同一个已核验的 context_epoch 内精确复用未变化的结构子树、只编码本轮结构增删改；一旦宿主发生上下文压缩或基线摘要失配，立即原子切换回新的完整基线，绝不悬空叠加旧差分。
-先看数据：从 100% 逐层削减、周期内结构化差分与任务消融
+先看数据：独立上下文对照、周期内结构化差分与任务消融
四种机制，分别核对测量基线
完整捕获、Progressive 必要视图、压缩周期内结构化 Delta 与受预算保护的 --initial-read 可以组合，但不保证任意输入的字节数逐级单调递减。Delta 依赖同周期内已验证的基线；新周期、摘要失配或完整表示更小时，恢复完整交付。下图教程数据是三组独立对照，不是同源四阶实测流水线 。
独立教程对照与 18h 压缩周期内差分观测
A：measurements.json 的三组归档教程对照：必要视图为 5,107 / 57,014 B（9.0%）；下一份捕获的 Delta 文件为 2,164 / 5,543 B，相对本轮完整 Progressive 交付文件保留 39.0%；另一份 51,547 B 的 capture.json 手工选择三个路径，返回 674 B 正文（1.3%），含 CLI 元数据为 1,362 B（2.6%）。674 B 不是 Progressive＋Delta 后执行 --initial-read 的实测。这里保留的是 measurements.json 所注明源码版本的历史观测，输出大小可能随源码版本和读取路径变化。B1：ANN 归档 18h 配对以选中包为基线，全 46 轮再减 38.54%，24 个周期内增量轮再减 74.25%。B2：八题的 213 次唤醒与 112 次续跑各用原分母，不与教程数字串成一条削减链。 按问题阅读
Context delivery · 机制与实例
2026 年 11 月 1 日 · 11 月 12 日更新
从 100% 完整捕获逐层削减：按需渐进折叠长尾（213 次唤醒保留 32.5%），在有效 compaction 周期内叠加结构化差分（ANN 增量轮再减 74.25%，八题首读入口降至约 3.0% / 5.0%），压缩或失配即原子恢复完整基线。
阅读全文 ↗ 分别核对渐进视图与周期内差分的测量基线：213 次唤醒保留 32.5%，ANN 周期内增量轮再减 74.25%，八题首读入口约 3.0% / 5.0%。这些队列独立比较，压缩或失配即恢复完整基线。
阅读全文 ↗
研究札记 · EdgeBench 与 LHTB
2026 年 10 月 16 日
