Why MemOS Is the Next‑Generation Memory OS for AI Agents

Background and Motivation

Long‑term memory is essential for agents. Traditional solutions embed memory in model parameters or use external notebooks, but MemOS aims to elevate memory to a first‑class system resource, managed like an operating system.

Design Philosophy: Memory as an OS

MemOS treats memory as a "memory operating system" that unifies storage, scheduling, and governance across multiple agents, users, and sessions, providing APIs for add, search, update, feedback, and delete operations.

Core Architecture

The architecture consists of three main layers:

MemOS Layer : Application‑facing interface handling multi‑user, multi‑agent, multi‑session read/write and management.

MemReader : Extracts structured memory from dialogues or documents using LLMs and embeddings.

MemScheduler : Asynchronously processes, optimizes, and schedules memory to improve quality, speed, and accuracy.

Below the MemOS layer sits the MemCube abstraction, a modular, serializable container that groups memory items (memory + metadata) for each user or agent and stores them in vector stores, graph databases, or other back‑ends.

Memory Types and Lifecycle

MemOS defines three interchangeable memory forms:

Plaintext Memory ("external notebook"): Structured, semantically enriched text stored in vector or graph stores, supporting working, long‑term, user, and tool memory categories.

Activation Memory ("thinking cache"): KV‑Cache of transformer attention keys/values, cached on GPU to accelerate long context inference; stored in the transformer cache or dumped to disk.

Parametric Memory ("muscle memory"): Knowledge baked into model weights via LoRA adapters, offering zero‑retrieval cost but requiring model fine‑tuning and white‑box deployment.

MemOS can dynamically migrate memory between these forms based on access frequency, stability, and resource constraints.

Getting Started with MemOS Cloud

MemOS offers a SaaS cloud service with a Python SDK. Install the client, configure the API key, and start adding and querying memory.

pip install MemoryOS -U

from memos.api.client import MemOSClient
import os
client = MemOSClient(api_key=os.getenv("MEMOS_API_KEY"))

Example workflow:

messages = [
    {"role": "user", "content": "我最近在学习 Python，想找一些适合新手的实战项目"},
    {"role": "assistant", "content": "建议从爬虫或数据分析项目开始，比较容易上手"}
]
client.add_message(messages, user_id="user_123", conversation_id="conv_001")
res = client.search_memory("用户在学习什么编程语言", user_id="user_123", conversation_id="conv_001")
print(res)

The SDK supports asynchronous processing (default) and synchronous mode via the async_mode flag, with task status queries available.

Async Processing and Filtering

MemOS performs a two‑stage pipeline: a millisecond‑level "rough" add that makes memory immediately searchable, followed by a second‑stage "fine" processing that enriches metadata and relationships. Users can query task status:

result = client.add_message(messages, user_id="user_123", async_mode=True)
task_id = result.data.task_id
status = client.get_task_status(task_id=task_id)
print(status.data[0].status)  # "running" or "completed"

When the memory pool grows, filters based on metadata (tags, custom fields, timestamps) can be applied before semantic search to improve speed and precision.

client.add_message(
    messages=[{"role": "user", "content": "下周一要参加产品发布会"}],
    user_id="user_123",
    conversation_id="conv_work",
    tags=["工作", "会议"],
    info={"scene": "产品发布会", "custom_status": "待准备"}
)
res = client.search_memory(
    "最近有什么重要安排",
    user_id="user_123",
    conversation_id="conv_work",
    filter={"and": [{"tags": {"contains": "工作"}}, {"custom_status": "待准备"}]}
)

Multimodal and Knowledge‑Base Integration

MemOS Cloud now supports image and document ingestion; such content is extracted and indexed alongside text memory. It also offers a knowledge‑base feature that merges static documents (e.g., employee handbooks) with dynamic memory, enabling identity‑aware retrieval.

# Add a message containing an image
messages = [{
    "role": "user",
    "content": [
        {"type": "text", "text": "我在研究 MemOS"},
        {"type": "image_url", "image_url": {"url": "https://example.com/architecture.png"}}
    ]
}]
client.add_message(messages, user_id="user_123")

# Search with knowledge‑base IDs
response = client.search_memory(
    query="新员工入职流程是什么",
    user_id="user_123",
    knowledgebase_ids=["id_hr_manual", "id_it_guide"]
)

Tool Memory and Future Directions

Tool usage traces (function calls, parameters, results) can be stored as "tool memory", allowing agents to reuse previous tool interactions without re‑invoking external services. The article concludes that MemOS turns complex memory engineering into an out‑of‑the‑box service, with a forthcoming deep‑dive into the open‑source self‑hosted version.