MemTensor/MemOS

⭐ 9,005  ·  TypeScript  ·  GitHub Repo

Self-evolving memory OS for LLM & AI Agents: ultra-persistent memory, hybrid-retrieval, and cross-task skill reuse, with 35.24% token savings

agent agentic-ai ai ai-agents chatgpt claude hermes llm

1-Sentence Summary

A self-evolving memory OS for LLMs, boosting accuracy by 43.7% while cutting token costs by 35.24%.

🔥 Key Capabilities & USP

• Self-Evolving Three-Tier Memory Architecture (L1/L2/L3)
  Automatically progresses from raw trace memory (L1) to actionable policies (L2) and abstract world models (L3). Skills are crystallized from feedback, eliminating manual memory curation and enabling continuous agent improvement.

• Inspectable Graph-Based Unified API
  Replaces opaque embedding stores with a fully transparent, queryable memory graph. Developers can add, retrieve, edit, or delete any memory node, providing unprecedented control and debuggability over agent memory—a stark contrast to black-box solutions.

• Multi-Modal & Multi-Cube Knowledge Base
  Natively ingests text, images, tool traces, and personas into a single memory system. Multiple isolated or composable knowledge "cubes" can be managed across users, projects, and agents, solving the pain point of fragmented memory silos in multi-agent architectures.

• Asynchronous MemScheduler with Production-Grade Resilience
  Handles all memory operations via Redis Streams with millisecond latency, task priority queuing, and auto-recovery. This ensures stability under high concurrency, a critical requirement for enterprise deployments that naive synchronous memory systems cannot meet.

• Memory Feedback & Correction Loop
  Allows natural-language commands to refine, correct, supplement, or replace existing memories. This makes the system adaptive and user-controllable, directly addressing the "forgetfulness" and "stubbornness" issues plaguing current LLM agents.

USP: MemOS is the only open-source memory system that combines self-evolving skill crystallization, an inspectable graph API, and enterprise-grade async scheduling—delivering measurable accuracy gains and token savings that no other memory solution currently offers.

Technical Architecture

Component	Technology	Role
Memory Graph Engine	Python, SQLite	Core storage and graph traversal for L1/L2/L3 memory tiers
Task Scheduler	Redis Streams	Asynchronous, prioritized, auto-recovering queue for memory operations
Hybrid Search	FTS5 + Vector Embeddings	Combines full-text search with semantic vector retrieval for optimal recall
Plugin System	MCP Protocol	Extensible interface for Hermes Agent, OpenClaw, and future integrations
Deployment	Docker, Cloud API	Local-first with optional cloud sync; self-hosted or managed cloud modes

Architectural Highlights:

• Local-first storage with optional cloud synchronization for hybrid deployments
• Multi-tier evolution where memory automatically matures from raw traces to abstract policies
• Hybrid retrieval that merges keyword precision (FTS5) with semantic understanding (vectors)
• Enterprise optimizations for high concurrency and sub-100ms latency under load

Quick Start Guide

# Clone the repository
git clone https://github.com/MemTensor/MemOS.git
cd MemOS

# Install dependencies
pip install -r ./docker/requirements.txt

# Configure environment
cp docker/.env.example MemOS/.env
# Edit MemOS/.env with your OpenAI and embedding provider API keys

# Launch with Docker
docker-compose up -d

After startup, the MemOS API will be available for integration with your LLM agents via the unified memory API.

Pros, Cons & Use Cases

Pros

• Measurable performance gains: +43.70% accuracy over OpenAI Memory and 35.24% token savings validated in benchmarks
• Fully open-source with dual deployment modes (self-hosted or cloud API)
• Multi-modal support for text, images, tool traces, and personas in one graph
• Active development with regular updates, detailed changelogs, and growing community

Cons

• External API dependency: Requires OpenAI and embedding provider keys for full functionality
• Complex self-hosted setup: Involves Redis, Docker, and multiple service dependencies
• Limited plugin ecosystem: Currently only supports Hermes Agent and OpenClaw natively
• Cloud privacy concerns: Cloud sync may introduce latency or data residency issues for sensitive workloads

Who should NOT use this?

• Developers building simple chatbots with no need for long-term memory or personalization—MemOS is over-engineered for stateless, single-turn interactions
• Teams without DevOps support who cannot manage Redis, Docker, and async infrastructure
• Projects requiring zero external API dependencies (e.g., fully air-gapped environments with no internet access)
• Applications needing real-time, sub-millisecond memory operations—while fast, the async scheduler introduces some latency over synchronous in-memory solutions

Ideal Use Cases

• Production AI agents needing persistent, self-improving memory across sessions and tasks
• Multi-agent systems requiring shared, inspectable knowledge bases with isolated user contexts
• Enterprise personalization where agents must learn user preferences and skills over weeks of interaction
• Research on memory architectures for LLMs, benefiting from the inspectable graph and evolution tiers

Community & Activity

With 9,005 stars and a last update on May 10, 2026, MemOS is clearly a high-velocity project with strong community traction. The active development cadence, detailed changelogs, and growing ecosystem (Hermes Agent, OpenClaw plugins) signal a project that is not just a proof-of-concept but a production-ready tool gaining serious adoption. The combination of academic-grade benchmarks and practical engineering (Docker, Redis Streams) makes this a compelling choice for teams serious about solving the memory bottleneck in LLM agents.