[INFO] 认知架构演化系统设计

• 时间: 2026-01-22
• 类型: 设计
• 来源: Robert 与 Jane 的设计讨论
• 置信度: 7/10（设计清晰，待原型验证）
• 标签: #AI #认知架构 #演化 #自我改进 #DDD #TypeScript #Bun

内容

基于 INFO-129（元架构思考）、INFO-130（代码作为认知基因）、INFO-131（技术栈）的落地设计。

一、核心决策

二、第一性原理：认知原语

从"认知需要什么"出发：

感知    →  从环境获取信息
记忆    →  存储和检索信息
推理    →  从已知推导未知
规划    →  分解目标为步骤
执行    →  对环境产生影响（通过代码）
学习    →  从经验中改进
元认知  →  对自身认知的认知（自我改进的基础）

代码化定义

// 统一的信息表示
interface CognitiveState {
  context: Map<string, any>;     // 当前上下文
  workingMemory: any[];          // 工作记忆
  goals: Goal[];                 // 当前目标栈
  trace: TraceEntry[];           // 执行轨迹
}

// 认知原语的统一接口
interface CognitiveModule {
  id: string;
  type: ModuleType;

  // 输入输出定义
  inputSchema: Schema;
  outputSchema: Schema;

  // 核心执行
  process(input: any, state: CognitiveState): Promise<{
    output: any;
    stateUpdate: Partial<CognitiveState>;
  }>;

  // 元信息（用于演化）
  describe(): ModuleDescription;
}

三、图结构 + DDD

架构表示

// Agent 架构 = 有向图
interface AgentArchitecture {
  modules: Map<string, CognitiveModule>;  // 节点
  edges: Edge[];                          // 边（信息流）
  entryPoints: string[];                  // 入口模块
  orchestrator: OrchestratorType;         // 调度策略
}

interface Edge {
  from: string;           // 源模块
  to: string;             // 目标模块
  condition?: Condition;  // 条件触发
  transform?: Transform;  // 信息转换
}

DDD 思想映射

架构图示例

┌─────────────────────────────────────────────────────────────┐
│                                                             │
│     ┌─────────┐                                             │
│     │ Perceive│ ─────────────────┐                          │
│     └────┬────┘                  │                          │
│          │                       ▼                          │
│          │              ┌─────────────┐                     │
│          │              │   Memory    │◄────────┐           │
│          │              └──────┬──────┘         │           │
│          │                     │                │           │
│          ▼                     ▼                │           │
│     ┌─────────┐         ┌─────────────┐        │           │
│     │ Reason  │◄────────│   Plan      │        │           │
│     └────┬────┘         └──────┬──────┘        │           │
│          │                     │                │           │
│          └──────────┬──────────┘                │           │
│                     ▼                           │           │
│              ┌─────────────┐                    │           │
│              │   Execute   │────────────────────┘           │
│              │(Bun Sandbox)│                                │
│              └──────┬──────┘                                │
│                     │                                       │
│                     ▼                                       │
│              ┌─────────────┐                                │
│              │    Meta     │ ←── 观察执行，自我改进          │
│              └─────────────┘                                │
└─────────────────────────────────────────────────────────────┘

四、唯一工具：Bun Sandbox + 代码数据库

核心洞察

传统设计（过度抽象）：
  Tool1: FileSystem
  Tool2: Network
  Tool3: Database
  ...每个 tool 是独立接口

第一性原理设计：
  唯一 Tool: Bun Sandbox（执行任意 TS 代码）
       +
  代码数据库（管理、检索、版本、组合）

工具的本质就是可执行的代码，不需要额外抽象。

接口设计

// 唯一的工具：代码执行
interface BunSandboxTool {
  execute(code: string, context: any): Promise<ExecutionResult>;
}

interface ExecutionResult {
  success: boolean;
  result: any;
  stdout: string;
  stderr: string;
  metrics: {
    duration: number;
    memoryUsed: number;
  };
}

// 代码存储（数据库）
interface CodeRepository {
  // 存储
  save(code: CodeSnippet): Promise<string>;

  // 检索
  get(id: string): Promise<CodeSnippet>;
  search(query: string): Promise<CodeSnippet[]>;  // 语义搜索

  // 版本
  getHistory(id: string): Promise<CodeVersion[]>;

  // 组合
  compose(ids: string[]): Promise<string>;
}

interface CodeSnippet {
  id: string;
  name: string;
  description: string;
  code: string;           // TS 代码
  inputSchema?: Schema;
  outputSchema?: Schema;
  tags: string[];
  createdBy: 'human' | 'agent';
  parentIds?: string[];   // 演化来源（可追溯）
  usageCount: number;     // 使用次数（自然选择信号）
  successRate: number;    // 成功率
}

工作流程

任务输入
    │
    ▼
┌─────────────────────────────────────────────────────────────┐
│                        Agent                                │
│                                                             │
│  1. 理解任务                                                │
│  2. 从数据库检索相关代码片段                                 │
│  3. 组合/修改代码（LLM 生成）                               │
│  4. 调用 Bun Sandbox 执行                                   │
│  5. 根据结果迭代                                            │
│  6. 成功的代码片段存回数据库（学习）                         │
│                                                             │
└─────────────────────────────────────────────────────────────┘
    │
    ▼
任务输出

"创造工具" = "写入新代码到数据库"

// 传统：定义新 Tool 接口 + 实现
// 本设计：
await codeRepo.save({
  name: "fetchAndParse",
  description: "获取 URL 内容并解析 JSON",
  code: `
    export async function fetchAndParse(url: string) {
      const res = await fetch(url);
      return res.json();
    }
  `,
  tags: ["network", "json"],
  createdBy: "agent"
});

五、代码库的演化

初始状态：
  人类写入基础代码片段
       │
       ▼
Agent 执行任务：
  · 检索相关代码
  · 组合、修改
  · 执行验证
  · 成功代码存回数据库
       │
       ▼
代码库演化：
  · 好的代码被复用（usageCount ↑）
  · 差的代码沉底（successRate ↓）
  · 新模式涌现
  · 可追溯演化路径（parentIds）

代码库本身就是演化的对象——不仅 Agent 架构在演化，代码资产也在演化。

六、自我改进机制

元认知模块

interface MetaCognitiveModule extends CognitiveModule {
  // 观察执行轨迹
  observeTrace(trace: TraceEntry[]): Observation;

  // 评估架构
  evaluateArchitecture(
    architecture: AgentArchitecture,
    performance: PerformanceMetrics
  ): ArchitectureEvaluation;

  // 提出修改
  suggestModification(
    evaluation: ArchitectureEvaluation
  ): ArchitectureModification[];

  // 执行修改
  applyModification(
    architecture: AgentArchitecture,
    modification: ArchitectureModification
  ): AgentArchitecture;
}

自我改进循环

执行任务 → 记录轨迹 → 元认知观察 → 评估 → 提出修改 → 应用 → 执行任务...

七、双循环演化

┌─────────────────────────────────────────────────────────────┐
│                 外循环：种群演化（达尔文）                    │
│                                                             │
│   多个 Agent 架构并行                                       │
│   LLM 生成架构变体                                          │
│   Sandbox 并行评估                                          │
│   选择 Top-K                                                │
│                                                             │
│    ┌─────────────────────────────────────────────────┐      │
│    │           内循环：自我改进（拉马克）              │      │
│    │                                                 │      │
│    │   单个 Agent 在生命周期内自我修改               │      │
│    │   元认知模块观察和调整                          │      │
│    │   新代码存入数据库                              │      │
│    │                                                 │      │
│    └─────────────────────────────────────────────────┘      │
│                                                             │
│   内循环的改进可以"遗传"到下一代                             │
└─────────────────────────────────────────────────────────────┘

八、原型 MVP 计划

Phase 1：最小原语 + Bun Sandbox
─────────────────────────────────────────────────
· 4 个基础模块：Perceive, Memory, Reason, Execute
· Bun Sandbox 执行 TS 代码
· 简单代码数据库（SQLite）
· 固定架构

Phase 2：图结构 + 代码演化
─────────────────────────────────────────────────
· 架构可配置（图结构）
· Agent 可存储新代码
· 代码检索（向量搜索）

Phase 3：元认知 + 自我改进
─────────────────────────────────────────────────
· Meta 模块
· 架构自我修改
· 验证"自我改进"能力

Phase 4：种群演化
─────────────────────────────────────────────────
· 多架构并行
· LLM 变异
· 选择 + 遗传

关联

• INFO-129：元架构思考（设想3/7）
• INFO-130：代码作为认知基因
• INFO-131：GP + LLM + Sandbox 技术栈
• NODE-AI意识与学习：本设计是其落地方案
• RULE-范式Bootstrap：LLM 驱动演化