Exclusive Interview with Hermes Founding Team: Why Open-Source Agents Must "Have Memory" — A Conversation Revealing Product Philosophy

"If every time you talk to someone, they forget who you are — would you consider them intelligent?"

When the co-founder of Nous Research posed this question in a San Francisco coffee shop, the conversation at the table fell silent for two seconds. It's a seemingly simple yet soul-piercing question: today, the vast majority of AI Agents are precisely that "someone who forgets who you are every time."

Hermes, the open-source agent framework under Nous Research, is attempting to change this. It is not merely an Agent that can call tools and run tasks — its core ambition is to give agents genuine "memory."

This might sound like yet another trendy concept in the tech world, but after a deep conversation with the Hermes founding team, we discovered: memory is not a nice-to-have feature, but the foundational condition for an agent to evolve from a "tool" into a "partner." And open source is the only path to ensure this evolution doesn't spiral out of control.

1. The "Memory-less Agent" Dilemma: Every Conversation Is an Amnesiac Restart

In today's AI application ecosystem, the vast majority of Agents face an awkward reality: they have no persistent memory.

You spend an entire afternoon discussing project architecture with an Agent, mapping out technology choices, module divisions, and interface design. The next day, you open the same Agent, and it looks at you and says: "Hello, I'm an AI assistant. How can I help you?"

Everything resets to zero.

The Hermes team illustrated this problem with a more concrete example: imagine you have an Agent manage your code repository. The first time, you spend considerable effort explaining the project's directory structure, coding standards, and branching strategy. The Agent performs well — in that one conversation. But the next conversation, it has to learn everything from scratch again.

"It's like hiring a genius employee who loses their memory every morning," described a core team member. "They might have an IQ of 200, but you have to retrain them every day. This isn't an efficiency problem; it's a fundamental architectural flaw."

The pain points of memory-less agents extend far beyond "repetitive labor":

• Inability to accumulate experience: Agents cannot learn from past mistakes and may repeat the same errors
• Context fragmentation: Cross-session tasks cannot connect, and complex projects are split into isolated conversations
• Zero personalization: Agents don't understand your preferences, habits, or decision-making style — every response is a "standard answer"
• Soaring collaboration costs: Every new conversation requires rebuilding context, and the user's time cost far exceeds the Agent's compute cost

This is not an experience optimization problem; it's a structural defect. An agent without memory is essentially a stateless function call — input instruction, output result, leave no trace.

2. Hermes Memory Architecture: A Three-Layer System, from "Conversation" to "Cognition"

Faced with this structural defect, Hermes didn't opt for the simple "add a database" solution. The team designed a three-layer memory architecture, with each layer addressing a different dimension of the problem.

Short-Term Memory: Conversational Context Window

This is the most intuitive layer — the current conversation context. Hermes's short-term memory management is not simply stuffing all historical messages into the prompt; instead, it employs a dynamic context window strategy:

• Key information extraction: Extracting key decisions and conclusions from long conversations to avoid token waste
• Context priority ranking: Current task-related information takes priority; casual chat information gets deprioritized
• Window sliding mechanism: When conversation exceeds context length, gracefully "forgetting" the least important parts

"The goal of short-term memory is not to remember everything, but to maintain the highest information density within a limited window," the team explained.

Long-Term Memory: Persistent Storage

This is the core of Hermes's memory system — cross-session persistent storage. Unlike simple "conversation history saving," Hermes's long-term memory functions more like a structured knowledge base:

• User preferences: Your preferred code style, commonly used tech stacks, preferred output formats
• Project knowledge: Project structure, key decision records, technical debt list
• Historical decisions: Choices made in the past and their rationale, avoiding repeated discussions of already-decided matters
• Error experiences: Mistakes made previously and their corrections, forming a "lessons learned" repository

Long-term memory is not saving all conversation records — that's data hoarding, not memory. The Hermes team emphasized that genuine memory is the compression and refinement of raw information, retaining only what has value for future decisions.

Working Memory: Task Execution State

The third layer is working memory, focused on the "present": where the current task stands, which tools have already been called, and what the intermediate results are. The core challenge of this layer is: when executing complex tasks, agents often need to call multiple tools and complete multiple sub-steps; if intermediate state is lost, the entire task collapses.

Hermes's working memory mechanism ensures:

• Task state persistence: Execution can resume even after tool call interruptions
• Tool call chain tracing: Complete logging of tool call history, supporting retrospection and debugging
• Parallel task isolation: Multiple concurrent tasks don't interfere with each other

The coordinated operation of the three-layer architecture transforms Hermes's Agent from a "stateless API caller" into a truly capable agent that can accumulate, learn, and grow.

3. Open-Source Memory vs. Closed-Source Memory: The Watershed of Data Sovereignty

When memory becomes a core capability of agents, a fundamental question surfaces: Where is your Agent's memory stored? Who controls it?

The importance of this question far exceeds most people's imagination.

The Memory Dilemma of Closed-Source Products

Current mainstream closed-source AI products (ChatGPT's Memory, Claude's project memory, etc.) all provide some degree of memory capability. But they share a common underlying architecture: memory is stored on the vendor's servers.

What does this mean?

• You cannot audit: What information has your Agent memorized about you? You don't know. You can only see the parts it "chooses to show" you.
• You cannot migrate: Want to switch to a different Agent platform? Your memories cannot come with you. A year of accumulated context with one Agent resets to zero the moment you switch platforms.
• You cannot truly delete: You clicked "clear memory," but what about server-side backups? Residual data in training datasets? You cannot confirm.
• You cannot control access: Who can read your Agent's memories? Vendor employees? Partners? Government data requests? The vague language in terms of service gives too much room for interpretation.

The Hermes team has a precise analogy for this: "Memory in closed-source products is like writing your diary in someone else's notebook. You can write, you can read, but the notebook is in someone else's hands."

The Core Promise of Open-Source Memory

Hermes chose open source not just for code openness — it's a promise of data sovereignty:

• You decide the storage location: Whether memory is stored locally, on a private cloud, or on a public cloud is your choice. Hermes supports multiple storage backends that users can configure themselves.
• Fully transparent data: All memory data formats, structures, and storage methods are completely public. You can view, export, and edit at any time.
• Zero-cost migration: Because formats are open and protocols are standardized, you can migrate memory from one Hermes instance to another, or to compatible third-party systems.
• Encryption and access control: Worried about privacy? Hermes supports end-to-end encrypted memory storage that only your key can decrypt. No one — including Hermes's developers — can read your encrypted memories.

"The essence of open source is not 'free,'" the team repeatedly emphasized during our conversation. "It's 'controllable.' When your Agent remembers all your preferences, habits, and project secrets, you must have the ability to audit and control those memories. This isn't a feature requirement; it's a right."

4. Memory Security: When Privacy Meets Intelligence

The stronger the memory capability, the greater the privacy risk. This is one of the issues the Hermes team takes most seriously.

The team shared a thought-provoking scenario: an Agent has memorized all your work conversations from the past three months. These conversations may contain API keys, business plans, client information, personal health conditions... If these memories were leaked, the consequences would far exceed an ordinary data breach — because an Agent's memory is structured and relational. An attacker wouldn't need to piece together fragments; everything is already organized.

Hermes's memory security strategy includes:

1. Layered encryption: Memories of different sensitivity levels use encryption of varying strengths
2. Access control: Fine-grained permission management controlling which Agent instances can access which memories
3. Memory forgetting: Support for precisely "forgetting" specific information without affecting other memories
4. Audit logging: All memory access behaviors have complete logs, supporting post-hoc tracing
5. Local-first: Sensitive memories are stored locally by default, without network transmission

"Security is not a feature," the team said. "It's the infrastructure of the memory architecture. If your Agent memory system isn't designed security-first, then the stronger the memory capability, the more dangerous it becomes."

5. Future Direction: From Individual Memory to Collective Intelligence

At the end of the conversation, we asked about the future direction of Hermes's memory system. The team's answer revealed a larger vision.

Cross-Agent Memory Sharing

When multiple Agents collaborate, they need to share context. For example, your code Agent and documentation Agent need to share project knowledge; your research Agent and writing Agent need to share material libraries. Hermes is designing a secure cross-Agent memory sharing protocol that enables collaboration while protecting privacy.

Memory Compression and Retrieval Optimization

As usage time grows, memory data continuously expands. Hermes is developing more efficient memory compression algorithms — not simply deleting old memories, but intelligently extracting patterns and rules. Just as humans don't need to remember the verbatim record of every conversation but do remember the other person's personality and preferences.

Metacognitive Capability

The most distant vision: enabling Agents not only to have memory but to "reflect" on it. Knowing which memories are reliable, which may be outdated, and which need updating. This approaches human "metacognition" — thinking about one's own thinking process.

6. Product Philosophy: Open Source Is a Promise of "User-Controlled Data"

Looking back at the entire conversation, the Hermes team repeatedly returned to a core proposition: Open source is not just code openness; it's a promise of "users controlling their own data."

In the Agent era, memory is data, and data is power. If Agent memories are monopolized by a few companies, users will lose fundamental control over their digital lives. This is not alarmism — when an Agent remembers all your decision preferences, work habits, and interpersonal relationships, its understanding of you may exceed your own self-knowledge.

Open source is a structural solution to balance this power. Open code means anyone can audit the memory system's implementation; community-driven means no single point of control; local deployment means data never leaves your sphere of control.

"We believe," the team said before the conversation ended, "that the future of agents is not about having a smarter tool do things for you, but about you having a digital partner that truly understands you, respects you, and is under your control. Memory is the cornerstone of this vision, and open source is the guardrail ensuring it's not abused."

7. Kaihe: Making "Memory Never Leaves Local" a Reality

Hermes's open-source memory philosophy finds its most natural landing point on Kaihe's Agent Computer.

The Kaihe A1 is a locally-operated Agent Computer — all computation, storage, and network communication of the Agent are completed locally. This means Hermes's long-term memory can be stored entirely on the local hard drive, without any cloud intermediary. Your Agent remembers all your preferences and project knowledge, and these memories have never left the device sitting on your desk.

"Memory never leaves local" is not a marketing slogan; it's the natural consequence of Kaihe's hardware architecture. When computing is local, storage is local, and network egress is local, your Agent's memory inherently possesses data sovereignty — no need to trust any third party, because you are the alternative to the third party.

For developers and enterprises concerned about privacy, the Kaihe + Hermes combination provides a reassuring equation: Open-source Agent framework + Local Agent Computer = Fully controlled memory. No cloud vendor can read your memories; no platform migration will lose your context; no terms-of-service change will threaten your data sovereignty.

This is not a hypothetical future. Today, you can deploy Hermes on the Kaihe A1 and experience an agent with memory, experience, and growth — all under your control.

---

KaiheAiBox · Hermes Zone