MindMemOS – Huawei Noah's Ark Open-Source AI Agent Memory Operating System

1. What is MindMemOS

MindMemOS is an open-source AI Agent memory operating system developed by Huawei Noah's Ark Lab, designed to address the fundamental flaw of traditional Agents, which forget historical information after each interaction. This system decouples memory from a single Agent, transforming it into an independent asset that can be reused across different frameworks. It employs a three-dimensional structure of entity-attribute-time to preserve the latest state and complete evolution trajectory, and through mechanisms such as Dreaming offline organization, Feedback closed-loop, and Skill Evolution self-advancement, it enables the co-evolution of memory and the system. It is positioned as the "memory operating system" for Agents, rather than a simple memory storage layer.

Image source: Official article
Image source: official article

Technical positioning and domain: MindMemOS belongs to the infrastructure of memory management in the field of artificial intelligence, focusing on providing persistent and structured memory capabilities for AI Agents. Unlike traditional memory solutions (such as vector databases or simple key-value storage), it is positioned as a "memory operating system," emphasizing the cross-application reuse and lifecycle management of memory as an independent asset, occupying a unique position in the Agent infrastructure layer.

Development background: Developed by Huawei Noah's Ark Lab, which has deep expertise in fundamental AI research, with multiple achievements in areas such as natural language processing and multimodal learning in the past. The motivation for development stems from the current lack of effective long-term memory mechanisms in AI Agents during practical applications, leading to each interaction starting from scratch, unable to accumulate user preferences, project backgrounds, and execution experiences, which severely limits the practicality and intelligence level of Agents.

Core value: Solving the fundamental issue of Agents "forgetting after use," through a three-dimensional memory structure, offline organization, and skill evolution, enabling Agents to continuously learn and adapt. Its core value lies in liberating memory from application bindings, achieving cross-framework and cross-scenario memory sharing and transfer, thereby reducing redundant development costs, improving Agent collaboration efficiency, and providing persistent user profile support for personalized services.

Technical features: It uses a three-dimensional graph structure of entity-attribute-time, supports dual-mode memory extraction (MindVanilla open-domain extraction and MindSchema rule-based extraction), and has differentiated capabilities such as offline consolidation (Dreaming automatically resolves conflicts and redundancies), feedback-driven optimization (Feedback supports explicit and implicit correction), and skill self-evolution based on real trajectories (Skill Evolution converts experience into reusable rules). It achieves an accuracy rate of 94.03% on the LoCoMo benchmark.

2. Key Features

• Three-Dimensional Memory Structure: Organizes memory using a three-axis coordinate system of entity-attribute-time. Each entity is associated with multiple attributes, and each attribute records a complete trajectory of changes over time. This structure not only preserves the latest state but also retains the historical evolution process, enabling retrospective analysis of dynamic information such as user interest changes and project progress.

• Dual-Mode Memory Extraction: In open-domain scenarios, the MindVanilla mode can quickly structure and store conversation content without requiring predefined templates. The MindSchema mode, on the other hand, allows developers to predefine entity types and attribute rules, making it suitable for business scenarios with clear domain models such as e-commerce and healthcare, achieving a balance between extraction accuracy and efficiency.

• Compact Search Retrieval: Utilizes a two-tiered search architecture. The outer Agentic module dynamically plans the search path based on the intent of the query, while the inner layer performs multi-path searches including entity reverse lookup, multi-hop relationship expansion, and timeline tracking. Before the final output, the results are re-ranked and refined to ensure the most relevant memory fragments are returned.

• Dreaming Offline Organization: Automatically runs during system idle time to identify redundancies, conflicts, and evolutionary relationships within the memory. It merges redundant information, archives outdated versions, and supplements missing higher-order patterns. This mechanism compresses 19.4%-23.5% of active memory while increasing the accuracy of question-answering by up to 10.3 percentage points, achieving memory quality optimization through the principle of "less is more."

• Feedback Loop: Supports both explicit feedback (direct user ratings or corrections) and implicit feedback (inferred from user follow-up behavior). After automatically identifying the type of feedback signal, the system performs corresponding operations such as adding, updating, archiving, deleting, or reinforcing memory entries. This mechanism enables memory extraction and retrieval strategies to continuously learn from user interactions, adapting to users' real needs over time.

• Skill Evolution: Automatically extracts successful strategies and failure patterns based on real execution trajectories, generating Skill modification plans and iterating versions. The initial Skill, without optimization, performs worse than the baseline with no Skill. However, Skills evolved through the MindEvolve-Sup mechanism increase task success rates from 51.3% to 57.2%, demonstrating the value of turning experience into rules.

3. How to Use

1. Environment Requirements and Configuration Preparation: Requires Docker and Docker Compose environments, with Linux or macOS recommended as the operating system. After cloning the GitHub repository, copy the configuration files: cp .env.example .env and cp config/mindmemos/dev.example.yaml config/mindmemos/dev.yaml. Set the necessary API Key in the .env file and configure model routing parameters such as chat_model_router, embed_model_router, and rerank_model_router in the dev.yaml file, supporting integration with multiple large language models and embedding models.

2. Starting the Service: Run the make dev command to launch the complete Docker dependency stack (including the database, vector storage, etc.) and the FastAPI service, which listens on port 8000 by default. If only the core dependencies are needed, use make dev-core to start only the essential components. The first launch may require pulling images and initializing the database, which can take approximately 5–10 minutes.

3. Installing and Configuring the SDK: Install the Python SDK using pip install mindmemos-sdk. Run the mindmemos auth command and configure base_url (default is http://localhost:8000), api_key, and user_id as prompted. The SDK supports both synchronous and asynchronous calling methods, making it easy to integrate into different frameworks.

4. Adding and Retrieving Memories: Use the SDK to call the client.memory.add() method to write conversation records or factual information, with support for specifying entities, attributes, and timestamps. Use client.memory.search() to perform searches, passing in query text and filtering conditions. Advanced usage includes enabling multi-path search by using the Compact Search parameter and limiting the time range with time_range. Additionally, user feedback signals can be submitted using the CLI command mindmemos memory feedback, offline memory consolidation can be triggered with mindmemos memory dreaming, local Skills can be registered using mindmemos skill register, and skill version evolution can be initiated with mindmemos skill evolve.

4. Pros and Cons Analysis

5. Comparative Analysis with Similar Tools

Selection Recommendations: For scenarios requiring high-precision structured memory and cross-framework Agent collaboration, MindMemOS is the preferred choice due to its three-dimensional memory structure, offline organization capabilities, and Skill evolution features, especially suitable for multi-Agent platforms and long-term user profile construction. For projects that only require simple conversation memory and have a shallow technical stack, Mem0's lightweight deployment and general-purpose extraction may be more convenient, but its lower accuracy and lack of Skill evolution must be accepted. If the project is deeply integrated with the Zep or EverOS ecosystem, migration costs may be high, but the advantages of MindMemOS in memory quality and evolution capabilities are worth evaluating. For academic research and teams requiring customized memory structures, MindMemOS's MIT open source license and modular design offer the greatest flexibility.

6. Editor's Summary

MindMemOS's technical innovation lies in elevating memory from "auxiliary storage" to an "independent operating system," with its three-dimensional graph structure representing a significant breakthrough over traditional flat memory solutions. By incorporating three dimensions—entity, attribute, and time—the system not only stores facts but also preserves their evolution over time. This is of fundamental value for applications that require an understanding of long-term user behavior patterns, such as personalized assistants and user profiling.

The Dreaming offline organization mechanism addresses the contradiction between memory expansion and quality degradation at the algorithmic level. Experimental data shows that active organization is more effective than passive storage, a concept that is worth adopting by similar projects.

In terms of practical value, MindMemOS's multiple access methods (Docker, SDK, CLI, OpenClaw plugin) allow it to be flexibly integrated into existing Agent workflows. Its memory decoupling design reduces the cost of memory sharing in multi-Agent collaborations. The Skill Evolution feature converts execution experience into reusable rules, providing a viable technical path for continuous learning in Agents. However, the current system's deployment complexity and reliance on model APIs remain barriers to widespread adoption, requiring the community to contribute simpler installation solutions and offline inference support.

In terms of target users, MindMemOS is most suitable for AI application developers, Agent framework maintainers, and academic researchers with a certain level of technical expertise, especially teams that need to build personalized services with long-term memory or multi-Agent collaboration platforms. For beginners or projects requiring only basic memory functions, lighter alternatives may be more appropriate. In terms of future development potential, if the system continues to improve in documentation, one-click deployment, and model compatibility, while building a richer Skill ecosystem, MindMemOS has the potential to become a major player in the Agent memory infrastructure domain.

7. Application Scenarios

• Personalized AI Assistants: Retain user preferences, project context, and historical pitfalls across conversations, avoiding the need to "train" an Agent from scratch each time. For example, a personal knowledge management assistant can remember a user's research interests, reading progress, and note-taking style, providing more accurate recommendations and summaries in subsequent interactions.

• Multi-Agent Collaboration Platform: A shared memory repository for different Agent frameworks such as OpenClaw, Hermes, Claude Code, and OpenHands, ensuring consistent knowledge across systems. For instance, in a software development team, a code review Agent and a documentation generation Agent can share project context and decision history, reducing redundant communication.

• Automated Algorithm Design (LLM4AD): Systematize effective experiences and pitfalls in algorithm search into a searchable, reusable three-tier memory system. Research teams can store experimental configurations, failure causes, and successful strategies in the memory repository, allowing subsequent algorithm search Agents to directly query historical experiences and accelerate iteration.

• Complex Office Automation: Continuously optimize execution strategies for repetitive tasks like spreadsheet processing and document editing through Skill Evolution. For example, a financial report generation Agent can record formatting anomalies and correction methods encountered in each processing session, gradually forming a standardized workflow to improve accuracy and efficiency.

• Long-term User Profile Construction: Track the evolution of user attributes (interests, consumption habits, health metrics, etc.) over time to support personalized recommendations and social planning. A recommendation Agent on an e-commerce platform can dynamically adjust its strategy based on a user's browsing and purchasing history over the past three months, capturing seasonal and trend-based changes.

8. FAQ

Q: Which large language models does MindMemOS support?
A: MindMemOS supports various LLMs through the configuration of chat_model_router, including the OpenAI GPT series, Anthropic Claude series, and open-source models (such as Llama, Qwen), depending on the API interface configured during deployment. The embedding model and re-ranking model can also be flexibly switched using embed_model_router and rerank_model_router, respectively.

Q: Where is the memory data stored? Does it support local persistence?
A: Memory data is stored in a database deployed via Docker (defaulting to PostgreSQL and vector databases such as Weaviate or Qdrant). All data is saved locally and will not be uploaded to Huawei servers. Users can choose different database backends through configuration, supporting fully localized deployment.

Q: How long does the Dreaming offline organization process take? How many resources does it consume?
A: The runtime of Dreaming depends on the size of the memory library and the configured models. Typically, for a library with tens of thousands of memories, a single organization process takes between several minutes to over ten minutes. Resource consumption mainly occurs during LLM calls and database operations. It is recommended to trigger this process during system idle times, and the concurrency level can be controlled via API.

Q: How many execution samples does Skill Evolution require to take effect?
A: The official recommendation is to accumulate at least 50 successful or failed execution traces to generate statistically meaningful evolutionary effects. The more samples, the more stable the evolved Skill rules will be. In the initial phase, simulated data or historical logs can be used for pre-evolution.

Q: How can I integrate an existing Agent framework (such as LangChain, AutoGPT) with MindMemOS?
A: MindMemOS provides a Python SDK and REST API. Frameworks like LangChain can be integrated by calling the client.memory.add() and client.memory.search() interfaces. The official provides the OpenClaw plugin as a reference implementation, and other frameworks can be adapted based on this plugin. The decoupled memory design allows integration without modifying the core logic of the Agent, requiring only the embedding of memory read/write operations at the interaction nodes.

9. Project Links

• Project Website: https://mindmemos.cn/
• GitHub Repository: https://github.com/mindscale-noah/MindMemOS