General Engine - MemoryOS

The General Engine is the default MemoryOS runtime. Use it when your product needs reliable long-term memory but does not require an industry-specific schema. It works for most AI products:

chatbots and assistants
coding agents
productivity copilots
SaaS personalization
internal knowledge helpers

What it stores

The General Engine extracts durable memory from conversations into these categories:

Category	Meaning	Example
`preference`	How the user likes things done	User prefers concise answers with Python examples.
`fact`	Stable user or account facts	User works in a B2B SaaS support team.
`goal`	Something the user wants to achieve	User is preparing to launch an AI product.
`procedure`	A repeated workflow or instruction	User wants weekly summaries every Friday.
`relationship`	People, teams, or account relationships	User reports to the Head of Product.
`expertise`	Skills, tools, or areas of knowledge	User is comfortable with FastAPI and PostgreSQL.

What it does not store

Keep these in your own product database:

billing records
official user profile fields
account permissions
source-of-truth ticket status
source-of-truth course enrollment
payroll, HRIS, or compliance records

MemoryOS stores memory extracted from interactions. Your product database remains the system of record.

Write path

When your backend calls add(), MemoryOS:

authenticates the tenant API key
resolves external_user_id inside that tenant
runs the quality gate
queues extraction
extracts durable memory
resolves conflicts against existing memory
stores canonical records
indexes vectors for retrieval
records version history

The API returns quickly with a job result. Extraction runs asynchronously.

result = mem.add(
    messages=[
        {
            "role": "user",
            "content": "Remember that I prefer concise technical explanations with Python examples.",
        }
    ],
    external_user_id="user_123",
)

Read path

Call get() before your model call. MemoryOS retrieves relevant memories and returns system_prompt_addition, which is safe to prepend to your system prompt.

memories = mem.get(
    query="answer this user's integration question",
    external_user_id="user_123",
    limit=5,
    context_max_tokens=500,
)

system_prompt = "You are a helpful assistant."
if memories.has_context:
    system_prompt = f"{system_prompt}\n\n{memories.system_prompt_addition}"

Retrieval ranking

The General Engine ranks memories using:

semantic relevance to the current query
importance score
recency and lifecycle state
hot-tier cache signals
category filters when provided

Use a query that describes the current task. This produces better retrieval than a generic query like "memory" or "preferences".

Quality gate outcomes

add() may return:

Status	Meaning	Application behavior
`queued`	Memory extraction was queued	Continue normally
`passthrough`	Writes are skipped in the current quota mode	Continue without persistence
`L1`	Per-user rate limit	Retry later
`L2`	Low-quality input	Do not retry the same message
`L3`	Duplicate or near-duplicate input	Avoid repeated writes
`L4`	Budget governance block	Upgrade or wait for reset
`blocked`	Fallback block state	Log and continue

The LLM call should not fail only because memory could not be written.

When to move to a domain schema

Stay on the General Engine if prompt-ready memory is sufficient. Move to a domain schema when your product needs structured domain memory, such as:

EdTech student profiles, weak topics, exams, and forgetting-stage context
Support customer issue history, support type, sentiment, and escalation risk

​What it stores

​What it does not store

​Write path

​Read path

​Retrieval ranking

​Quality gate outcomes

​When to move to a domain schema

​Related pages