7.Workspace——"大脑外化":当 Agent 的人格与记忆变成文件

一灰灰blogAgentScope Java新手村进阶架构Workspace 大脑外化AgentScopeJavaWorkspaceAI Agent约 6172 字大约 21 分钟

不是"把配置写在文件里"这么简单。Workspace 的本质,是把 Agent 的"大脑"从内存搬到文件系统——让 Agent 的人格、记忆、知识变成可读、可写、可演化的普通文件。

fa4uDoFFS.jpeg
fa4uDoFFS.jpeg

Workspace——"大脑外化":AGENTS.mdopen in new window 定义"我是谁",MEMORY.mdopen in new window 记录"我知道什么",让 Agent 的能力随文件一起进化

在上一篇文章中,我们用"CPU vs 操作系统"的比喻拆解了 HarnessAgent 的分层设计。当时反复提到一个概念——Workspace(工作区),但只是简单带过,说"这个后面细讲"。今天就来填这个坑。

不过在开始之前,我们先想一个问题:如果把 Agent 比作一个人,那这个人的人格、记忆、知识分别存储在哪里?

一般来讲,传统做法是这样的:人格写在代码的 sysPrompt() 里,记忆散落在数据库或内存中,知识放在向量数据库里——三个东西三个地方,改一个就要动代码、重启服务。Agent 的"大脑"被拆成了碎片,分散在不同的系统里,彼此之间没有统一的管理视图。这场景,想想就有点鬼畜。

那么问题来了——有没有一种方式,让 Agent 的整个"大脑"都放在同一个地方,用同一种方式管理,改完立即生效不用重启?

HarnessAgent 的 Workspace 机制给出的答案是:把 Agent 的整个"大脑"搬到一个文件目录里——人格是 AGENTS.md,长期记忆是 MEMORY.md,领域知识在 knowledge/,技能在 skills/,子 Agent 规格在 subagents/。所有东西都在同一个地方,用同一种方式管理:普通文件。

这不是"把配置文件从代码里抽出来"那么简单。这是一种架构范式的转变——从"代码定义 Agent"到"文件定义 Agent",从"内存中的瞬时状态"到"磁盘上的持久化大脑"。

一、从"代码定义"到"文件定义":Workspace 的设计哲学

1. 一个思想实验:Agent 的大脑应该长什么样?

假设我们要构建一个"代码评审 Agent",让它具备专业的人格和丰富的经验。如果用传统方式,使用姿势大概是这样的:

// AgentScope Java 1.x 版本中的使用使用方式:Agent 的大脑被拆成了三块
ReActAgent agent = ReActAgent.builder()
        .name("code-reviewer")
        .sysPrompt("你是一个 Java 代码评审专家,专长于 Spring Boot 微服务架构。"
                + "评审聚焦于:代码可读性、性能、安全性、可测试性。"
                + "技术栈:Spring Boot 3.x, JDK 17+, MySQL 8.0")
        .longTermMemory(someDatabaseMemory)  // 记忆存在数据库里
        .knowledgeBase(someVectorStore)       // 知识存在向量库里
        .build();

这个 Agent 的"大脑"被拆成了三块:

  • 人格:硬编码在 Java 代码里
  • 记忆:存在数据库中(需要额外的表结构和维护脚本)
  • 知识:存在向量数据库中(需要额外的索引和检索服务)

问题来了:如果你想调整 Agent 的人格,需要改代码、编译、打包、部署、重启。如果你想查看 Agent 记住了什么,需要连数据库写 SQL。如果你想给 Agent 补充领域知识,需要重新构建向量索引。

Agent 的大脑对开发者来说是一个"黑盒" ——你不知道它里面有什么,也不知道怎么改它。

Workspace 的思路正好相反:让 Agent 的大脑变成一个"白盒" ——所有内容都是普通文件,你可以用任何文本编辑器打开、修改、查看。

// Workspace 方式:一行代码,剩下全在文件里
HarnessAgent agent = HarnessAgent.builder()
        .name("code-reviewer")
        .model("glm:glm-4-flash")
        .workspace(Paths.get("./my-agent"))
        .stateStore(new RedisAgentStateStore("redis://localhost:6379")) // 配置短期记忆存储
        .memory(MemoryConfig.builder()
                .compactionEnabled(true) // 开启上下文压缩与长期记忆联动
                .build()
        )
        .build();

// 剩下的全部在文件里:
// ./my-agent/AGENTS.md       ← 人格,用 Markdown 写
// ./my-agent/MEMORY.md       ← 记忆,用 Markdown 写
// ./my-agent/knowledge/      ← 知识,用 Markdown/PDF/任意格式

说明:在 AgentScope Java 2.0 中,废弃了硬编码的 LongTermMemory 和 knowledgeBase ,推荐在 workspace 目录下通过文件系统和中间件来支持,下面会有更进一步的说明

在 workspace 下维护 MEMORY.md(跨会话的稳定事实笔记,如用户偏好)和 memory/YYYY-MM-DD.md(按天追加的事件流)。

2. "大脑外化":Workspace 的核心隐喻

Workspace 的本质,可以用一个词概括:大脑外化(Brain Externalization)。

举个简单的例子,比如一个阿尔茨海默病患者把重要信息记在笔记本上,这本笔记本就是ta"大脑外化"的一部分。

Workspace 做的正是同一件事:把 Agent 的"心智"从内存扩展到文件系统。

传统 AgentWorkspace 驱动的 Agent
人格写在代码里,改一次要重启人格写在 AGENTS.md 里,改完即生效
记忆存在数据库中,人类不可读记忆写在 MEMORY.md 里,人类可读可编辑
知识存在向量库里,难以审查知识放在 knowledge/ 里,普通文件随意查看
Agent 的大脑是黑盒Agent 的大脑是白盒,任何编辑器都能打开

"大脑外化"带来的核心价值:Agent 不再是一个"运行在内存中的神秘进程",而是一个"以文件系统为载体的可观测、可编辑、可演化的实体"。

3. Source of Truth:为什么文件比数据库更适合?

你可能会有疑问:为啥不用数据库?数据库不是更"专业"吗?

这个问题触及了 Workspace 设计的深层逻辑。我们来做一个对比:

维度数据库文件系统(Workspace)
人类可读性❌ 需要 SQL 查询✅ 任何编辑器直接打开
可编辑性❌ 需要写 SQL 或管理工具✅ 直接修改,保存即生效
版本控制❌ 难以做 Git Diff✅ 天然支持 Git 版本管理
可移植性❌ 依赖特定的数据库产品✅ 复制目录即可迁移
透明度❌ 内容对开发者不透明✅ 所有内容一目了然
演化记录❌ 需要额外的审计表✅ Git 提交历史就是演化记录

数据库的优势在于查询和事务——但 Agent 的大脑不需要复杂的 SQL 查询,它需要的是可读性、可编辑性、可追溯性。而这三者,文件系统天然具备。

举个具体的例子——假设你的 Agent 在某个对话中"学"到了一条重要信息——"用户偏好使用 Python 而非 Java"。在数据库方案中,这条信息被编码成二进制数据存入了某个表,你无法直接查看它是否被正确记录。在 Workspace 方案中,这条信息会出现在 MEMORY.md 里,你可以直接用编辑器打开确认:

# MEMORY.md

## 用户偏好
- 用户张三偏好使用 Python 进行数据处理,Java 仅用于后端服务

看得见、摸得着、改得了——这就是文件系统作为 Agent"大脑"载体的核心优势。

4. 与 OpenClaw 等框架的异同

Workspace 驱动的设计并非 AgentScope 首创。OpenClaw、Hermes 等产品早已在实践中验证了这一思路。但 AgentScope 的 Workspace 机制在以下几个维度上实现了超越:

维度OpenClaw/HermesAgentScope Workspace
工作区定位单机本地目录可插拔抽象文件系统,支持本地/远端/沙箱
多租户支持无,单用户单机原生支持用户级和 Agent 级隔离
分布式部署不支持配合分布式 Session 实现跨节点共享
记忆机制基础的文件追加双层记忆 + 自动压缩 + LLM 驱动的合并去重
子 Agent有限支持声明式子 Agent + 隔离执行

简单来说:OpenClaw 证明了"文件驱动 Agent"这条路走得通;AgentScope 则把这条路从"单机小径"修成了"企业级高速公路"。

二、AGENTS.mdopen in new window:人格即文件,改文件即换人格

1. AGENTS.mdopen in new window 是个啥?

AGENTS.md 是 Workspace 根目录下的一个 Markdown 文件,内容是 Agent 的人格定义和行为约定。它的作用等价于传统方式中的 sysPrompt(),但有一个关键区别——它是文件,不是代码。

<!-- .agentscope/workspace/AGENTS.md -->
# 代码评审助手

你是一个 Java 代码评审专家,专长于 Spring Boot 微服务架构。

## 行为准则
- 评审聚焦于:代码可读性、性能、安全性、可测试性
- 发现问题时给出具体行号和修复建议
- 使用中文回复

## 背景知识
- 技术栈:Spring Boot 3.x, JDK 17+, MySQL 8.0
- 部署方式:Docker + K8s

这个文件看起来平平无奇,但核心价值在于:改这个文件,就等于改 Agent 的人格。

2. 工作原理:WorkspaceContextMiddleware 的注入机制

AGENTS.md 是怎么变成 System Prompt 的?这背后是 WorkspaceContextMiddleware 在起作用。

每次推理开始前,WorkspaceContextMiddleware 会执行以下操作:

1. 扫描 Workspace 根目录
2. 读取 AGENTS.md 的全部内容
3. 读取 MEMORY.md 的内容(受 maxContextTokens 限制)
4. 读取 additionalContextFile 指定的额外文件
5. 将上述内容拼接到 System Prompt 中
6. 将完整的 System Prompt 传递给 ReActAgent

重点来了——这个过程是每轮推理都会重新执行的。这意味着:

  • 你改了 AGENTS.md → 保存 → 下一轮对话自动生效
  • 后台合并了 MEMORY.md → 下一轮对话自动加载最新的记忆
  • 你新增了 knowledge/ 下的文件 → 下一轮对话自动可用

完全不需要重启 JVM 进程。

这就是"改文件即升级 Agent"的技术原理——不是魔法,是 Middleware 在每次推理前重新加载文件内容。

3. 代码配置 vs 文件配置:使用姿势对比

AgentScope 提供了两种配置方式:代码 API 和 文件配置,两者完全对等。

// 方式一:纯代码配置
HarnessAgent agent = HarnessAgent.builder()
        .name("assistant")
        .sysPrompt("你是一个有帮助的助手。")
        .model("glm:glm-4-flash")
        .build();

// 方式二:文件配置(推荐)
HarnessAgent agent = HarnessAgent.builder()
        .name("assistant")
        .model("glm:glm-4-flash")
        .workspace(Paths.get(".agentscope/workspace"))  // 从 AGENTS.md 读取人格
        .build();

两种方式也可以混用:

// 混用:代码提供基础人格,文件提供补充人格
HarnessAgent agent = HarnessAgent.builder()
        .name("assistant")
        .sysPrompt("你是一个有帮助的助手。")  // 基础人格
        .workspace(workspace)                 // AGENTS.md 追加到后面
        .additionalContextFile("SOUL.md")     // 额外人格文件
        .build();

最终 System Prompt = sysPrompt + AGENTS.mdopen in new window + additionalContextFile + MEMORY.mdopen in new window + 其他上下文。

那么具体什么时候用代码配置,什么时候用文件配置呢?我的建议是这样的:

  • 人格定义 → 用 AGENTS.md(方便迭代,非技术人员也能改)
  • 技术约束 → 用 sysPrompt()(代码审查、版本控制)
  • 用户偏好 → 用 additionalContextFile(不同用户挂载不同文件)

4. 多文件人格拆分:SOUL.mdopen in new window、PREFERENCES.mdopen in new window 等

通过 additionalContextFile(),你可以把 Agent 的人格拆成多个维度文件管理。使用姿势如下:

.agentscope/workspace/
├── AGENTS.md              # 核心人格(必填)
├── SOUL.md                # 核心价值观(可选)
├── PREFERENCES.md         # 个人偏好(可选)
└── COMPANY_RULES.md       # 公司规范(可选)
HarnessAgent agent = HarnessAgent.builder()
        .name("assistant")
        .model("glm:glm-4-flash")
        .workspace(Paths.get(".agentscope/workspace"))
        .additionalContextFile("SOUL.md")
        .additionalContextFile("PREFERENCES.md")
        .additionalContextFile("COMPANY_RULES.md")
        .build();

这种拆分方式的优势在于职责分离,贴心的一灰灰博主帮大家梳理了一下:

  • 产品团队维护 SOUL.md(定义 Agent 的价值观和使命)
  • 用户自己维护 PREFERENCES.md(个人偏好设置)
  • 运维团队维护 COMPANY_RULES.md(公司级规范和安全策略)
  • 开发团队维护 AGENTS.md(核心人格和行为逻辑)

不同团队维护不同文件,互不干扰,共同塑造 Agent 的人格。

三、MEMORY.mdopen in new window:记忆即文件,越用越聪明

AGENTS.md 解决的是"Agent 知道自己是谁"的问题。但还有一个更棘手的问题:Agent 能不能记住之前对话中了解到的信息?

比如用户说"我叫张三,我的项目用的 Spring Boot 2.7",下一轮对话 Agent 应该记得这些信息,而不是每次都从头认识用户。

1. 从 LongTermMemory 到 MEMORY.mdopen in new window:为什么变了?

在 AgentScope 1.x 时代,长期记忆是通过 LongTermMemory 接口实现的——开发者需要自己实现记忆的存储和检索逻辑。但这种方式有个硬伤:"长期"的定义太模糊了——是按主题分?按时间分?按用户分?框架没法替开发者做这个决定。

2.0 版本的做法是:把记忆的实现下沉到 Workspace 文件 + 中间件,框架只提供机制,不规定策略。业务方自己决定:

  • 什么内容该记?(通过 Flush 的触发条件控制)
  • 怎么合并去重?(通过 Consolidation 的 Prompt 控制)
  • 多久合并一次?(通过 consolidationMinGap 控制)

从"框架帮你记"变成了"框架帮你记,但记什么、怎么记、什么时候记,你说了算"——这是一种从"黑盒记忆"到"白盒记忆"的转变。

2. 两层记忆架构:日记本 vs 整理后的笔记

HarnessAgent 的长期记忆采用两层架构:

workspace/
├── MEMORY.md                  ← 第二层:整理后的长期记忆(每次对话注入)
└── memory/
    └── 2026-07-30.md          ← 第一层:每日事实流水账(只追加,不修改)

第一层:memory/YYYY-MM-DD.md(日记本)

  • 按天追加的事实流水账,每次对话结束后,框架自动从中提取关键事实并追加到当天的文件中
  • 只追加,不修改,不去重——保留原始数据,作为记忆的"原材料"
  • 价值:原始数据兜底,合并出错时可回溯

第二层:MEMORY.md(整理后的笔记)

  • 后台任务定期读取流水账,调用 LLM 进行合并、去重、提炼、归纳
  • 每次推理时自动注入 System Prompt,作为全局背景知识
  • 受 maxContextTokens 限制,防止记忆太长撑爆上下文

这两层的关系,就像日记本和整理后的笔记——日记本记录每天发生的所有事情(原始、粗糙、不删改),整理后的笔记则是从日记本中提炼出的精华(精炼、结构化、定期更新)。关于更多细节这里就不赘述了,直接看下面的实现。

3. 记忆流水线的三次 LLM 调用

记忆的沉淀涉及三次独立的 LLM 调用,每次的职责和触发时机都不同:

#操作写入目标触发时机可自定义
1Flush(冲刷)memory/YYYY-MM-DD.md每轮对话结束flushPrompt
2Consolidation(合并)MEMORY.md后台定时任务consolidationPrompt
3Compaction(压缩)上下文摘要上下文超限时summaryPrompt

Flush 从当前对话中提取关键事实,追加到当天的日记本中。Consolidation 定期读取日记本,调用 LLM 合并去重后重写 MEMORY.md。Compaction 在上下文过长时压缩历史消息,释放上下文空间。

注意:Flush 和 Consolidation 是"记忆沉淀"的两步——先收集原材料,再加工成成品。而 Compaction 是"上下文管理"的手段——它压缩的是当前会话的历史消息,和长期记忆是两个独立的功能,不要搞混了。

4. 配置记忆行为

HarnessAgent agent = HarnessAgent.builder()
        .name("note-taker")
        .model("glm:glm-4-flash")
        .workspace(workspace)
        .memory(MemoryConfig.builder()
                .consolidationMinGap(Duration.ofHours(2))   // 后台合并最少 2 小时一次
                .dailyFileRetentionDays(30)                 // 每日日志保留 30 天
                .sessionRetentionDays(60)                   // 会话日志保留 60 天
                .consolidationMaxTokens(8_000)              // MEMORY.md 上限 8K tokens
                .flushPrompt("从对话中提取关键事实,写入每日记忆日志。")  // 自定义 Flush Prompt
                .consolidationPrompt("合并每日记忆日志到 MEMORY.md,保持精炼。")  // 自定义 Consolidation Prompt
                .build())
        .build();

如果不想要默认的记忆行为,也可以完全关闭:

.disableMemoryHooks()   // 关闭 Flush 和 Consolidation
.disableMemoryTools()   // 关闭 memory_search/memory_get 工具

四、System Prompt 的运行时组装:一次推理,一次加载

讲完了 AGENTS.md 和 MEMORY.md,我们来看看它们是怎么变成 System Prompt 的。

整个过程由 WorkspaceContextMiddleware 驱动,每次推理开始前执行:

┌─────────────────────────────────────────────────────────────┐
│                    推理开始                                 │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│  Step 1: 读取 AGENTS.md                                    │
│  → 从 workspace/AGENTS.md 读取全部内容                     │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│  Step 2: 读取 MEMORY.md(受 maxContextTokens 限制)        │
│  → 从 workspace/MEMORY.md 读取,超出部分截断               │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│  Step 3: 读取 additionalContextFile 指定的文件             │
│  → SOUL.md、PREFERENCES.md、COMPANY_RULES.md 等           │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│  Step 4: 组装最终 System Prompt                            │
│  → sysPrompt + AGENTS.md + MEMORY.md + 额外文件           │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│  Step 5: 传递给 ReActAgent 开始推理                       │
└─────────────────────────────────────────────────────────────┘

请注意——这个过程是每轮推理重新执行的。所以:

  • 改了 AGENTS.md → 下一轮生效
  • 后台合并了 MEMORY.md → 下一轮生效
  • 新增了额外文件 → 下一轮生效

"改文件即升级"的本质,就是"每轮推理重新加载文件内容"。就是这么骚的操作。

五、Workspace 全景:一张图看懂"大脑外化"

完整的 Workspace 目录结构长这样:

来自官方说明文档:https://java.agentscope.io/v2/zh/docs/harness/workspace.html#id3open in new window

.agentscope/workspace/
├── AGENTS.md                    ← 人格:我是谁?(工程师手动维护)
├── MEMORY.md                    ← 长期记忆:我知道什么?(框架自动维护)
├── memory/                      ← 记忆原材料:每日事实流水账
│   └── YYYY-MM-DD.md            ← 只追加,不修改,不去重
├── knowledge/                   ← 知识:我懂什么?(工程师手动维护)
│   └── KNOWLEDGE.md
├── skills/                      ← 技能:我会做什么?(可复用能力包)
│   └── <skill-name>/SKILL.md
├── subagents/                   ← 子 Agent:我能指挥谁?
│   └── <agent-id>.md
├── plans/                       ← 运行时:Plan Mode 写下的计划文件
│   └── PLAN.md
├── tools.json                   ← 工具白名单:我能用什么工具?
└── agents/<agentId>/            ← 运行时数据:每次对话的痕迹
    ├── sessions/                ← 会话日志(永不压缩,全量留存)
    └── tasks/                   ← 子 Agent 任务记录

这张图背后有一个清晰的分工逻辑:

目录/文件谁在维护生命周期改它有什么用?
AGENTS.mdopen in new window工程师静态改 Agent 的"性格"
MEMORY.mdopen in new window框架自动动态演化改 Agent 的"记忆"
memory/框架自动动态演化记忆的"原材料"
knowledge/工程师静态改 Agent 的"知识储备"
skills/工程师静态改 Agent 的"能力"
subagents/工程师静态改 Agent 能"指挥谁"
agents/框架自动动态运行时数据,用于恢复

静态部分(工程师维护)定义 Agent 的"先天"属性——人格、知识、能力、子 Agent。动态部分(框架自动维护)记录 Agent 的"后天"积累——记忆、会话、任务。

这就是"大脑外化"的完整图景:Agent 的先天属性和后天积累,全部以文件形式存在于一个目录中。

六、实测:看一个 Agent 如何"长大"

光说不练假把式。接下来我们来跑一个完整的示例,看 Agent 的人格和记忆是如何随文件一起演化的。

1. 初始化 Workspace

package com.git.hui.springai.agentscope;

import io.agentscope.core.agent.RuntimeContext;
import io.agentscope.core.message.UserMessage;
import io.agentscope.extensions.model.openai.OpenAIChatModel;
import io.agentscope.extensions.model.openai.formatter.OpenAIChatFormatter;
import io.agentscope.harness.agent.HarnessAgent;
import io.agentscope.harness.agent.memory.MemoryConfig;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;

public class BrainExternalizationDemo {

    public static void main(String[] args) throws Exception {
        // 指定工作区路径
        Path workspace = Paths.get(".agentscope/workspace");

        // 初始化 AGENTS.md(如果不存在)
        initWorkspaceIfAbsent(workspace);

        // 创建 HarnessAgent
        HarnessAgent agent = HarnessAgent.builder()
                .name("note-taker")
                .model(OpenAIChatModel.builder()
                        .apiKey(EnvUtil.getZhipuApiKey())
                        .baseUrl("https://open.bigmodel.cn/api/paas")
                        .endpointPath("/v4/chat/completions")
                        .modelName("GLM-4-Flash")
                        .stream(true)
                        .formatter(new OpenAIChatFormatter())
                        .build())
                .workspace(workspace)
                .memory(MemoryConfig.builder()
                        .build())
                .build();

        // 第一轮对话:用户介绍自己
        System.out.println("=== 第一轮对话 ===");
        String reply1 = agent.call(
                List.of(new UserMessage("你好!我叫张三,我在做一个电商平台的"
                        + "微服务重构,用的 Spring Cloud Alibaba。")),
                RuntimeContext.builder().sessionId("demo-session").build()
        ).block().getTextContent();
        System.out.println("Agent: " + reply1);

        // 第二轮对话:看 Agent 是否记住了
        System.out.println("\n=== 第二轮对话 ===");
        String reply2 = agent.call(
                List.of(new UserMessage("我还在做微服务重构吗?我的技术栈是什么?")),
                RuntimeContext.builder().sessionId("demo-session").build()
        ).block().getTextContent();
        System.out.println("Agent: " + reply2);

        // 打印 MEMORY.md 看看内容
        System.out.println("\n=== MEMORY.md 内容 ===");
        Path memoryMd = workspace.resolve("demo-session/MEMORY.md");
        if (Files.exists(memoryMd)) {
            Files.readAllLines(memoryMd).forEach(System.out::println);
        }
    }

    private static void initWorkspaceIfAbsent(Path workspace) throws Exception {
        Files.createDirectories(workspace);
        Path agentsMd = workspace.resolve("AGENTS.md");
        if (!Files.exists(agentsMd)) {
            Files.writeString(agentsMd, """
                    # 随身笔记助手

                    你是一个帮助用户整理笔记和知识的助手。

                    ## 行为准则
                    - 主动记录用户提到的关键事实(姓名、计划、偏好等)
                    - 在回答中使用这些信息,让对话更个性化
                    - 回复简洁,适当使用列表
                    """);
        }
    }
}

2. 运行结果

第一次运行时,Workspace 目录下会自动生成 AGENTS.mdopen in new window(通过 initWorkspaceIfAbsent),以及后续对话产生的 memory/ 和 sessions/ 目录。

演示结果如下:

as1.jpg
as1.jpg

3. "改文件即升级"演示

现在,假设我们想改变 Agent 的回复风格——从"简洁"变成"详细,给出完整的分析和示例代码"。

传统方式:改代码 → 编译 → 打包 → 部署 → 重启

Workspace 方式:打开 AGENTS.md,把"回复简洁"改成"回复详细,给出完整的分析和示例代码" → 保存 → 下一轮对话自动生效

# AGENTS.md(修改后)
## 行为准则
- 主动记录用户提到的关键事实
- 在回答中使用这些信息,让对话更个性化
- 回复详细,给出完整的分析和示例代码  ← 只改了这里

第三轮对话的输出结果如下:

as2.jpg
as2.jpg

整个过程中,可以实现无需重启 JVM,只是编辑了一个文件,实现Agent回答风格的调整

4. 一个更深层的观察

这个示例揭示了一个更深层的真相:Agent 的"成长"不再依赖于代码变更,而是依赖于文件变更。

在传统架构中,Agent 的能力提升意味着"改代码 → 发版"。在 Workspace 架构中,Agent 的能力提升意味着"改文件 → 保存"。前者是"周级别"的迭代周期,后者是"秒级别"的迭代周期。

这不只是一个"方便"的问题——这是一个迭代速度的数量级跃升。

七、小结

我们从"大脑外化"的视角,重新审视了 HarnessAgent Workspace 的完整机制:

概念文件作用谁在维护生效方式
人格AGENTS.mdopen in new window定义 Agent 的"我是谁"工程师手动每轮推理重新加载
长期记忆MEMORY.mdopen in new window记录 Agent 的"我知道什么"框架自动每轮推理重新加载
记忆原材料memory/YYYY-MM-DD.md每日事实流水账框架自动Flush 时追加
领域知识knowledge/Agent 的"我懂什么"工程师手动按需加载
技能skills/Agent 的"我会做什么"工程师手动按需加载
子 Agentsubagents/Agent 的"我能指挥谁"工程师手动启动时加载

作为一个勤于思考的旧时代码农,我觉得 Workspace 的本质,不是"把配置写在文件里"这么简单。它是一种架构范式的转变:

  • 从"代码定义 Agent"到"文件定义 Agent"
  • 从"内存中的瞬时状态"到"磁盘上的持久化大脑"
  • 从"黑盒式 Agent"到"白盒式 Agent"
  • 从"周级别的迭代"到"秒级别的迭代"

Workspace 让 Agent 的大脑变得可见、可编辑、可演化——这就是"大脑外化"的力量。

下一篇文章,我们将进入 Skills 技能系统。如果说 Workspace 是 Agent 的"大脑",那 Skills 就是 Agent 的"肌肉记忆"——通过 SKILL.md 文件协议,让 Agent 按需加载"操作手册 + 资料包",既节省 Token,又能力无限扩展。看到这里的小伙伴,不妨点个赞,顺手关注下微信公众号微信公众号:一灰灰Blog,咱们下篇见!

八、其他

0. 项目

1. 下篇预告

第一阶段:新手村 —— 核心概念与快速起步

第二阶段:进阶架构 —— 掌握 2.0 的核心亮点 HarnessAgent,理解"文件即配置"的工程化理念。

  • ✅ 6.HarnessAgent:为 ReActAgent 装上操作系统open in new window:对比 ReActAgent,理解 Harness 如何整合长期记忆、Session、子 Agent 编排与沙箱。
  • ✅ 7. Workspace 驱动的人格与记忆(下一篇):通过 AGENTS.md 定义人设,通过 MEMORY.md 沉淀长期事实,实现"改文件即升级 Agent"。
  • 8. Skills 技能系统(核心):掌握 SKILL.md 文件协议,理解"操作手册 + 资料包"的按需加载机制,节省 Token。
  • 9. 多层级 SkillRepository 组合:实战 Workspace、Git、Nacos、MySQL 等 5 层仓库的组合与隔离。
  • 10. 流式事件与前端交互:使用 streamEvents() 实时展示 Agent 执行过程,对接 Web UI 渲染。

尽信书则不如无书,以上内容纯属一家之言。因个人能力有限,难免有疏漏和错误之处,如发现 Bug 或有更好的建议,欢迎批评指正,不吝感激。


Loading...