diff --git a/README.md b/README.md
index b07abd9..6cdac68 100644
--- a/README.md
+++ b/README.md
@@ -1,80 +1,79 @@
# NextAgent — 认知解耦智能体架构
-NextAgent 是一套颠覆传统单一 LLM 模式的**认知解耦智能体架构**。通过模拟人脑的模块化分工，将认知、记忆、推理与表达分离为独立子网，子网间通过**自定义张量协议**通信，从根本上解决大模型的**幻觉**问题与**效率瓶颈**。
+NextAgent 是一套颠覆传统单一 LLM 模式的**认知解耦智能体架构**。通过模拟人脑的模块化分工，将认知、记忆、推理与表达分离为独立子网，子网间通过**统一张量协议**通信，从根本上解决大模型的**幻觉**问题与**效率瓶颈**。
## 核心架构
```
-┌─────────────────────────────────────────────────────────────────────┐
-│ 应用层 (CLI/API/SDK) │
-└──────────────────────────────┬──────────────────────────────────────┘
+ ┌──────────────┐
+ │ 用户 │
+ │ (输入/输出) │
+ └──────┬───────┘
│
-┌──────────────────────────────▼──────────────────────────────────────┐
-│ 调度 Core (前额叶皮层) │
-│ 启发式调度 · 逻辑判断 · 任务解析 · 记忆聚合 │
-│ ┌──────────────┐ ┌──────────────┐ ┌────────────────────────┐ │
-│ │ 任务解析器 │ │ 调度策略引擎 │ │ 记忆聚合器 │ │
-│ │ 拆解用户意图 │ │ 启发式调度规则 │ │ 汇总子网结果→记忆参数包 │ │
-│ └──────────────┘ └──────────────┘ └────────────────────────┘ │
-└──────┬──────┬──────┬──────┬──────┬──────┬──────┬───────────────────┘
- │ │ │ │ │ │ │
- │ └──张量通信层──┐ │ │ │
- │ (Standard Tensor Protocol) │ │
- ▼ ▼ ▼ ▼
-┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐
-│ 路由与压缩 │ ←──→ │ 记忆子网 │ │ 逻辑链路 │ │ LLM 子网 │
-│(感觉中枢) │ 张 量 │(海马体/皮层)│ │追踪神经网络│ │(布洛卡区) │
-│ │ │ │ │ (推理回路) │ │ │
-│ 多模态 │ │ 图数据库 │ │ 逻辑验证 │ │ 自然语言→用户 │
-│ 特征提取 │ │ 向量数据库 │ │ 自我修正 │ │ 表达张量→Core │
-│ 信息压缩 │ │ 文本记忆 │ │ 路径重规划 │ │ │
-└──────────┘ └──────────┘ └──────────┘ └──────────┘
- │
- ▼
- ┌────────────────────┐
- │ 存储层 (冷区存储) │
- │ 原始数据 · 索引 │
- └────────────────────┘
+ ┌──────────▼──────────┐
+ │ 外部输入/输出 │
+ │ (唯一接入外部路径) │
+ └──────┬──────┬───────┘
+ │ │
+ ┌──────▼──┐ ┌─▼────────┐
+ │ 路由与 │ │ LLM │
+ │ 压缩子网 │ │ 子网 │
+ │(唯一输入) │ │(唯一输出) │
+ │ 多模态 │ │ 自然语言 │
+ │ 特征提取 │ │ 给用户 │
+ │ 标签张量 │ │ │
+ └──────┬──┘ └────┬──────┘
+ │ │
+ │ 张量通信层 │
+ │ (内部通信) │
+ ▼ ▼
+ ┌──────────────────────────┐
+ │ 调度 Core (内部层) │
+ │ 启发式调度 · 内部分发 │
+ │ │
+ │ ┌──────────┐ ┌────────┐ │
+ │ │ 记忆子网 │ │ 逻辑子网 │ │
+ │ │(唯一记忆) │ │(推理回路)│ │
+ │ │ 自治读写 │ │ 验证重规│ │
+ │ │ 图DB/向量 │ │ 划/错误│ │
+ │ │ /文本 │ │ 追溯 │ │
+ │ └──────────┘ └────────┘ │
+ └──────────────────────────┘
```
+### 边界规则
+
+| 方向 | 路径 | 说明 |
+|------|------|------|
+| **输入** | 用户 → 路由与压缩子网（唯一） | 所有图像/文本/语音必须经过路由子网，且仅此一路 |
+| **输出** | LLM 子网 → 用户（唯一） | 当前仅 LLM 输出自然语言，可扩展图像/视频输出子网 |
+| **内部** | 调度 Core + 子网 | Core 是内部调度层，不直接与用户交互 |
+| **记忆** | 记忆子网（自治） | 唯一记忆模块。Core 仅传递查询张量+新信息张量，如何更新/删除/修改由记忆子网自行决策 |
+
### Mermaid 架构图
```mermaid
graph TB
- User["用户"] -->|"自然语言/多模态输入"| Core["调度 Core
(前额叶皮层)"]
+ User["用户"] -->|"图像/文本/语音"| RCN["路由与压缩子网
(唯一输入路径)"]
- subgraph TensorLayer ["张量通信层 (Standard Tensor Protocol)"]
- direction LR
- TE["编码层
Encoder: 内部张量→标准张量"]
- TD["解码层
Decoder: 标准张量→内部张量"]
+ subgraph Internal ["系统内部"]
+ direction TB
+ Core["调度 Core
(内部调度层)"]
+ MEM["记忆子网
(唯一记忆模块·自治)"]
+ LTC["逻辑链路追踪子网
(推理回路)"]
end
- subgraph Subnets ["四大子网"]
- RCN["路由与压缩子网
(感觉中枢)
多模态→标准张量"]
- MEM["记忆子网
(海马体与皮层)
图DB+向量DB+文本"]
- LTC["逻辑链路追踪
神经网络
(推理回路)"]
- LLM["LLM 子网
(布洛卡区/表达核)"]
- end
-
- Cold["冷区存储
原始数据"]
-
- Core -->|"启发式调度"| RCN
- Core -->|"启发式调度"| MEM
- Core -->|"启发式调度"| LTC
- Core -->|"启发式调度|张量"| LLM
-
- RCN -.->|"标准张量"| Core
- MEM -.->|"记忆检索张量"| Core
- LTC -.->|"推理路径张量"| Core
- LLM -.->|"表达验证张量"| Core
-
+ RCN -->|"标签张量"| Core
+ Core -->|"查询张量+新信息"| MEM
+ MEM -->|"记忆张量"| Core
+ Core -->|"推理请求"| LTC
+ LTC -->|"推理路径张量"| Core
+ Core -->|"推理路径"| LLM["LLM 子网
(唯一输出路径)"]
LLM -->|"自然语言"| User
+ LLM -.->|"表达验证张量"| Core
- Core -->|"记忆更新参数张量"| MEM
- MEM -->|"读写"| Cold
-
- RCN -.-> Cold
- LTC -.-> Cold
+ RCN -.->|"滑动窗口保留原始数据"| Raw["临时原始数据"]
+ Core -.->|"一轮结束后调度处理"| RCN
```
## 通信机制：统一张量协议 (Unified Tensor Protocol)
@@ -85,7 +84,7 @@ graph TB
#### 适配器模式（编解码层）
-每个子网通过一个**编解码层（Codec Layer）**与外部通信，负责将子网内部的私有数据格式（如 PyTorch Tensor、MindSpore Tensor 或自定义结构）转换为统一的标准张量格式：
+每个子网通过一个**编解码层（Codec Layer）**与外部通信，负责将子网内部的私有数据格式（如 PyTorch Tensor、自定义结构等）转换为统一的标准张量格式：
```
┌─────────────┐ ┌───────────────────┐ ┌─────────────┐
@@ -100,7 +99,7 @@ graph TB
└─────────────┘ └───────────────────┘ └─────────────┘
```
-**作用**：屏蔽不同子网/框架的实现差异。新的子网只要实现对应的编解码器（Adapter），就能接入系统，无需修改调度 Core 或其他已有模块的代码。
+**作用**：屏蔽不同子网/框架的实现差异。新的子网只要实现编解码适配器，就能接入系统，无需修改调度 Core 或其他已有模块。
#### 门面模式（统一张量接口）
@@ -131,9 +130,9 @@ interface TensorBus:
### 核心优势
#### 动态并网与即插即用
-- 新的子网只需实现编解码器即可向 Core 注册，实现**运行时热插拔**
+- 新的子网只需实现编解码适配器即可向 Core 注册，支持**运行时热插拔**
- 各子网独立迭代算法，接口不变即不影响系统稳定性
-- 支持运行时动态创建/销毁子网
+- 支持运行时根据需求动态创建/销毁子网
#### 零拷贝（Zero-Copy）
在支持分布式能力的系统上，张量可通过**内核旁路技术**直接在设备间传递内存地址，避免将数据从 NPU/GPU 搬回 CPU 再打包的昂贵序列化开销。
@@ -142,26 +141,28 @@ interface TensorBus:
张量是 NPU/GPU 的**原生计算单元**，协议允许数据在设备内存池中直接流转，无需格式转换，大幅降低延迟和 CPU 占用。
#### 高数据保真度
-相比于文本或 JSON 协议，张量能**无损传递高维特征图、注意力权重矩阵**等复杂数值结构，确保传递的是完整的
+相比于文本或 JSON 协议，张量能**无损传递高维特征图、注意力权重矩阵**等复杂数值结构，确保传递的是完整的"思维向量"而非降维后的符号化描述。
## 调度方式：启发式调度
-Core 的调度不是线性流式的。每次收到数据包后：
+Core 的调度是启发式的，非流式管线。每次收到数据包后动态决策：
-1. 解析输入 → 判断任务类型
-2. 调用记忆子网检索上下文
-3. 根据记忆结果决定：是否再次调用路由提取输入 → 送逻辑推理 → 再查记忆 → ...
-4. 反复、多方式调用子网，逐步收敛到最终结果
-5. 将所有子网结果聚合，打包为记忆更新参数包 → 送记忆子网更新
+1. 路由子网处理输入 → 生成标签张量 → 交给 Core
+2. Core 根据标签判断任务类型，调用记忆子网检索上下文
+3. 根据记忆结果决定下一步——可能再次调路由提取、送逻辑推理、再查记忆……
+4. 反复、多方式调用子网，逐步收敛
+5. 将子网结果聚合 → 交记忆子网自主更新
+6. 本轮结束后，Core 再调度路由子网对暂存的原始数据进行处理（标签生成、压缩、归档）
-## 四大子网概述
+## 子网职责
-| 子网 | 类比人脑 | 核心职责 | 通信方式 |
-|------|---------|---------|---------|
-| **路由与压缩子网** | 感觉中枢 | 多模态特征提取、信息压缩、引用张量生成 | 标准张量 |
-| **记忆子网** | 海马体与皮层 | 图数据库+向量数据库+文本三级记忆存储与检索 | 记忆检索张量 / 记忆更新参数张量 |
-| **逻辑链路追踪神经网络** | 推理回路 | 逻辑验证、错误追溯、路径重规划、自我修正 | 推理路径张量 |
-| **LLM 子网** | 布洛卡区/表达核 | 结构化→自然语言（给用户）+ 表达验证张量（给Core） | 表达验证张量 |
+| 子网 | 角色 | 核心职责 |
+|------|------|---------|
+| **路由与压缩子网** | 🚪 唯一输入路径 | 处理多模态输入，生成标签张量，滑动窗口暂存原始数据 |
+| **记忆子网** | 🧠 唯一记忆模块（自治） | 独立管理图数据库+向量数据库+文本三级存储，自行决策如何更新/删除/修改 |
+| **逻辑链路追踪神经网络** | 🔗 推理回路 | 逻辑验证、错误追溯、路径重规划、自我修正 |
+| **LLM 子网** | 📤 唯一输出路径 | 结构化→自然语言给用户 + 表达验证张量给Core |
+| **调度 Core** | 🎯 内部调度层 | 启发式统筹调度，不直接与用户交互 |
## 设计哲学
@@ -169,23 +170,28 @@ Core 的调度不是线性流式的。每次收到数据包后：
传统单一 LLM 的幻觉根源：**知识存储与语言表达在同一网络中耦合**。NextAgent 将两者解耦：
-- **记忆子网** 负责存储和检索事实知识（图数据库 + 向量数据库）
-- **逻辑推理子网** 负责验证推理链的正确性
-- **LLM 子网** 只负责将结构化信息转换为自然语言，**从不"猜测"事实**
-- Core 收到 LLM 返回的**表达验证张量**来判断 LLM 是否正确表达了推理结果
+- **记忆子网** 独立负责知识存储与检索
+- **逻辑推理子网** 独立负责推理验证
+- **LLM 子网** 只负责语言表达，**从不"猜测"事实**
+- Core 通过分析 LLM 返回的表达验证张量来判断输出正确性
-### ⚡ 效率与灵活性 — 冷热数据分离
+### 🔒 严格的输入/输出边界
-- **热区（张量通信层）**：子网间传递轻量级张量，仅携带元数据和向量
-- **温区（图数据库）**：结构化知识图谱，支持 Cypher 查询
-- **冷区（原始存储）**：完整原始数据，按需拉取
+```
+输入 → [路由子网] → [Core+记忆+逻辑] → [LLM] → 输出
+ 唯一入口 内部 唯一出口
+```
-### 🎯 LLM 下位化
+- 路由子网是**唯一**与外部输入交互的组件
+- LLM 子网是**唯一**与外部输出交互的组件
+- Core 是**纯内部层**，不暴露给用户
+- 记忆子网是**唯一记忆模块**，Core 不越权直接操作记忆
-LLM 不再是"全知怪物"，而是降级为专业的**语言生成引擎**：
-- 知识来源：记忆子网 → 不依赖 LLM 自身参数知识
-- 逻辑来源：推理子网 → LLM 不负责推理
-- 输入：结构化推理路径张量 → 不是原始问题
+### ⚡ 效率与灵活性
+
+- **张量通信**：子网间传递轻量级张量
+- **滑动窗口**：路由子网暂存原始数据，一轮结束后再处理
+- **记忆自治**：记忆子网自主决定存储策略
## 快速开始
@@ -220,31 +226,31 @@ NextAgent/
│ │ └── memory_aggregator.py # 记忆聚合器
│ ├── protocol/ # 张量协议层
│ │ ├── tensor_schema.py # 标准张量定义
-│ │ ├── encoder.py # 编码层
-│ │ └── decoder.py # 解码层
-│ ├── subnets/ # 四大子网实现
-│ │ ├── routing_compression/ # 路由与压缩子网
+│ │ ├── encoder.py # 编码器基类
+│ │ └── decoder.py # 解码器基类
+│ ├── subnets/ # 子网实现
+│ │ ├── routing_compression/ # 路由与压缩子网（唯一输入）
│ │ ├── memory/ # 记忆子网（图DB+向量DB+文本）
│ │ ├── logic_trace/ # 逻辑链路追踪子网
-│ │ └── llm_expression/ # LLM 表达子网
+│ │ └── llm_expression/ # LLM 表达子网（唯一输出）
│ └── storage/ # 存储层
│ ├── graph_db/ # Neo4j 图数据库客户端
│ ├── vector_db/ # 向量数据库客户端
│ └── text_store/ # 文本记忆存储
-├── tests/ # 测试套件
-├── config/ # 配置文件
-└── requirements.txt # 依赖
+├── tests/
+├── config/
+└── requirements.txt
```
## 文档索引
| 文档 | 内容 |
|------|------|
-| [架构总览](docs/architecture-overview.md) | 整体设计、张量协议、启发式调度、记忆更新机制 |
-| [路由与压缩子网](docs/routing-compression-subnet.md) | 多模态编码、压缩训练、张量化训练 |
-| [记忆子网](docs/memory-subnet.md) | 三级存储、图数据库设计、训练计划（参考 TrulyMEM） |
+| [架构总览](docs/architecture-overview.md) | 整体设计、张量协议、启发式调度、边界规则 |
+| [路由与压缩子网](docs/routing-compression-subnet.md) | 唯一输入路径、滑动窗口、标签张量、两阶段处理 |
+| [记忆子网](docs/memory-subnet.md) | 唯一记忆模块、自治读写、三级存储（参考 TrulyMEM）|
| [逻辑链路追踪神经网络](docs/logic-trace-subnet.md) | RLHF+PRM、MCTS、自我修正训练 |
-| [LLM 子网](docs/llm-subnet.md) | 双输出通道、SFT/RLHF 微调、表达验证训练 |
+| [LLM 子网](docs/llm-subnet.md) | 唯一输出路径、双输出通道、表达验证训练 |
---
diff --git a/docs/architecture-overview.md b/docs/architecture-overview.md
index 71fa0a3..87d1732 100644
--- a/docs/architecture-overview.md
+++ b/docs/architecture-overview.md
@@ -7,48 +7,52 @@ NextAgent 采用**认知解耦架构（Cognitive Decoupled Architecture）**，
### 设计原则
- **单一职责**：每个子网只负责一种认知功能，降低复杂度
-- **张量通信**：子网间不传递自然语言，通过标准张量协议交换信息
-- **冷热分离**：活跃数据以张量形式在子网间传递，原始数据存储在冷区
+- **张量通信**：子网间不传递自然语言，通过统一张量协议交换信息
+- **边界隔离**：路由子网是唯一输入路径，LLM 是唯一输出路径，Core 为纯内部层
+- **记忆自治**：记忆子网是唯一记忆模块，Core 仅传递查询和新信息张量，读写操作由记忆子网自行决策
+- **冷热分离**：活跃数据以张量形式在子网间传递，原始数据暂存于路由子网的滑动窗口，一轮结束后再处理
- **启发式调度**：Core 根据上下文动态决定调用顺序和方式，非线性执行
- **LLM 下位化**：LLM 降级为专业语言生成引擎，知识与逻辑均外置
-### 架构分层
+### 边界隔离
```
-┌─────────────────────────────────────────────────────────────────┐
-│ 应用层 │
-│ CLI / API / SDK / Web Interface / 第三方集成 │
-└───────────────────────┬─────────────────────────────────────────┘
- │
-┌───────────────────────▼─────────────────────────────────────────┐
-│ 调度 Core（前额叶皮层） │
-│ ┌──────────────┐ ┌──────────────┐ ┌────────────────────────┐ │
-│ │ 任务解析器 │ │ 调度策略引擎 │ │ 记忆聚合器 │ │
-│ │ 拆解用户意图 │ │ 启发式调度规则 │ │ 汇总子网结果→记忆参数包 │ │
-│ └──────────────┘ └──────────────┘ └────────────────────────┘ │
-└──────┬──────┬──────┬──────┬──────┬──────┬───────────────────────┘
- │ │ │ │ │ │
- ▼ ▼ ▼ ▼ ▼ ▼
-┌─────────────────────────────────────────────────────────────────┐
-│ 张量通信层（核心创新） │
-│ ┌────────────────────────────────────────────────────────┐ │
-│ │ 标准张量 (Standard Tensor) │ │
-│ │ Header: 源/目标/类型/时间戳 | Payload: 数据 | Sig: 校验 │ │
-│ │ 各子网通过 编码层(Encoder) → 标准张量 → 解码层(Decoder) │ │
-│ └────────────────────────────────────────────────────────┘ │
-└──────┬──────┬──────┬──────┬──────┬──────┬───────────────────────┘
- │ │ │ │ │ │
-┌──────▼──┐ ┌─▼──────┐ ┌─▼──────┐ ┌─▼──────┐ ┌─▼────────────────┐
-│ 路由与 │ │ 记忆 │ │ 逻辑链路 │ │ LLM │ │ 存储层 │
-│ 压缩子网 │ │ 子网 │ │ 追踪子网 │ │ 子网 │ │ ┌────────────┐ │
-│(感觉中枢) │ │(海马体) │ │(推理回路)│ │(布洛卡) │ │ │ Neo4j 图DB │ │
-│ │ │ │ │ │ │ │ │ │ 向量数据库 │ │
-│ ViT │ │ Entity │ │ MCTS │ │ SFT │ │ │ 文本存储 │ │
-│ Wav2Vec │ │ 三元组 │ │ PRM │ │ RLHF │ │ └────────────┘ │
-│ BERT │ │ Cypher │ │ 路径追踪 │ │ 双输出 │ │ │
-└──────────┘ └─────────┘ └─────────┘ └─────────┘ └────────────────┘
+ ┌──────────────┐
+ │ 用户 │
+ └──────┬───────┘
+ │
+ ┌────────────▼────────────┐
+ │ 外部输入/输出面 │
+ └──────┬──────┬───────────┘
+ │ │
+ ┌──────▼──┐ ┌─▼──────────┐
+ │ 路由与 │ │ LLM 子网 │
+ │ 压缩子网 │ │(唯一输出路径)│
+ │(唯一输入 │ │ 自然语言→ │
+ │ 路径) │ │ 用户 │
+ │ 标签张量 │ │ 表达张量→ │
+ │ →Core │ │ Core │
+ └──────┬──┘ └────┬───────┘
+ │ │
+ │ 张量通信层 │
+ ▼ ▼
+ ┌────────────────────────┐
+ │ 调度 Core (内部层) │
+ │ │
+ │ ┌────────┐ ┌────────┐ │
+ │ │ 记忆子网 │ │逻辑子网│ │
+ │ │(自治) │ │(推理) │ │
+ │ └────────┘ └────────┘ │
+ └────────────────────────┘
```
+| 方向 | 路径 | 约束 |
+|------|------|------|
+| **输入** | 用户 → 路由与压缩子网（唯一） | 所有外部输入必须且只能经过此路径 |
+| **输出** | LLM 子网 → 用户（唯一） | 当前仅 LLM；可扩展图像/视频输出子网 |
+| **内部** | Core + 内部子网 | Core 不直接暴露给用户 |
+| **记忆** | 记忆子网（自治） | Core 仅传递查询张量+新信息张量；记忆子网自行决策全部读写操作 |
+
## 统一张量协议（Unified Tensor Protocol）
这是 NextAgent 的核心创新——子网间通过标准化的张量格式通信，不传递自然语言。该协议基于**适配器模式（Adapter Pattern）**和**门面模式（Facade Pattern）**设计，旨在解决多子网架构中的模块异构性与通信效率问题。
@@ -161,100 +165,118 @@ class TensorBus:
### 核心职责
-1. **任务解析**：接收用户输入，拆解为可执行的子任务序列
+1. **接收路由标签张量**：接收路由与压缩子网处理后的标签张量，而非直接接收用户输入
2. **启发式调度决策**：根据上下文动态决定调用子网的方式和顺序，非线性
3. **子网结果聚合**：收集各子网返回的张量，综合分析
4. **表达验证**：接收 LLM 返回的表达验证张量，判断输出质量
-5. **记忆聚合**：汇总各子网结果，打包为记忆更新参数包张量
+5. **记忆中转**：将本轮新的信息与查询意图封装为张量传递给记忆子网（不越权处理记忆）
6. **冲突解决**：当子网返回矛盾结果时，启动仲裁机制
### Core 内部组件
| 组件 | 职责 |
|------|------|
-| **任务解析器 (Task Parser)** | 接收输入，拆解任务图 |
+| **任务解析器 (Task Parser)** | 接收路由标签张量，拆解任务图 |
| **调度策略引擎 (Scheduler)** | 维护启发式调度规则，决定下一步调哪个子网 |
| **上下文管理器 (Context Manager)** | 维护会话状态和中间结果 |
| **表达验证器 (Expression Verifier)** | 接收 LLM 的表达验证张量，判断正确性 |
-| **记忆聚合器 (Memory Aggregator)** | 汇总多子网结果，打包为记忆更新参数张量 |
+| **记忆中转器 (Memory Broker)** | 将本轮新信息和查询意图打包为张量传递给记忆子网；不越权处理记忆内容 |
### 启发式调度流程（非流式！）
-Core 的调度不是线性管线式的。每次收到数据包后，会基于当前状态动态决策：
+Core 的调度不是线性管线式的。每次收到路由子网的标签张量后，会基于当前状态动态决策：
```
-输入到达
+路由子网处理输入 → 生成标签张量
│
▼
-┌──────────────────┐
-│ 1. 任务解析 │ ── 拆解用户意图，生成初始任务图
-└──────┬───────────┘
+标签张量到达 Core
+ │
+ ▼
+┌─────────────────────┐
+│ 1. 任务解析 │ ── 根据标签拆解用户意图，生成初始任务图
+└──────┬──────────────┘
│
▼
-┌──────────────────┐
-│ 2. 调用记忆子网 │ ── "之前聊过这个吗？"
-│ 查询上下文 │ 第一次记忆检索
-└──────┬───────────┘
+┌─────────────────────┐
+│ 2. 向记忆子网查询 │ ── Core 传入：查询张量 + 新信息标签张量
+│ (自治查询) │ 记忆子网自行检索，返回记忆张量
+└──────┬──────────────┘
│
▼
-┌──────────────────┐
-│ 3. 启发式判断 │ ← 根据记忆结果决定下一步
-│ │ 有相关记忆？→ 送逻辑推理 + 可能再次调路由提取更多信息
-│ │ 无相关记忆？→ 调路由子网全面提取输入特征
-│ │ 输入不清晰？→ 再次调路由子网重新提取特征
-│ │ 需要更多背景？→ 再次调记忆子网深度检索
-│ │ 歧义？→ 多次调不同子网交叉验证
-└──────┬───────────┘
+┌─────────────────────┐
+│ 3. 启发式判断 │ ← 根据记忆结果决定下一步
+│ │ 有相关记忆？→ 送逻辑推理
+│ │ 需要更多输入？→ 调路由提取（滑动窗口）
+│ │ 更深入记忆？→ 再传新查询给记忆子网
+│ │ 模糊？→ 多次调不同子网交叉验证
+└──────┬──────────────┘
│
▼
-┌──────────────────┐
-│ 4. 循环调度 │ ── 反复、多方式调用子网
-│ (可能多轮) │ 记忆→推理→记忆→路由→推理→...
-└──────┬───────────┘
+┌─────────────────────┐
+│ 4. 循环调度 │ ── 反复、多方式调用子网
+│ (可能多轮) │ 记忆→推理→路由→记忆→…
+└──────┬──────────────┘
│
▼
-┌──────────────────┐
-│ 5. 送 LLM 表达 │ ── 推理结果足够可靠后，送 LLM 生成自然语言
-│ + 接收验证张量 │ Core 收到表达验证张量 → 判断正确性
-└──────┬───────────┘
+┌──────────────────────────┐
+│ 5. 送 LLM 表达 │ ── 推理结果可靠后，送推理路径张量
+│ + 接收验证张量 │ LLM → 自然语言给用户
+│ │ LLM → 表达验证张量给 Core
+│ │ Core 判断正确性
+└──────┬───────────────────┘
│
▼
-┌──────────────────┐
-│ 6. 记忆聚合更新 │ ── 汇总本轮回所有子网结果
-│ │ 打包为 memory_update 张量
-│ │ 送记忆子网执行存储
-└──────────────────┘
+┌──────────────────────────┐
+│ 6. 记忆更新（传递信息） │ ── Core 将新信息+验证结果打包
+│ │ 传递给记忆子网
+│ │ 记忆子网自行决定写入/更新/删除
+└──────┬───────────────────┘
+ │
+ ▼
+┌──────────────────────────┐
+│ 7. 调度路由处理残留数据 │ ── 本轮结束后 Core 通知路由子网
+│ │ 处理滑动窗口中的原始数据
+│ │ （压缩、标签索引、归档/丢弃）
+└──────────────────────────┘
```
#### 启发式调度算法（简化伪代码）
```
-function heuristic_process(input):
- # 1. 任务解析
- task_graph = parse_task(input)
+function heuristic_process(raw_input):
+ # 0. 路由子网先行处理输入（唯一输入路径）
+ label_tensor = routing_subnet.process(raw_input)
+ # 路由子网持有原始数据的滑动窗口
- # 2. 初始化调度状态
+ # 1. 初始化调度状态
state = {
- "task": task_graph,
+ "label": label_tensor,
"context": {},
"iteration": 0,
"confidence": 0.0,
- "pending_signals": []
+ "verified": False
}
- # 3. 启发式调度循环
- while not is_complete(state) and state.iteration < MAX_ITERATIONS:
+ # 2. 启发式调度循环
+ while not state.verified and state.iteration < MAX_ITERATIONS:
next_action = scheduler.decide_next_action(state)
- # decide_next_action 根据当前状态、历史结果、置信度动态决定
- # 可能调用：记忆查询、路由提取、逻辑推理、表达生成、记忆更新
+ # decide_next_action 动态决定下一步
if next_action.type == "memory_retrieve":
- memory_tensor = memory_subnet.retrieve(next_action.params)
+ # Core 仅传递查询张量 + 新信息张量给记忆子网
+ memory_tensor = memory_subnet.retrieve({
+ "query": next_action.params,
+ "new_info": state.label
+ })
+ # 记忆子网自行检索，自行决定关联逻辑
state.context["memory"] = memory_tensor
- state.pending_signals.append(memory_tensor)
elif next_action.type == "routing_extract":
- ref_tensor = routing_subnet.extract(next_action.params)
+ # 从路由子网的滑动窗口中获取更丰富的特征
+ ref_tensor = routing_subnet.extract_from_window(
+ next_action.params
+ )
state.context["refined_input"] = ref_tensor
elif next_action.type == "logical_reason":
@@ -264,17 +286,23 @@ function heuristic_process(input):
elif next_action.type == "llm_express":
verify_tensor = llm_subnet.express(state.context)
- # verify_tensor 包含语义编码和置信度，非自然语言
state.context["verification"] = verify_tensor
- # 如果验证通过，置完成标记
if verify_tensor.metadata.confidence > THRESHOLD:
state.verified = True
- # 4. 记忆聚合更新
- update_tensor = memory_aggregator.build_update_tensor(state)
- memory_subnet.store(update_tensor)
+ # 3. 将本轮新信息 + 结果交给记忆子网（自治更新）
+ memory_subnet.update({
+ "session_info": state.context,
+ "new_data": state.label
+ })
+ # 记忆子网自行决定如何写入/更新/删除
+
+ # 4. 通知路由子网处理滑动窗口中的残留数据
+ routing_subnet.flush_window({
+ "processed": True,
+ "archive": use_relevant
+ })
- # 5. LLM 的自然语言已直接输出给用户
return state.verified
```
@@ -306,35 +334,54 @@ LLM 子网的输出有两个去向，这是核心设计之一：
## 记忆更新机制
-记忆更新不是由子网单独完成，而是由 Core 聚合多子网结果后统一触发：
+记忆子网是整个设计中**唯一与记忆内容交互的模块**。Core 不自作主张处理记忆，只负责将信息传递给记忆子网，由记忆子网自行决定如何更新、删除和修改。
+
+### 信息传递流程
```
-┌──────────┐ 路由子网结果张量
-│ 路由 │ ─────────────┐
-└──────────┘ │
- ├──┐
-┌──────────┐ 推理子网结果张量 │ │
-│ 推理 │ ─────────────┤ │
-└──────────┘ │ │
- │ ├── Core 记忆聚合器 ── 打包 ──→ 记忆更新参数张量
-┌──────────┐ 记忆子网交互结果 │ │ (MemoryAggregator) (MemoryUpdateTensor)
-│ 记忆 │ ─────────────┤ │
-└──────────┘ │ │
- ├──┘
-┌──────────┐ Core 内部状态 │
-│ Core │ ─────────────┘
-└──────────┘
+本轮所有子网的结果
+ │
+ ▼
+┌──────────────────────────────┐
+│ Core 记忆中转器 (Memory Broker) │
+│ (不包含任何记忆处理逻辑) │
+│ │
+│ Core 只做两件事： │
+│ 1. 封装查询张量 → 传给记忆子网 │
+│ 2. 封装新信息张量 → 传给记忆子网 │
+└──────────┬───────────────────┘
+ │
+ ▼
+┌──────────────────────────────┐
+│ 记忆子网 (自治) │
+│ │
+│ 记忆子网自行决定： │
+│ → 如何写入新信息 │
+│ → 如何更新已有记忆 │
+│ → 如何删除/修正错误记忆 │
+│ → 选择图DB / 向量DB / 文本 │
+│ │
+│ 整个过程 Core 不参与 │
+└──────────────────────────────┘
+```
- 记忆更新参数张量 ──→ 记忆子网
- │
- ├──→ 图数据库写入 (Neo4j)
- │ (Entity + RELATES 三元组)
- │
- ├──→ 向量索引更新
- │ (语义向量写入)
- │
- └──→ 文本记忆记录
- (会话日志归档)
+### 查询流程
+
+```
+Core 需要查询记忆时：
+ │
+ ├── 封装查询张量（含意图、种子实体、上下文）
+ ├── 封装基础张量（含当前标签、路由结果）
+ │
+ ▼
+记忆子网接收后自行检索
+ │
+ ├── 图数据库 Cypher 查询
+ ├── 向量数据库语义检索
+ ├── 自行关联推理
+ │
+ ▼
+返回包含记忆的张量给 Core
```
## 数据流完整链路（用户视角）
@@ -342,51 +389,51 @@ LLM 子网的输出有两个去向，这是核心设计之一：
```mermaid
sequenceDiagram
participant User as 用户
- participant Core as 调度 Core
participant RCN as 路由与压缩子网
- participant MEM as 记忆子网
+ participant Core as 调度 Core (内部)
+ participant MEM as 记忆子网 (自治)
participant LTC as 逻辑链路追踪子网
participant LLM as LLM 子网
- User->>Core: 自然语言/多模态输入
+ User->>RCN: ① 原始输入（唯一输入路径）
+ RCN->>RCN: 特征提取与标签生成
+ RCN-->>Core: ② 标签张量
- Core->>RCN: ① 路由提取（标准张量）
- RCN->>RCN: 特征提取与压缩
- RCN-->>Core: 返回引用张量
+ Core->>MEM: ③ 传查询张量+新信息张量
+ Note over MEM: 记忆子网自行检索
+ MEM-->>Core: ④ 返回记忆张量
- Core->>MEM: ② 记忆检索（标准张量）
- MEM->>MEM: 图数据库+向量检索
- MEM-->>Core: 返回记忆结果张量
-
- Note over Core: ③ 启发式判断
根据记忆结果决定下一步
+ Note over Core: ⑤ 启发式判断
alt 需要更多输入特征
- Core->>RCN: 再次调路由子网（携带记忆上下文）
- RCN-->>Core: 返回更精确的引用张量
+ Core->>RCN: 从滑动窗口获取详细特征
+ RCN-->>Core: 返回详细引用张量
else 需要深层记忆
- Core->>MEM: 二次记忆检索（携带路由新结果）
- MEM-->>Core: 返回关联记忆张量
+ Core->>MEM: 新查询张量
+ MEM-->>Core: 更深入的记忆结果
end
- Core->>LTC: ④ 逻辑推理（标准张量）
- LTC->>LTC: MCTS推理路径搜索+验证
- LTC-->>Core: 返回推理路径张量
+ Core->>LTC: ⑥ 推理请求
+ LTC->>LTC: MCTS推理+验证
+ LTC-->>Core: ⑦ 推理路径张量
- alt 推理置信度低
- Core->>LTC: ⑤ 携带更多上下文重新推理
- LTC-->>Core: 返回修正后的推理路径
+ alt 置信度低
+ Core->>LTC: 再次推理（携带更多上下文）
+ LTC-->>Core: 修正推理路径
end
- Core->>LLM: ⑥ 表达生成（推理路径张量）
- LLM->>LLM: 结构化→自然语言转换
+ Core->>LLM: ⑧ 推理路径张量
+ LLM->>LLM: 结构化→自然语言
+ LLM-->>User: ⑨ 自然语言输出（唯一输出路径）
+ LLM-->>Core: ⑩ 表达验证张量
- LLM-->>User: ⑦ 自然语言输出（直接给用户）
- LLM-->>Core: ⑧ 表达验证张量（判断正确性）
+ Note over Core: ⑪ 验证通过
- Note over Core: ⑨ 表达验证通过
+ Core->>MEM: ⑫ 传本轮新信息张量
+ Note over MEM: 记忆子网自行决定
如何写入/更新/删除
- Core->>MEM: ⑩ 记忆更新（参数包张量）
- MEM->>MEM: 图DB写入+向量索引更新+文本记录
+ Core->>RCN: ⑬ 通知处理滑动窗口残留数据
+ RCN->>RCN: 压缩·标签索引·归档
```
## 关键设计决策
@@ -397,7 +444,7 @@ sequenceDiagram
| 调度策略 | 启发式调度 | 灵活、适应复杂任务，非固定管线 |
| LLM 输出机制 | 双通道（自然语言→用户 / 张量→Core） | 解耦表达与验证 |
| 记忆存储 | 图数据库(Neo4j) + 向量数据库 + 文本 | 结构化 + 语义 + 时序 三保险 |
-| 记忆更新触发 | Core 聚合后统一封装 | 确保记忆一致性，避免碎片化写入 |
+| 记忆更新触发 | Core 传新信息→记忆子网自治 | 唯一记忆模块，Core 不越权读写 |
| LLM 定位 | 专业语言生成引擎 | 不存储知识、不负责推理 |
## 与现有架构对比
@@ -410,6 +457,8 @@ sequenceDiagram
| 调度方式 | 线性执行 | 线性工具链 | **启发式、非线性的循环调度** |
| LLM 定位 | 全知全能 | 主控+生成 | **降级为语言生成引擎** |
| 输出验证 | 无 | 无 | **表达验证张量机制** |
-| 记忆更新 | 上下文窗口 | 外部DB写入 | **Core聚合后统一打包更新** |
+| 记忆更新 | 上下文窗口 | 外部DB写入 | **Core传新信息→记忆子网自治更新** |
+| **输入路径** | 直接接收 | 直接接收 | **唯一经路由子网** |
+| **输出路径** | 直接输出 | 直接输出 | **唯一经 LLM 子网** |
| 幻觉控制 | 无专门机制 | 工具结果覆盖 | 知识/推理/表达完全解耦 |
| 可解释性 | 低（黑箱） | 中（可追踪工具调用） | 高（完整张量链路追踪） |
diff --git a/docs/llm-subnet.md b/docs/llm-subnet.md
index b6e412e..613b4a4 100644
--- a/docs/llm-subnet.md
+++ b/docs/llm-subnet.md
@@ -2,7 +2,9 @@
## 概述
-LLM 子网类比人脑的**布洛卡区（表达核）**，是 NextAgent 架构中**唯一直接与用户交互**的组件。在认知解耦架构下，LLM 不再是"全知怪物"，而是降级为专业的**语言生成引擎**：知识来源外置到记忆子网，逻辑推理外置到推理子网，LLM 仅负责将结构化的推理结果转换为自然语言。
+LLM 子网类比人脑的**布洛卡区（表达核）**，是 NextAgent 架构中**唯一的输出路径**（当前仅输出自然语言；可扩展图像、视频等输出子网）。
+
+在认知解耦架构下，LLM 不再是"全知怪物"，而是降级为专业的**语言生成引擎**：知识来源外置到记忆子网，逻辑推理外置到推理子网，LLM 仅负责将结构化的推理结果转换为自然语言。
### 核心设计：LLM 下位化
diff --git a/docs/memory-subnet.md b/docs/memory-subnet.md
index ad0140a..3b54558 100644
--- a/docs/memory-subnet.md
+++ b/docs/memory-subnet.md
@@ -8,16 +8,30 @@
### 架构定位
+记忆子网是整个 NextAgent 架构中**唯一与记忆内容交互的模块**。Core 不自作主张处理记忆——只负责将查询张量和新信息张量传递过来，**如何更新、删除、修改**由记忆子网自行完成。
+
```
- 记忆更新参数张量 (来自 Core) 记忆检索请求张量 (来自 Core)
- │ │
- ▼ ▼
+ Core 传过来的两样东西
+ │
+ ┌─────────┴────────────┐
+ │ │
+ 查询张量 新信息张量
+ (含意图/种子实体) (含本轮标签/结果)
+ │ │
+ └─────────┬────────────┘
+ │
+ ▼
┌───────────────────────────────────────────────────────────┐
-│ 记忆子网 │
+│ 记忆子网（自治） │
│ │
│ ┌────────────────────────────────────────────────────┐ │
-│ │ 记忆管理器 (Memory Manager) │ │
-│ │ 解析参数包 → 分发到对应存储层 → 返回结果 │ │
+│ │ 记忆管理器 (Memory Manager) │ │
+│ │ 自行决定： │ │
+│ │ → 如何解析查询 → 走图DB/向量DB/文本 │ │
+│ │ → 如何写入新信息 → MERGE/CREATE/更新 │ │
+│ │ → 如何更新已有记忆 → 增量/覆盖/合并 │ │
+│ │ → 如何删除 → 软删除/硬删除/归档 │ │
+│ │ → 如何关联 → 链路推理/图谱推理 │ │
│ └──────┬────────────┬──────────────┬─────────────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
@@ -32,8 +46,8 @@
│ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ 张量编/解码层 │ │
-│ │ 接收：memory_query / memory_update 标准张量 │ │
-│ │ 输出：memory_result 标准张量 │ │
+│ │ 输入：查询张量 + 新信息张量（来自 Core） │ │
+│ │ 输出：记忆结果张量（返回给 Core） │ │
│ └────────────────────────────────────────────────────┘ │
└───────────────────────────────────────────────────────────┘
```
@@ -133,9 +147,10 @@ LIMIT 10
| 项目 | 说明 |
|------|------|
-| **输入1** | `memory_query` 张量（来自 Core，含查询意图和种子实体） |
-| **输入2** | `memory_update` 张量（来自 Core，含要写入的三元组和元数据） |
+| **输入1** | 查询张量（来自 Core，含查询意图、种子实体、上下文） |
+| **输入2** | 新信息张量（来自 Core，含本轮标签和子网结果；**不含具体写入指令**） |
| **输出** | `memory_result` 张量（包含检索到的实体/关系/向量结果） |
+| **自治** | 记忆子网自行决定如何写入、更新、删除、修改记忆 |
## 训练目标
@@ -284,9 +299,9 @@ class Neo4jGraph:
| 信息一致性 | 同一信息多次检索结果是否一致 |
| 记忆容量 | 在不显著降低性能前提下的最大存储量 |
-## 记忆更新参数包张量格式
+## 新信息张量格式
-Core 打包给记忆子网的 `memory_update` 张量格式：
+Core 传递给记忆子网的**新信息张量**（Core 不发送
```json
{
diff --git a/docs/routing-compression-subnet.md b/docs/routing-compression-subnet.md
index deda7af..6110266 100644
--- a/docs/routing-compression-subnet.md
+++ b/docs/routing-compression-subnet.md
@@ -6,31 +6,65 @@
### 架构定位
+路由与压缩子网是 **NextAgent 唯一外部信息输入路径**。所有图像、文本、语音输入都必须经过此子网处理。
+
```
-原始输入 (图像/语音/文本)
+原始输入 (图像/语音/文本) ←── 唯一外部输入入口
│
▼
┌──────────────────────────────────────────────┐
│ 路由与压缩子网（感觉中枢） │
│ │
-│ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
-│ │ 多模态 │ │ 特征融合 │ │ 压缩编码 │ │
-│ │ 编码器 │ →│ (Attention)│ →│ (AutoEnc)│ │
-│ └──────────┘ └──────────┘ └──────────┘ │
+│ ┌──────────────────────────────────────────┐│
+│ │ 阶段 A（即时处理） ││
+│ │ 输入产生时立即执行 ││
+│ │ ││
+│ │ ┌──────────┐ ┌──────────┐ ┌────────┐ ││
+│ │ │ 多模态 │→│ 特征融合 │→│ 标签 │ ││
+│ │ │ 编码器 │ │ (Attention)│ │ 生成器 │ ││
+│ │ └──────────┘ └──────────┘ └────────┘ ││
+│ │ ││
+│ │ 输出：标签张量 → 立即发送给调度 Core ││
+│ │ 原始数据 → 存入滑动窗口（保留一段时间） ││
+│ └──────────────────────────────────────────┘│
│ │
-│ ┌──────────────────────────────────────┐ │
-│ │ 张量编码层 (Tensor Encoder) │ │
-│ │ 内部张量 → 标准通信张量 │ │
-│ └──────────────────────────────────────┘ │
+│ ┌──────────────────────────────────────────┐│
+│ │ 阶段 B（轮结束后执行） ││
+│ │ Core 通知后触发 ││
+│ │ ││
+│ │ ┌──────────┐ ┌──────────┐ ┌────────┐ ││
+│ │ │ 压缩编码 │→│ 张量化 │→│ 归档/ │ ││
+│ │ │ (AutoEnc) │ │ (Tensor) │ │ 丢弃 │ ││
+│ │ └──────────┘ └──────────┘ └────────┘ ││
+│ │ ││
+│ │ 处理目标：滑动窗口中的原始数据 ││
+│ └──────────────────────────────────────────┘│
│ │
└──────────────────┬───────────────────────────┘
│
- ▼
- 标准引用张量 (Standard Ref Tensor)
- │
- → 发送给调度 Core
+ ├── 阶段 A: 标签张量（即时） → 调度 Core
+ └── 阶段 B: 处理后数据（轮结束）→ 冷区存储/丢弃
```
+### 滑动窗口机制
+
+路由子网维护一个**滑动窗口**暂存原始输入数据：
+
+| 参数 | 说明 |
+|------|------|
+| 窗口大小 | 最近 N 条输入（可配置，默认 10 条） |
+| 保留时间 | 窗口内数据在本轮调度结束前均有效 |
+| 触发清除 | Core 通知 `flush_window()` 后处理残留数据 |
+| 数据用途 | 供 Core 调度中间再次提取详细特征 |
+
+### 边界规则
+
+| 规则 | 说明 |
+|------|------|
+| 唯一输入路径 | 所有外部数据必须经过此子网 |
+| 不参与调度循环内部 | 路由子网不参与 Core 的内部记忆/推理循环（除非 Core 要求从窗口提取更多特征） |
+| 两阶段处理 | 快速出标签 → 轮结束再处理原始数据 |
+
### 输入/输出
| 项目 | 说明 |