# We Gave an AI Agent a Conscious and Subconscious Mind
**作者**: Mercury
**日期**: 2026-05-20T17:12:52.000Z
**来源**: [https://x.com/mercury__agent/status/2057147558615802051](https://x.com/mercury__agent/status/2057147558615802051)
---
Most AI agents do not remember.
They reconstruct.
Every new session becomes a ritual of reloading summaries, files, embeddings, logs, and prior conversations back into a prompt. The model appears continuous, but the continuity is mostly simulated.
That distinction matters.
A larger context window is not the same thing as memory.
Research from Stanford’s “Lost in the Middle” paper showed that language models often struggle to retrieve information placed in the middle of very long contexts, even when the context technically fits within the model’s limits. (arxiv.org)
So the real challenge is not simply:
> “How much context can an AI agent hold?”
The harder question is:
> “What should an AI agent actively remember, what should it archive, and what should it bring back later?”
That is the problem Mercury’s Second Brain was designed to solve.
Not memory as storage.
Memory as lifecycle.
The Problem With Most AI Agents
Most AI agents today still operate like stateless chat interfaces with tools attached.
They can:
- call APIs
- read files
- execute commands
- browse repositories
- summarize information
- generate code
But they often fail at continuity.
A useful long-running agent needs to remember:
- ongoing projects
- user preferences
- previous decisions
- failed approaches
- recurring workflows
- relationships between ideas
- unfinished tasks
- operational constraints
- behavioral patterns over time
Without continuity, every session becomes reconstruction.
That does not scale.
This is not just a product issue anymore. It is becoming a systems problem.
Research has already been moving in this direction.
Generative Agents
Stanford’s Generative Agents paper introduced agents that store experiences, synthesize reflections, and dynamically retrieve memory for future planning and behavior. The work demonstrated that believable long-running agents require more than raw generation. They require memory organization and retrieval. (arxiv.org)
Reflexion
The Reflexion framework showed that agents can improve through verbal reinforcement by storing lessons from previous failures in episodic memory instead of retraining the model itself. (arxiv.org)
MemGPT
MemGPT proposed something even more important: memory hierarchy for language agents.
Instead of treating context as infinite, MemGPT framed the problem similarly to operating systems, where active memory and archival memory are managed separately. (arxiv.org)
That idea heavily aligns with the direction Mercury is taking.
Because the future bottleneck for AI agents is no longer only intelligence.
It is continuity.
# Conscious and Subconscious Memory
Mercury’s Second Brain introduces a dual-layer memory architecture:
## Conscious Memory
The conscious layer contains memory that should remain actively available during execution.
Examples:
- current projects
- active goals
- ongoing tasks
- user preferences
- recent decisions
- important operational state
This is the working layer.
The agent actively reasons over this information.
## Subconscious Memory
The subconscious layer stores information that still matters, but should not continuously occupy active context.
Instead of deleting older context entirely, Mercury moves dormant but meaningful memory below the active layer until it becomes relevant again.
That creates three important behaviors:
1. Dormancy
Not every memory should remain active forever.
Continuous active recall creates:
- noisy prompts
- token inefficiency
- degraded reasoning quality
- duplicated context injection
2. Resurfacing
Older context should reappear when the current task makes it relevant again.
A project discussed weeks ago may suddenly matter during deployment.
A previous failure may become useful during debugging.
A user preference may return during workflow execution.
The system should recover that context naturally.
3. Controlled Forgetting
Memory should not disappear accidentally because a context window overflowed.
Users should be able to:
- dismiss memory intentionally
- inspect stored context
- understand why memory exists
- correct stale information
- maintain ownership over persistence
This is one of the biggest missing primitives in current AI agents.
Most systems either:
- forget too aggressively
- or remember too aggressively
Mercury attempts to manage memory as a lifecycle instead of a static vector database.
# Why This Matters Beyond Chat
The larger shift is that AI agents are slowly evolving into operational runtimes.
The interface is no longer just a chat window.
Mercury combines:
- persistent memory
- Git-aware workflows
- workspace execution
- terminal operations
- Kanban orchestration
- permission-gated actions
- token-aware runtime behavior
- local-first infrastructure
At that point, the architecture starts looking less like a chatbot and more like an operating layer for long-running AI systems.
That distinction matters.
Because real work requires:
- continuity
- planning
- recovery
- inspection
- permissions
- execution state
- task persistence
Without those primitives, “autonomous agents” become fragile loops with temporary context.
# The Kanban Layer
Mercury’s Kanban system is designed around operational continuity.
Tasks are persistent.
Dependencies are tracked.
Execution state survives sessions.
The agent can:
- pause execution
- ask for clarification
- resume later
- maintain project continuity
- operate across dependency chains
That changes the role of the agent.
The system is no longer generating isolated responses.
It is maintaining workflow state over time.
This is a critical difference between:
- prompt execution
- and agent execution
# Why Memory Architecture Matters More Than Bigger Context Windows
The AI industry has focused heavily on context length:
- 128k
- 1M
- 10M token contexts
But larger context windows alone do not solve:
- relevance prioritization
- memory lifecycle
- stale context
- duplicate memory
- long-term continuity
- operational recall
- dormant knowledge resurfacing
More context is not automatically better memory.
A useful agent needs to decide:
- what stays active
- what becomes dormant
- what should resurface later
- what should be removed entirely
That is memory architecture.
Not prompt engineering.
# Benchmarks That Actually Matter for AI Agents
We believe AI agent memory systems should eventually be evaluated using operational benchmarks, not just isolated prompt accuracy.
The important measurements are things like:
Recall latency
How quickly the agent retrieves relevant long-term memory.
Context efficiency
How many tokens are required to restore useful working state.
Duplicate memory rate
Whether the system repeatedly stores the same information.
Long-session continuity
Whether the agent preserves state across time.
Task resumption accuracy
Whether interrupted workflows recover correctly.
Permission safety
Whether sensitive actions remain user-controlled.
Memory relevance precision
Whether recalled memory is actually useful.
Stale-memory handling
Whether outdated information can be corrected.
These are closer to real-world agent behavior than benchmark prompts alone.
Because the real challenge is not:
> “Can the model answer one question?”
The challenge is:
> “Can the system maintain useful operational state over weeks of work?”
# The Shift From Chatbots to Agent Operating Systems
ReAct introduced interleaved reasoning and action loops. (arxiv.org)
Toolformer explored models deciding when to use tools autonomously. (arxiv.org)
Generative Agents explored reflective memory systems. (arxiv.org)
MemGPT explored hierarchical memory management. (arxiv.org)
Mercury attempts to connect those ideas into a practical runtime:
- memory
- tools
- permissions
- workspace execution
- Git integration
- Kanban orchestration
- persistent state
- local-first ownership
That is the larger thesis.
AI agents are not just becoming better chatbots.
They are becoming operating environments.
# The Controversial Part
If an AI agent cannot remember what matters, it is not really assisting you.
It is repeatedly meeting you for the first time.
The next generation of agents will not be defined only by:
- larger models
- longer context windows
- faster inference
They will be defined by:
- memory management
- continuity
- permission systems
- operational state
- long-running execution
- user ownership
- workflow persistence
That is why we gave Mercury a conscious and subconscious memory layer.
Not because it sounds futuristic.
Because long-running agents need a memory architecture designed for real work.
# Research Notes
Academic References
- “Lost in the Middle: How Language Models Use Long Contexts”
Nelson F. Liu et al.
https://arxiv.org/abs/2307.03172
- “Generative Agents: Interactive Simulacra of Human Behavior”
Joon Sung Park et al.
https://arxiv.org/abs/2304.03442
- “Reflexion: Language Agents with Verbal Reinforcement Learning”
Noah Shinn et al.
https://arxiv.org/abs/2303.11366
- “ReAct: Synergizing Reasoning and Acting in Language Models”
Shunyu Yao et al.
https://arxiv.org/abs/2210.03629
- “Toolformer: Language Models Can Teach Themselves to Use Tools”
Timo Schick et al.
https://arxiv.org/abs/2302.04761
- “MemGPT: Towards LLMs as Operating Systems”
Charles Packer et al.
https://arxiv.org/abs/2310.08560
# Mercury
Mercury is a local-first AI agent runtime focused on:
- persistent memory
- permission-aware execution
- Git-native workflows
- Kanban orchestration
- long-running operational continuity
- token-aware runtime behavior
- extensible agent skills
GitHub Repository:
Mercury Agent GitHub Repository
Documentation:
Mercury Documentation
## 相关链接
- [Mercury](https://x.com/mercury__agent)
- [@mercury__agent](https://x.com/mercury__agent)
- [7.4K](https://x.com/mercury__agent/status/2057147558615802051/analytics)
- [arxiv.org](https://arxiv.org/abs/2307.03172)
- [arxiv.org](https://arxiv.org/abs/2304.03442)
- [arxiv.org](https://arxiv.org/pdf/2310.08560)
- [arxiv.org](https://arxiv.org/abs/2302.04761)
- [https://arxiv.org/abs/2307.03172](https://arxiv.org/abs/2307.03172)
- [https://arxiv.org/abs/2304.03442](https://arxiv.org/abs/2304.03442)
- [https://arxiv.org/abs/2303.11366](https://arxiv.org/abs/2303.11366)
- [https://arxiv.org/abs/2210.03629](https://arxiv.org/abs/2210.03629)
- [https://arxiv.org/abs/2302.04761](https://arxiv.org/abs/2302.04761)
- [https://arxiv.org/abs/2310.08560](https://arxiv.org/abs/2310.08560)
- [Mercury Agent GitHub Repository](https://github.com/cosmicstack-labs/mercury-agent)
- [Mercury Documentation](https://mercury.cosmicstack.org/)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [1:12 AM · May 21, 2026](https://x.com/mercury__agent/status/2057147558615802051)
- [7,446 Views](https://x.com/mercury__agent/status/2057147558615802051/analytics)
- [View quotes](https://x.com/mercury__agent/status/2057147558615802051/quotes)
---
*导出时间: 2026/5/21 10:17:36*
---
## 中文翻译
# 我们赋予了一个 AI 智能体意识和潜意识思维
**作者**: Mercury
**日期**: 2026-05-20T17:12:52.000Z
**来源**: [https://x.com/mercury__agent/status/2057147558615802051](https://x.com/mercury__agent/status/2057147558615802051)
---
大多数 AI 智能体并不记忆。
它们在重构。
每一个新会话都变成了一场加载摘要、文件、嵌入向量、日志和先前对话回提示词的仪式。模型看起来是连续的，但这种连续性大多是模拟出来的。
这种区别很重要。
更大的上下文窗口并不等同于记忆。
斯坦福大学“迷失在中间” 的研究表明，语言模型在检索位于非常长上下文中间位置的信息时往往很吃力，即使从技术上讲，这些上下文符合模型的限制。 (arxiv.org)
因此，真正的挑战不仅仅是：
> “一个 AI 智能体能容纳多少上下文？”
更难的问题是：
> “AI 智能体应该主动记住什么，应该归档什么，以及应该稍后取回什么？”
这就是 Mercury 的“第二大脑”旨在解决的问题。
不是作为存储的记忆。
而是作为生命周期的记忆。
大多数 AI 智能体的问题
当今大多数 AI 智能体仍然像连接了工具的无状态聊天界面一样运作。
它们可以：
- 调用 API
- 读取文件
- 执行命令
- 浏览代码仓库
- 总结信息
- 生成代码
但它们往往在连续性上表现失败。
一个有用的长期运行的智能体需要记住：
- 进行中的项目
- 用户偏好
- 之前的决定
- 失败的方法
- 重复性工作流
- 想法之间的关联
- 未完成的任务
- 操作限制
- 随时间变化的行为模式
没有连续性，每个会话都变成了重构。
这无法扩展。
这不再仅仅是一个产品问题，它正在演变成一个系统问题。
研究已经在朝着这个方向发展。
生成式智能体
斯坦福大学的生成式智能体论文引入了能够存储经验、合成反思并为未来规划和行为动态检索记忆的智能体。这项工作表明，可信的长期运行的智能体不仅仅需要原始生成能力，它们需要记忆组织和检索。 (arxiv.org)
Reflexion
Reflexion 框架表明，智能体可以通过言语强化来改进，方法是将先前失败的教训存储在情景记忆中，而不是重新训练模型本身。 (arxiv.org)
MemGPT
MemGPT 提出了一个更重要的概念：语言智能体的记忆层级。
MemGPT 不再将上下文视为无限的，而是将问题类比为操作系统，其中活动内存和归档内存是分开管理的。 (arxiv.org)
这个想法与 Mercury 的方向高度一致。
因为 AI 智能体的未来瓶颈不再仅仅是智能。
而是连续性。
# 意识与潜意识记忆
Mercury 的第二大脑引入了双层记忆架构：
## 意识记忆
意识层包含在执行期间应保持活动可用性的记忆。
例如：
- 当前项目
- 活跃目标
- 进行中的任务
- 用户偏好
- 最近的决定
- 重要的操作状态
这是工作层。
智能体在此层之上进行积极的推理。
## 潜意识记忆
潜意识层存储仍然重要，但不应该持续占据活动上下文的信息。
Mercury 不会完全删除旧的上下文，而是将那些休眠但有意义的记忆移动到活动层之下，直到它们再次变得相关。
这创造了三种重要的行为：
1. 休眠
并非每个记忆都应该永远保持活跃。
持续的主动回忆会导致：
- 噪杂的提示词
- Token 效率低下
- 推理质量下降
- 上下文重复注入
2. 浮现
当当前任务使旧的上下文再次相关时，它应该重新出现。
几周前讨论的项目可能在部署期间突然变得重要。
之前的失败可能在调试期间变得有用。
用户偏好可能在执行工作流时回归。
系统应该自然地恢复该上下文。
3. 可控遗忘
记忆不应因为上下文窗口溢出而意外消失。
用户应该能够：
- 有意解除记忆
- 检查存储的上下文
- 理解记忆存在的原因
- 更正过时信息
- 维持对持久化的所有权
这是当前 AI 智能体中最缺失的原语之一。
大多数系统要么：
- 遗忘得过于激进
- 要么记得过于激进
Mercury 试图将记忆作为一个生命周期来管理，而不是一个静态的向量数据库。
# 为什么这不仅仅关乎聊天
更大的转变在于，AI 智能体正慢慢演变为运行时操作环境。
界面不再仅仅是一个聊天窗口。
Mercury 结合了：
- 持久化记忆
- 感知 Git 的工作流
- 工作区执行
- 终端操作
- 看板编排
- 权限门控操作
- 感知 Token 的运行时行为
- 本地优先的基础设施
在这一点上，架构开始看起来不再像一个聊天机器人，而更像是长期运行的 AI 系统的操作系统层。
这种区别很重要。
因为真正的工作需要：
- 连续性
- 规划
- 恢复
- 检查
- 权限
- 执行状态
- 任务持久化
没有这些原语，“自主智能体”就会变成带有临时上下文的脆弱循环。
# 看板层
Mercury 的看板系统是围绕操作连续性设计的。
任务是持久化的。
依赖关系是被跟踪的。
执行状态在会话之间保留。
智能体可以：
- 暂停执行
- 请求澄清
- 稍后恢复
- 维持项目连续性
- 跨依赖链操作
这改变了智能体的角色。
系统不再生成孤立的响应。
它在随着时间推移维护工作流状态。
这是以下两者之间的关键区别：
- 提示词执行
- 智能体执行
# 为什么记忆架构比更大的上下文窗口更重要
AI 行业一直非常关注上下文长度：
- 128k
- 1M
- 10M token 上下文
但仅靠更大的上下文窗口无法解决：
- 相关性优先级排序
- 记忆生命周期
- 过时上下文
- 重复记忆
- 长期连续性
- 操作召回
- 潜在知识的浮现
更多的上下文并不自动意味着更好的记忆。
一个有用的智能体需要决定：
- 什么保持活跃
- 什么进入休眠
- 什么应该稍后浮现
- 什么应该被完全移除
这就是记忆架构。
不是提示词工程。
# 对 AI 智能体真正重要的基准
我们认为，AI 智能体记忆系统最终应该使用操作基准进行评估，而不仅仅是孤立的提示词准确性。
重要的衡量指标包括：
召回延迟
智能体检索相关长期记忆的速度有多快。
上下文效率
恢复有用的工作状态需要多少 Token。
重复记忆率
系统是否重复存储相同的信息。
长会话连续性
智能体是否随时间保持状态。
任务恢复准确性
被中断的工作流是否能正确恢复。
权限安全性
敏感操作是否仍由用户控制。
记忆相关性精度
被召回的记忆是否真的有用。
过时记忆处理
是否可以更正过时的信息。
这些比单纯的基准测试提示词更接近现实世界中的智能体行为。
因为真正的挑战不是：
> “模型能回答一个问题吗？”
挑战在于：
> “系统能否在数周的工作中维持有用的操作状态？”
# 从聊天机器人到智能体操作系统的转变
ReAct 引入了交错推理和行动循环。 (arxiv.org)
Toolformer 探索了模型自主决定何时使用工具。 (arxiv.org)
Generative Agents 探索了反思性记忆系统。 (arxiv.org)
MemGPT 探索了分层记忆管理。 (arxiv.org)
Mercury 试图将这些想法连接到一个实用的运行时中：
- 记忆
- 工具
- 权限
- 工作区执行
- Git 集成
- 看板编排
- 持久化状态
- 本地优先所有权
这就是更大的论点。
AI 智能体不仅仅是变得更好的聊天机器人。
它们正在成为操作环境。
# 有争议的部分
如果一个 AI 智能体记不住重要的事情，它并没有真正在帮助你。
它是一次又一次地第一次见你。
下一代智能体将不仅仅由以下因素定义：
- 更大的模型
- 更长的上下文窗口
- 更快的推理
它们将由以下因素定义：
- 记忆管理
- 连续性
- 权限系统
- 操作状态
- 长期运行
- 用户所有权
- 工作流持久化
这就是我们赋予 Mercury 意识和潜意识记忆层的原因。
并不是因为这听起来很未来主义。
而是因为长期运行的智能体需要一种为真正的工作而设计的记忆架构。
# 研究笔记
学术参考文献
- “Lost in the Middle: How Language Models Use Long Contexts”
Nelson F. Liu et al.
https://arxiv.org/abs/2307.03172
- “Generative Agents: Interactive Simulacra of Human Behavior”
Joon Sung Park et al.
https://arxiv.org/abs/2304.03442
- “Reflexion: Language Agents with Verbal Reinforcement Learning”
Noah Shinn et al.
https://arxiv.org/abs/2303.11366
- “ReAct: Synergizing Reasoning and Acting in Language Models”
Shunyu Yao et al.
https://arxiv.org/abs/2210.03629
- “Toolformer: Language Models Can Teach Themselves to Use Tools”
Timo Schick et al.
https://arxiv.org/abs/2302.04761
- “MemGPT: Towards LLMs as Operating Systems”
Charles Packer et al.
https://arxiv.org/abs/2310.08560
# Mercury
Mercury 是一个本地优先的 AI 智能体运行时，专注于：
- 持久化记忆
- 感知权限的执行
- Git 原生工作流
- 看板编排
- 长期运行的操作连续性
- 感知 Token 的运行时行为
- 可扩展的智能体技能
GitHub 仓库：
Mercury Agent GitHub Repository
文档：
Mercury Documentation
## 相关链接
- [Mercury](https://x.com/mercury__agent)
- [@mercury__agent](https://x.com/mercury__agent)
- [7.4K](https://x.com/mercury__agent/status/2057147558615802051/analytics)
- [arxiv.org](https://arxiv.org/abs/2307.03172)
- [arxiv.org](https://arxiv.org/abs/2304.03442)
- [arxiv.org](https://arxiv.org/pdf/2310.08560)
- [arxiv.org](https://arxiv.org/abs/2302.04761)
- [https://arxiv.org/abs/2307.03172](https://arxiv.org/abs/2307.03172)
- [https://arxiv.org/abs/2304.03442](https://arxiv.org/abs/2304.03442)
- [https://arxiv.org/abs/2303.11366](https://arxiv.org/abs/2303.11366)
- [https://arxiv.org/abs/2210.03629](https://arxiv.org/abs/2210.03629)
- [https://arxiv.org/abs/2302.04761](https://arxiv.org/abs/2302.04761)
- [https://arxiv.org/abs/2310.08560](https://arxiv.org/abs/2310.08560)
- [Mercury Agent GitHub Repository](https://github.com/cosmicstack-labs/mercury-agent)
- [Mercury Documentation](https://mercury.cosmicstack.org/)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [1:12 AM · May 21, 2026](https://x.com/mercury__agent/status/2057147558615802051)
- [7,446 Views](https://x.com/mercury__agent/status/2057147558615802051/analytics)
- [View quotes](https://x.com/mercury__agent/status/2057147558615802051/quotes)
---
*导出时间: 2026/5/21 10:17:36*