← Back to all posts

12 min readUpdated 11 Aug 2026
RLMContext EngineeringPrime AgentHarness EngineeringThinking Architecture+3 more

从 Context Window 到 Thinking Architecture：RLM、Prime Agent 与 Harness Engineering 的下一阶段

Yap Wei JunSoftware Engineer · Singapore

过去几年，我们讨论 LLM 能力时，最常见的问题是：

  • Context Window 有多大？
  • 模型 benchmark 多高？
  • 参数更多是不是更聪明？
  • 1M tokens 是否就能解决长文档问题？

但 2026 年越来越清楚的一件事是：真正决定 Agent 能力的，已经不只是 Model。

更准确的单位应该是：

Model × Harness × Context Architecture × Tools × Evaluator × Learning Loop

这篇文章研究一个正在快速成形的新方向：Recursive Language Model（RLM）、Context-as-Variable、Prime Agent、Continual Harness，以及 Harness Engineering 如何进一步演变成 Thinking Architecture / Cognitive Systems Engineering。

From Context Window to Thinking Architecture

1. Context Window 不是 Comprehension Window

一个模型支持 200K、1M，甚至更大的 Context Window，并不代表它在整个长度范围里都能保持相同的理解质量。

更大的 Context Window 首先代表的是：

Storage capacity（可容纳容量）

而不是：

Guaranteed comprehension capacity（保证理解能力）

当越来越多文件、日志、代码、历史对话、工具输出、旧推理和弱相关信息进入同一个 Context，真正稀缺的不是 token 空间，而是模型的有效注意力。

这就是所谓的 Context Rot：上下文还没有塞满，表现已经可能开始下降。

所以 Context Engineering 的目标不应该是：

“尽量装更多。”

而应该是：

“在当前决策时，只给模型最小但足够的上下文。”

这可以称为 Smallest Sufficient Context。

2. RLM 最关键的改变：Context 不再是 Prompt，而是 Variable

传统 long-context 做法很直接：

Huge Document
    ↓
Tokenize everything
    ↓
Context Window
    ↓
Model
    ↓
Answer

RLM 的方向完全不同。

大型输入不直接进入模型 Context，而是先留在一个外部环境中，例如 Python session、文件系统、数据库、repository、KB 或其他可查询存储。

Huge Source X
      ↓
External Variable / Environment
      ↓
X = very large data

Root Agent Context
┌─────────────────────┐
│ Goal                │
│ Current State       │
│ Variable: X         │
│ Selected Evidence   │
└─────────────────────┘

模型知道 X 存在，但不需要一次读完整个 X。

它可以先问：

  • 有多少文件？
  • 哪些文件最大？
  • 哪些包含 authentication？
  • 哪些 section 与 revenue recognition 有关？
  • 哪些表需要 aggregate？

然后用 Python、grep、SQL、RAG、AST、metadata filter 等方式逐步探索。

这就是 Context-as-Variable。

真正重要的指标也因此发生变化：

以前问：模型一次能看多少 tokens？

现在问：Agent 能可靠地导航多少外部信息？

这可以称为 Addressable Context。

3. 一个最容易理解的类比：Context Window 是 RAM，不是 Database

把 LLM Agent 当成一台计算机，会更容易理解。

Computer ArchitectureAgent Architecture
CPUFoundation Model
CPU cache / RAMActive Context
SSD / DatabaseDocuments / Repo / KB / History
PointerVariable / Handle
QuerySearch / SQL / RAG / Python
ProcessAgent
Child processSub-agent
SchedulerHarness
Unit testsEvaluator
OS permissionCapability / Security Layer

以前很多 Agent 系统的做法像是：

“RAM 现在有 1M tokens，所以全部资料都塞进去。”

但正常软件系统不会因为 RAM 变大，就把整套数据库 load 进 RAM。

更合理的做法是：

需要什么，再 query 什么。

因此，RLM 真正推动的是一种新的 Context Architecture。

4. RLM 不是 RAG 的替代品

RAG 的典型流程是：

Question
  ↓
Embedding
  ↓
Vector Search
  ↓
Top-K Chunks
  ↓
LLM

它很有用，但 retrieval strategy 往往较早就被固定。

RLM-style agent 更像：

Goal
  ↓
Decide next operation
  ↓
Search? SQL? RAG? grep? AST? Python? Sub-agent?
  ↓
Execute
  ↓
Inspect result
  ↓
Decide next operation
  ↓
Repeat

因此正确关系不是：

RLM vs RAG

而是：

RLM + RAG + Search + SQL + Code + KB + Sub-agents

RAG 只是 Agent 可以选择的一种 context-access tool。

5. 为什么“小模型 blind”有机会赢“大模型 read everything”？

这类实验最反直觉的地方是：

  • 大模型直接读完整资料；
  • 小模型却只拿到一个 variable/handle；
  • 结果小模型在某些 long-context aggregation task 反而表现更好。

原因不是小模型突然更聪明，而是它的 information architecture 更合理。

如果一个工程师要分析十年的 ERP 数据，你不会说：

“这里是整份 database dump，全部记住，然后回答。”

你会说：

“Database 在 PostgreSQL。先看 schema，再写 query，再 aggregate，再验证。”

RLM 做的就是后者。

真正影响 reasoning quality 的，不只是：

有没有资料？

而是：

正确资料有没有在正确 reasoning step 进入当前 working set？

6. Multi-Agent 的价值之一，其实是 Context Isolation

很多人把 Multi-Agent 理解成：

“多个 AI 一起比较聪明。”

但一个更实用的价值是 Context Isolation。

例如一个复杂代码库审计：

Root Agent
├── Authentication Reviewer
├── API Reviewer
├── Test Coverage Reviewer
└── Performance Reviewer

每个 worker 只拿自己需要的目标、scope、工具和 evidence requirements。

这样做有两个好处：

  1. 独立任务可以并行；
  2. 不同领域的信息不会全部挤在一个 Context 里互相竞争。

所以 sub-agent 不只是角色扮演，它也是一种 Context Partitioning / Context Isolation mechanism。

7. 但 Recursion 不是越深越好

如果系统变成：

Agent
 └─ Agent
    └─ Agent
       └─ Agent
          └─ Agent

很容易出现 overthinking：更多 token、更多 latency、更多 conflicting conclusions，却不一定更准确。

因此 Recursion 应该被当成一个有预算的资源：

max depth
max workers
max tokens
max time
max tool calls

一个好的策略通常是：

Need recursion?
   │
   ├─ No → Direct solve
   │
   └─ Yes
       ↓
   One decomposition layer
       ↓
   Parallel specialists
       ↓
   Aggregate
       ↓
   Verify

Use the simplest architecture that can reliably solve the task.

8. Prime Agent 的第二层变化：Continual Harness

RLM 解决的是大规模 Context 如何被访问。

Prime Agent 更进一步，把 Harness 本身也变成可学习对象。

一个 Harness 可以包含：

Prompt
Sub-agents
Skills
Memory
Routing
Tool policies
Workflow hints

传统系统里，这些通常由开发者写死。

Continual Harness 的方向是：Agent 根据实际 execution trajectory 反思：

  • 什么有效？
  • 什么失败？
  • 哪个步骤浪费？
  • 哪个策略值得保存？

然后产生小幅的 harness modification。

Harness v1
   ↓
Task
   ↓
Experience
   ↓
Reflection
   ↓
Candidate Change
   ↓
Evaluation
   ↓
Harness v2

注意：这不是修改 model weights。

它是在修改 Agent 的 operating environment。

9. 自我改进真正危险的地方：Reward Hacking

Self-improvement 最危险的情况不是 Agent 没学会，而是：

它学会了错误但高分的方法。

一个典型风险流程：

Bad Action
   ↓
High Reward
   ↓
Reflection: “This works”
   ↓
Promote to Memory / Skill
   ↓
Future Agent becomes better at wrong behaviour

如果系统允许 Agent 自动修改 Skills、Memory 或 Prompt，那么 evaluator 就不再只是 QA 工具。

Evaluator 变成整个学习系统的方向盘。

因此：

Self-improvement without trustworthy evaluation = self-amplifying specification error.

中文简单讲：

Agent 不只是可能学坏，而且可能把错误方法固化成“经验”。

10. 所以 Evaluator 必须成为 Agent Architecture 的一部分

传统软件开发里，测试通常放在 implementation 后面。

自主 Agent 不一样。

Evaluator 应该进入主循环：

Objective
↓
Hypothesis
↓
Experiment
↓
Measure
↓
Evaluate
├─ Reject
├─ Rollback
└─ Keep
    ↓
Learn
    ↓
Next Experiment

可靠 evaluator 可以来自：

  • unit/integration tests；
  • database readback；
  • deterministic business rules；
  • benchmark；
  • simulator；
  • real user behaviour；
  • human approval；
  • production observation。

越快得到可靠 evaluation，Agent 就可以安全地进行越多实验。

所以未来 Agent 系统一个非常重要的瓶颈可能不是模型推理速度，而是：

Evaluator quality + evaluator latency。

11. Benchmark 也应该从 Model Leaderboard 升级成 Model × Harness Matrix

传统 benchmark 常写成：

Model A    72
Model B    75
Model C    77

然后大家会自然理解成：

Model C 比 Model A 聪明 5 分。

但 Agent benchmark 的真实系统更像：

Score = f(
  Model,
  Reasoning Effort,
  System Prompt,
  Harness,
  Context Policy,
  Retrieval,
  Tools,
  Memory,
  Sub-agents,
  Retry Policy,
  Test-time Compute,
  Evaluator
)

因此未来更合理的 benchmark 应该明确记录：

Model × Harness × Runtime configuration

而不是把全部结果归因给模型名字。

这也解释了为什么同一套 weights 在不同 harness 中可以出现非常大的 observable capability difference。

12. Harness Engineering 的下一阶段：Thinking Architecture

我会把 Harness Engineering 定义为：

Designing the causal environment in which model intelligence is converted into reliable action.

中文：

设计模型如何看、如何想、如何行动、如何验证、如何学习的因果环境。

再往上一层，就是 Thinking Architecture。

Thinking Architecture 关注：

Goal Framing
↓
Context Assembly
↓
Problem Decomposition
↓
Reasoning Strategy
↓
Tool / Worker Selection
↓
Decision
↓
Verification Contract
↓
Action
↓
Evidence
↓
Reflection / Learning

这已经不只是 Prompt Engineering。

它更接近一种 Cognitive Systems Engineering（认知系统工程）。

13. 一个更完整的 AI Agent 六层架构

Thinking Architecture for Long-Context Agents

Layer 1 — Model Layer

Foundation Model 提供 reasoning capability。

Layer 2 — Working Context Layer

只保留：

  • 当前目标；
  • 当前状态；
  • 当前需要的 evidence；
  • 当前决策所需的规则。

Layer 3 — External Variable Layer

大型信息保持在外部：

repo://
kb://
db://
file://
session://
result://

Layer 4 — Recursive Compute Layer

Agent 可调用：

Search
SQL
RAG
Python / JavaScript
Graph traversal
Sub-agents
Map-Reduce

Layer 5 — Continual Harness Layer

可以学习：

Memory
Skills
Workflow hints
Sub-agent definitions
Routing strategy

但必须经过 evaluation、versioning 和 rollback。

Layer 6 — Control & Evaluation Layer

负责：

Permissions
Sandbox
Budget
Approval
Tests
Evaluator
Audit
Rollback

这是整个系统最重要的安全边界。

14. MCP-Native RLM Architecture

如果把这些原则放进 MCP / Agent Runtime，一个很自然的方向是：

Root Agent
│
├── Goal / Current State
│
├── Context Router
│
├── Variable Registry
│     ├── repo://...
│     ├── kb://...
│     ├── db://...
│     ├── file://...
│     └── session://...
│
├── Query / Compute Runtime
│     ├── SQL
│     ├── Search
│     ├── RAG
│     ├── Code
│     └── deterministic tools
│
├── Recursive Workers
│
├── Evidence Store
│
├── Evaluator
│
└── Learning Gate
      ├── candidate memory
      ├── candidate skill
      ├── eval
      ├── approve/promote
      └── rollback

Tool result 也不应该永远返回巨大 payload。

更好的 contract 可以是：

{
  "handle": "result://123",
  "summary": "...",
  "metadata": {},
  "evidence": [],
  "nextActions": []
}

Root Agent 想继续检查时才：

inspect(handle)
query(handle)
delegate(handle, task)

这可以有效减少 tool-output-driven context rot。

15. 从 Experience 到 Skill：Agent 真正应该怎样“学习”

一个危险的做法是：

成功一次 → 直接写入永久 Skill。

更合理的流程是：

Raw Event
   ↓
Experience
   ↓
Lesson
   ↓
General Principle
   ↓
Candidate Procedure
   ↓
Evaluation
   ↓
Reusable Skill

例如：

Raw Experience

第二层 recursion 在某次任务里极度增加 latency。

不能直接变成：

“永远不准 depth 2。”

应该先提炼成：

deeper recursion can create overthinking and high cost。

再形成 Skill：

在递归前评估 complexity，默认 depth 0–1；只有在独立 evaluator 能证明进一步 decomposition 有收益时才增加 depth。

这才叫真正的 Experience Learning。

16. 最值得保存的 12 个 Agent Skills

从这一整套研究中，我认为最值得产品化的 Skills 是：

  1. agent:recursive-context-navigation
  2. agent:context-as-variable
  3. agent:adaptive-context-router
  4. agent:smallest-sufficient-context
  5. agent:recursive-task-decomposition
  6. agent:parallel-context-workers
  7. agent:evidence-preserving-synthesis
  8. agent:harness-refinement
  9. agent:reward-hacking-audit
  10. agent:recursion-budget-controller
  11. agent:external-state-navigation
  12. agent:model-harness-benchmark

这些 Skill 的目的不是让 Agent 多几个 Prompt，而是把经验变成可验证、可复用的 procedure。

17. 五条最重要的结论

1. Context 是一种工程资源

不要把 Context Window 当仓库。

把它当 working memory。

2. 大型信息应该 externalize

真正优秀的 Agent 不是：

read everything

而是：

know how to find everything。

3. Model intelligence 与 System intelligence 不一样

Model ≠ Agent

Agent 是完整的问题解决系统。

4. Self-improvement 必须绑定 Evaluator

否则：

self-improvement
→ self-amplification of mistakes

5. Harness Engineering 正在变成 Cognitive Systems Engineering

未来真正重要的问题不是：

“这个 Prompt 怎样写？”

而是：

“我们怎样设计一个让智能模型能够可靠地观察、思考、搜索、行动、验证和学习的认知环境？”

结语

RLM 最值得记住的并不是“可以处理千万级 tokens”。

真正重要的是它提出了一个架构上的重新定义：

Context 不必全部存在模型内部。

Prime Agent 与 Continual Harness 又把这个方向往前推进了一步：

Harness 本身也可以成为可学习、可迭代的系统组件。

但一旦 Agent 可以修改自己的 Memory、Skills、Prompt 和 Sub-agent definitions，Evaluator、安全边界、版本控制和 rollback 就必须升级成第一等公民。

最后，我会用这句话总结整个方向：

Intelligence is no longer only inside the model. It emerges from the model's interaction with an engineered cognitive environment.

中文：

智能不再只是存在于模型参数中，而是模型与上下文、工具、记忆、环境、子智能体和验证器共同组成的认知系统所产生的能力。

未来真正值得竞争的，不只是更大的 Model。

而是更好的 Thinking Architecture。

← Back to all posts