大脑与记忆：AI 操作内核的认知架构

生物大脑有两套系统：快速直觉（小脑）和慢速推理（大脑皮层）。OctopusOS 复刻了这一架构——大脑（LLM）负责复杂推理，小脑（Cerebellum）负责快速本地推理——由三层记忆体系、知识蒸馏管线和结构化 ReAct 推理循环统一协调。

1. 为什么 AI OS 需要大脑和记忆

传统 AI Agent 是无状态的：处理提示、返回结果、然后遗忘。但真正的 AI 操作系统必须记忆、学习、跨时间推理——就像生物体一样。

没有持久记忆和学习闭环，AI Agent 会：

• 跨会话重复犯同样的错误
• 无法积累组织知识
• 没有机制持续提升路由准确率
• 缺乏结构化多步推理能力

OctopusOS 通过双脑 + 三层记忆架构解决这些问题，提供快速推理、持续学习、持久记忆和结构化推理。

2. 大脑：LLM 路由

大脑借助外部 LLM 提供者（OpenAI、本地模型）处理复杂路由决策。当小脑不确定时，LLM 接管。

# LLM 路由 — kernel/runtime/_wl_llm_routing.py
async def _model_route(self, *, run_id, user_text, context_digest, ...):
    prompt = build_routing_prompt(user_text, context_digest)
    response = await self.llm_port.complete(prompt)
    decision = parse_routing_decision(response)
    # 存储用于蒸馏
    self._store_distillation_example(
        routing_input={"user_text": user_text},
        llm_decision=decision,
    )
    return decision

LLM 将每个用户输入分类为 4 种模式：

3. 小脑：Cerebellum 本地模型

Cerebellum 是一个轻量级本地分类模型，提供亚毫秒级路由，无需任何外部 API 调用。它从执行反馈和 LLM 蒸馏中学习。

@dataclass(frozen=True)
class CerebellumModel:
    weights: dict[str, dict[str, float]]  # route → feature → weight
    bias: dict[str, float]                # route → bias
    model_version: str
    feature_config: FeatureConfig

核心算法：

• 贝叶斯 Beta 先验：每条路由以 Beta(2, 2) 分布初始化，根据反馈更新
• 特征包构建：将输入分词为 tok:word 特征 + 元数据特征
• 加权评分：score(route) = bias + Σ(weight[feature] * value)
• Adam 优化器：自适应学习率，带动量的梯度更新
• 经验回放缓冲区：存储近期样本用于课程学习

4. 知识蒸馏：LLM → Cerebellum

当 LLM 做出高置信度路由决策（confidence >= 0.5）时，会生成一个 DistillationExample 存入缓冲区。当缓冲区达到阈值（每 50 次运行），触发训练步。

@dataclass(frozen=True)
class DistillationExample:
    text: str
    context_digest: str
    llm_route: str        # CHAT | QUERY | PLAN | EXEC
    llm_confidence: float # >= 0.5 才合格
    features: dict[str, float]
    ts_ms: int = 0

蒸馏管线确保小脑逐步吸收 LLM 的路由智慧，随时间减少对昂贵 API 调用的依赖。

5. MemoryPoint 契约

OctopusOS 中的所有记忆都以 MemoryPoint 存储——一个冻结的不可变数据类，携带内容、元数据和嵌入向量。

@dataclass(frozen=True)
class MemoryPoint:
    memory_id: str
    app_id: str
    namespace: str        # "session" | "short" | "long"
    content: str
    embedding: tuple[float, ...]
    payload: dict         # 可扩展元数据
    tier: str
    hit_count: int = 0
    created_ms: int = 0
    expires_ms: int = 0

payload 字典是扩展机制——所有新功能（角色隔离、记忆链、中枢记忆）都通过 payload 字段实现，无需修改冻结契约：

• _role_id — 角色级记忆隔离
• _chain_parent_id — 时序链链接
• _contributed_by — 中枢记忆来源追踪

6. 三层记忆生命周期

OctopusOS 将记忆组织为三个层级，配合自动生命周期管理：

GC 循环定期运行：过期陈旧条目 → 压缩近似重复 → 晋升高命中记忆。

7. 角色级记忆隔离与中枢记忆

角色隔离

每个角色（如 sysadmin、developer）通过 payload._role_id 过滤获得独立的记忆空间。这防止了跨角色记忆泄露，同时共享底层存储。

def _memory_query_by_role(self, *, app_id, role_id, namespace, query, limit):
    all_points = self._memory_query(app_id=app_id, namespace=namespace, ...)
    return [p for p in all_points if p.payload.get("_role_id") == role_id]

中枢记忆

跨应用的组织知识存储在特殊的 __central__ 命名空间。任何应用可读取，但写入需要显式授权，并标记 _contributed_by 来源。

CENTRAL_APP_ID = "__central__"

def _central_memory_write(self, *, caller_app_id, point):
    enriched_payload = {**point.payload, "_contributed_by": caller_app_id}
    # 写入中枢存储

8. 记忆链：时序链接

记忆链通过 _chain_parent_id 在时间维度上连接相关记忆。这使因果推理成为可能——追踪一系列事件如何导向结论。

def build_chains(points: list[MemoryPoint]) -> dict[str, list[MemoryPoint]]:
    """按 _chain_parent_id 链接将记忆点分组为链。"""

def traverse_chain(points: list[MemoryPoint], root_id: str) -> list[MemoryPoint]:
    """从根节点遍历到所有后代，按时序排列。"""

def chain_depth(points: list[MemoryPoint], memory_id: str) -> int:
    """计算一条记忆在其链中的深度。"""

9. 脑图：推理图谱

脑图将原始记忆点和推理结果转化为可视化的互连知识图谱。每个节点代表一条记忆、一条链或一个推理结论；边代表关系。

@dataclass(frozen=True)
class MindMapNode:
    node_id: str
    label: str
    node_type: str  # memory | chain | reasoning | preference
    tier: str
    metadata: dict
    x: float = 0.0
    y: float = 0.0

@dataclass(frozen=True)
class MindMapEdge:
    edge_id: str
    source_id: str
    target_id: str
    relation: str   # contributes | triggers | informs | evidence
    weight: float = 1.0

force_layout() 函数使用弹簧-电力模型定位节点——相连节点相互吸引，所有节点相互排斥，生成可读的图布局。

10. ReAct 循环：结构化多轮推理

复杂任务需要多轮推理。ReAct 循环为每一步提供显式的 思考 → 行动 → 观察 结构。

@dataclass(frozen=True)
class ReActStep:
    step_id: str
    thought: str = ""        # Agent 在想什么
    action: str = ""         # SEARCH | CALL_SKILL | CHAT | PLAN
    action_input: dict = {}  # 行动参数
    observation: str = ""    # 行动结果
    ts_ms: int = 0

@dataclass(frozen=True)
class ReActScratchpad:
    run_id: str
    steps: list[ReActStep] = []
    current_goal: str = ""
    accumulated_context: str = ""

每一步都发出 REACT_STEP_COMPLETED LiveEvent，确保完全可审计。Scratchpad 摘要注入下一轮 LLM 调用，保持上下文连续性。

11. 证据与可审计性

每个记忆操作都创建可审计的轨迹：

所有事件通过 EvidenceStorePort 流入不可变存储。任何记忆写入、撤销或学习结论都可以通过 evidence_pointer 追溯到其来源。

12. 架构总结

大脑与记忆架构将六个子系统统一为一个认知层：

这些子系统共同赋予 OctopusOS 跨会话记忆、从每次交互中学习、通过复杂任务推理和审计每个认知决策的能力——这是真正智能操作系统的基石。