Memory × Working Memory 架构设计：短期记忆的状态流分层体系

个人简介

作者简介：全栈研发，具备端到端系统落地能力，专注大模型的压缩部署、多模态理解与 Agent 架构设计。 热爱“结构”与“秩序”，相信复杂系统背后总有简洁可控的可能。
我叫观熵。不是在控熵，就是在观测熵的流动
个人主页：观熵
个人邮箱：privatexxxx@163.com
座右铭：愿科技之光，不止照亮智能，也照亮人心！

专栏导航

观熵系列专栏导航：
AI前沿探索：从大模型进化、多模态交互、AIGC内容生成，到AI在行业中的落地应用，我们将深入剖析最前沿的AI技术，分享实用的开发经验，并探讨AI未来的发展趋势
AI开源框架实战：面向 AI 工程师的大模型框架实战指南，覆盖训练、推理、部署与评估的全链路最佳实践
计算机视觉：聚焦计算机视觉前沿技术，涵盖图像识别、目标检测、自动驾驶、医疗影像等领域的最新进展和应用案例
国产大模型部署实战：持续更新的国产开源大模型部署实战教程，覆盖从 模型选型 → 环境配置 → 本地推理 → API封装 → 高性能部署 → 多模型管理 的完整全流程
TensorFlow 全栈实战：从建模到部署：覆盖模型构建、训练优化、跨平台部署与工程交付，帮助开发者掌握从原型到上线的完整 AI 开发流程
PyTorch 全栈实战专栏： PyTorch 框架的全栈实战应用，涵盖从模型训练、优化、部署到维护的完整流程
深入理解 TensorRT：深入解析 TensorRT 的核心机制与部署实践，助力构建高性能 AI 推理系统
Megatron-LM 实战笔记：聚焦于 Megatron-LM 框架的实战应用，涵盖从预训练、微调到部署的全流程
AI Agent：系统学习并亲手构建一个完整的 AI Agent 系统，从基础理论、算法实战、框架应用，到私有部署、多端集成
DeepSeek 实战与解析：聚焦 DeepSeek 系列模型原理解析与实战应用，涵盖部署、推理、微调与多场景集成，助你高效上手国产大模型
端侧大模型：聚焦大模型在移动设备上的部署与优化，探索端侧智能的实现路径
行业大模型 · 数据全流程指南：大模型预训练数据的设计、采集、清洗与合规治理，聚焦行业场景，从需求定义到数据闭环，帮助您构建专属的智能数据基座
机器人研发全栈进阶指南：从ROS到AI智能控制：机器人系统架构、感知建图、路径规划、控制系统、AI智能决策、系统集成等核心能力模块
人工智能下的网络安全：通过实战案例和系统化方法，帮助开发者和安全工程师识别风险、构建防御机制，确保 AI 系统的稳定与安全
智能 DevOps 工厂：AI 驱动的持续交付实践：构建以 AI 为核心的智能 DevOps 平台，涵盖从 CI/CD 流水线、AIOps、MLOps 到 DevSecOps 的全流程实践。
C++学习笔记？：聚焦于现代 C++ 编程的核心概念与实践，涵盖 STL 源码剖析、内存管理、模板元编程等关键技术
AI × Quant 系统化落地实战：从数据、策略到实盘，打造全栈智能量化交易系统
大模型运营专家的Prompt修炼之路：本专栏聚焦开发 / 测试人员的实际转型路径，基于 OpenAI、DeepSeek、抖音等真实资料，拆解 从入门到专业落地的关键主题，涵盖 Prompt 编写范式、结构输出控制、模型行为评估、系统接入与 DevOps 管理。每一篇都不讲概念空话，只做实战经验沉淀，让你一步步成为真正的模型运营专家。

---

Memory × Working Memory 架构设计：短期记忆的状态流分层体系

---

🧠 摘要

在 Agent 系统中，记忆并非全部都等同于“知识检索”。真正起到大脑“缓冲区”功能的是——工作记忆（Working Memory）。它支撑 Agent 进行“多轮思考”、“行为序列规划”、“策略调整”乃至“上下文感知反应”，是智能行为产生的最小闭环。本篇将聚焦短期工作记忆的架构构建，从 StateFlow 出发，设计一套具有分层状态感知 / 多 Agent 状态隔离 / trace 可观测 / 动作可编辑的 Working Memory 模型，并在此基础上支持 Prompt 注入、行为调整与任务链中控能力。

---

📚 目录

1. 什么是 Working Memory？Agent 执行的上下文中枢机制
2. StateFlow × MemoryFlow：多层状态管理系统设计
3. Agent Slot × RoleContext：多 Agent 状态隔离与作用域绑定机制
4. TraceStack × ThoughtChain：支持推理过程的行为追踪栈
5. PromptPatch × RewriteHook：支持上下文记忆注入与动态修正机制
6. 结构集成：构建可观测 × 可用 × 可控制的工作记忆引擎

---

一、什么是 Working Memory？Agent 执行的上下文中枢机制

---

🧠 定义：Working Memory ≠ RAG

在人类认知中，工作记忆是短时信息加工与存储的中心，支撑逻辑推理、问题解决、动作执行与临时注意力保持。

对应到智能体系统中，它的作用是：

Agent 模块	对应人类功能
task_state 中 input / output	语义输入的短暂保持
trace_stack 中思考链	内在对话 / 多步推理的缓存
Prompt 中的 context token 注入	当前任务状态的临时绑定
交互式行为中的 response 记忆	最近输出的“意图延续”

Working Memory 是 Agent 推理和行为的“上下文胶水”与“执行逻辑编辑器”

---

🚨 为什么不能只用一个 task_state？

很多系统简单用 task_state = dict() 来存上下文，但这会导致：

• 多 Agent 状态污染（上下文互相覆盖）
• Trace 混乱（无法知道谁更新了谁）
• 多轮链中行为无法回放（无法持久结构）
• Prompt 注入缺乏结构化支持（状态即 prompt 无法复用）

所以你需要构建真正的 MemoryFlow × 多层状态容器结构。

---

二、StateFlow × MemoryFlow：多层状态管理系统设计

---

✅ 第一层：WorkingState（状态值持久器）

class WorkingState:
    def __init__(self, initial: dict = None):
        self._state = initial or {}
        self._trace = []

    def get(self, path: str):
        return reduce(lambda d, k: d.get(k, {}), path.split("."), self._state)

    def set(self, path: str, value):
        keys = path.split(".")
        ref = self._state
        for k in keys[:-1]:
            ref = ref.setdefault(k, {})
        ref[keys[-1]] = value
        self._trace.append({"op": "set", "path": path, "value": value, "ts": time.time()})

    def dump(self):
        return self._state

    def trace(self):
        return self._trace

---

✅ 第二层：MemoryFlow（状态流管理器）

• 为每个 Agent / Action 分配独立作用域
• 支持按任务流隔离状态、按角色复用结构
• 可注册 Observer（可订阅行为）

class MemoryFlow:
    def __init__(self):
        self.states = defaultdict(WorkingState)
        self.observers = []

    def for_agent(self, agent_id):
        return self.states[agent_id]

    def set(self, agent_id, path, value):
        self.states[agent_id].set(path, value)
        for obs in self.observers:
            obs.on_update(agent_id, path, value)

    def get(self, agent_id, path):
        return self.states[agent_id].get(path)

    def subscribe(self, observer):
        self.observers.append(observer)

---

🧩 实例调用

memflow = MemoryFlow()
memflow.set("SummaryAgent", "output.text", "今天完成了日报")
memflow.set("SummaryAgent", "output.score", 0.82)

print(memflow.get("SummaryAgent", "output.text"))

---

✅ 可订阅状态流的 Observer 示例

class LogObserver:
    def on_update(self, agent_id, path, value):
        print(f"[Trace] {agent_id} updated {path}: {value}")

---

📌 小结：

• Working Memory 是“任务态 × 推理链 × 上下文”的容器
• WorkingState 保持结构化状态
• MemoryFlow 管理多 Agent 状态隔离、可订阅
• 远比一个全局字典更具扩展性与可治理性

---

三、Agent Slot × RoleContext：多 Agent 状态隔离与作用域绑定机制

---

🎯 问题：为什么多 Agent 系统常“上下文乱套”？

现实中你常见如下场景：

问题表现	实际原因
一个 Agent 的输出被另一个覆盖	所有 Agent 共用同一个字典
Agent 间协同失败	状态没有作用域，Agent 无法访问别人的必要上下文
prompt 拼装不准	没有结构区分“谁说的、什么时候说的、说了啥”
状态泄漏	多轮任务状态未清理，污染后续流程

---

✅ 引入 Slot 与 RoleContext 概念

• Slot: 每个 Agent 在 MemoryFlow 中的唯一“槽位”
• RoleContext: 某个 Agent 在某个任务角色下的上下文封装

slot_id = f"{agent_name}::{role}"

你可以为同一个 Agent 在不同任务中保留不同 Slot，例如：

SummaryAgent::daily
SummaryAgent::weekly
RiskChecker::financial

---

✅ MemoryFlow 支持 Slot Binding 与隔离

class MemoryFlow:
    def set(self, slot_id, path, value):
        self.states[slot_id].set(path, value)

    def get(self, slot_id, path):
        return self.states[slot_id].get(path)

    def for_role(self, agent_name, role="default"):
        return self.states[f"{agent_name}::{role}"]

---

🧩 使用示例：多 Agent 多上下文隔离运行

memflow.set("SummaryAgent::daily", "output.text", "日报生成成功")
memflow.set("SummaryAgent::weekly", "output.text", "本周总结就绪")

---

✅ 多角色执行场景支持

场景	槽位 ID 示例
日报总结	SummaryAgent::daily
周报总结	SummaryAgent::weekly
客户沟通	DialogueAgent::client_x
法律分析	LegalAgent::case_23

---

四、TraceStack × ThoughtChain：支持推理过程的行为追踪栈

---

🎯 为什么要链式 Trace？

在长链条任务中，Agent 不是一次调用完事，它可能：

• 自己调用自己（递归式任务）
• 分多个阶段完成推理（思考链）
• 失败后回滚、修复、注释（提示工程中的系统行为）

这就要求你构建结构化的 Trace 栈，而不是一个 log 字符串。

---

✅ TraceStack 模型定义

class TraceStack:
    def __init__(self):
        self.steps = []

    def push(self, agent_id, action, input_data, output_data):
        self.steps.append({
            "agent": agent_id,
            "action": action,
            "input": input_data,
            "output": output_data,
            "ts": time.time()
        })

    def all(self):
        return self.steps

---

✅ 与 MemoryFlow 联动

每个 Slot 中绑定一个 TraceStack：

class WorkingState:
    def __init__(self, initial=None):
        self._state = initial or {}
        self._trace_stack = TraceStack()

    def trace(self):
        return self._trace_stack.all()

    def push_trace(self, agent_id, action, input_data, output_data):
        self._trace_stack.push(agent_id, action, input_data, output_data)

---

🧩 示例使用：构建思考链

memflow.set("SummaryAgent::daily", "input.text", "今天做了很多事")
output = SummaryAgent().run(...)
memflow.set("SummaryAgent::daily", "output.text", output["text"])

memflow.states["SummaryAgent::daily"].push_trace(
    "SummaryAgent", "summarize", {"text": "..."}, output
)

---

✅ 行为链意义

能力	实现路径
多阶段推理	每一步行为链 trace 可回放
推理调试	失败行为链可打印、注释
Prompt Patch	可基于历史行为修改提示词策略
评估反馈	可统计哪一步影响最终评分最重

---

📌 小结：

• 每个 Agent 在任务中拥有独立 Slot × Role 结构
• 每次执行行为写入 TraceStack，形成 ThoughtChain
• Trace 可用于回放、评估、提示词生成、行为分析与训练采样

---

五、PromptPatch × RewriteHook：支持上下文记忆注入与动态修正机制

---

🎯 为什么不能一直用静态 Prompt？

当 Agent 需要根据：

• 当前上下文（用户输入、前一轮对话）
• 角色记忆（行为链、历史执行、任务类型）
• 评分结果（任务评分低，需触发修复）
• 链式推理路径（复用 ThoughtChain 行为轨迹）

来调整其提示词时，静态 Prompt 根本无法满足。

你需要一套：

✅ 记忆感知型 Prompt 编排系统：根据 Slot × Trace × Context 动态构造提示词

---

✅ PromptPatch：上下文提示词注入器

class PromptPatch:
    def __init__(self, memory_flow: MemoryFlow):
        self.memory = memory_flow

    def render(self, slot_id, template: str):
        ctx = self.memory.states[slot_id].dump()
        return template.format(**ctx.get("input", {}), **ctx.get("output", {}))

---

✅ 使用示例：

template = "请总结以下内容：{text}\n上一次评分为：{score}"
patched_prompt = PromptPatch(memflow).render("SummaryAgent::daily", template)

→ 输出为：

请总结以下内容：今天处理了三个项目，做了一次会议记录。
上一次评分为：0.73

---

✅ RewriteHook：低质量提示自动修正系统

class RewriteHook:
    def __init__(self, threshold=0.8):
        self.threshold = threshold

    def after(self, agent, slot_id, state):
        score = state.get(slot_id, "output.score") or 1.0
        if score < self.threshold:
            print(f"[Patch] ⛏️ {slot_id} 评分低（{score:.2f}），触发 prompt 重写")
            old_text = state.get(slot_id, "input.text")
            patch_prompt = f"请你以更简洁方式重新总结：{old_text}"
            state.set(slot_id, "input.text", patch_prompt)

---

✅ 在执行链中插入 RewriteHook

executor = TaskExecutor(
    agent=SummaryAgent(),
    memory=memflow,
    slot_id="SummaryAgent::daily",
    hooks=[RewriteHook(threshold=0.85)]
)
executor.run(task_state)

---

✅ 模型交互增强能力

功能	实现方式
上下文插入	PromptPatch.render()
自动 prompt 优化	RewriteHook
提示结构日志化	TraceEntry 中注入 prompt_used
多 prompt 策略管理	RoleContext 可设定不同模板策略

---

📌 小结：

• PromptPatch 负责读取记忆状态，生成结构化提示词
• RewriteHook 实现基于评分或行为 trace 的 Prompt 动态重写
• 这套机制让 Agent 具备“记得住 → 会调整”的提示能力
• 是真正进入 Prompt 编排自动化与智能提示系统的基石

---

六、结构集成：构建可观测 × 可用 × 可控制的工作记忆引擎

---

🧠 我们已经构建了哪些能力？

组件	功能
WorkingState	Agent 独立的结构化状态容器
MemoryFlow	多 Agent 多角色的状态流管理器
TraceStack	行为记录链，可追踪、可回放、可统计
Slot / RoleContext	状态作用域划分，支持多角色独立执行
PromptPatch	上下文驱动的 prompt 构造器
RewriteHook	行为链驱动的提示词修正机制

---

✅ 构建统一封装类：WorkingMemoryEngine

class WorkingMemoryEngine:
    def __init__(self):
        self.flow = MemoryFlow()
        self.patch = PromptPatch(self.flow)

    def for_slot(self, agent_name, role="default"):
        return f"{agent_name}::{role}"

    def get_input(self, slot, key):
        return self.flow.get(slot, f"input.{key}")

    def set_input(self, slot, key, value):
        self.flow.set(slot, f"input.{key}", value)

    def get_output(self, slot, key):
        return self.flow.get(slot, f"output.{key}")

    def set_output(self, slot, key, value):
        self.flow.set(slot, f"output.{key}", value)

    def render_prompt(self, slot, template):
        return self.patch.render(slot, template)

    def push_trace(self, slot, action, input_data, output_data):
        self.flow.states[slot].push_trace(slot, action, input_data, output_data)

    def dump(self, slot):
        return self.flow.states[slot].dump()

    def trace(self, slot):
        return self.flow.states[slot].trace()

---

🧩 使用示例：一段完整的执行逻辑

mem = WorkingMemoryEngine()
slot = mem.for_slot("SummaryAgent", "daily")

# Step 1: 设置输入
mem.set_input(slot, "text", "今天完成了项目汇报与会议纪要")

# Step 2: 渲染提示词
prompt = mem.render_prompt(slot, "请总结以下内容：{text}")
print("生成的 Prompt:", prompt)

# Step 3: 执行 Agent
output = SummaryAgent().run({"text": prompt})
mem.set_output(slot, "text", output["text"])
mem.set_output(slot, "score", output.get("score", 1.0))

# Step 4: Trace 行为
mem.push_trace(slot, "summarize", {"text": prompt}, output)

# Step 5: 查看状态与行为链
print(mem.dump(slot))
print(mem.trace(slot))

---

✅ 能力演进路径建议：

当前能力	下一阶段
Slot + PromptPatch	扩展到 Prompt 策略树（多版本 prompt 结构）
TraceStack	引入行为节点图谱（ThoughtGraph）
WorkingMemory	与 LongTermMemory 融合（短+长链共存）
MemoryFlow	引入事件驱动（on_score_change / on_input_ready）

---

📌 本章总结：

你已完成一个完整的 Agent 工作记忆引擎构建：

• 可用于链式任务上下文存储
• 可追踪每个 Agent 的思维链
• 可注入 prompt，支持动态生成与修正
• 可用于行为回放、调试、训练数据采样、质量评分

---

🌟 如果本文对你有帮助，欢迎三连支持！

👍 点个赞，给我一些反馈动力
⭐ 收藏起来，方便之后复习查阅
🔔 关注我，后续还有更多实战内容持续更新

---

写系统，也写秩序；写代码，也写世界。
观熵出品，皆为实战沉淀。