Storage is the easy part.
Production memory must decide what is durable, what changed, which source to trust, what the user approved, and what context the next agent actually needs.
Durable context loss
A returning user repeats lasting goals, preferences, and unresolved issues because prior state was never carried forward.
Multi-agent drift
Support, onboarding, recommendations, and copilots each build a different picture of the same person.
Conflicting truth
New facts contradict old facts, but raw vector retrieval returns both — and leaves the model to guess.
Your agent has storage.
It may not have governed state.
MemoryOS complements the systems you already use. It does not replace complete transcripts, business records, document retrieval, or the tools that perform real actions. Send MemoryOS the relevant signals from those systems, and retrieve compact governed context before the next model call.
Owns business records, transactions, and live operational truth.
Preserves complete conversations and message history.
Finds semantically similar records and documents.
Provide static instructions and general knowledge.
Governs learned state: what changed, what is current, and who may reuse it.
Not a vector database.
Not a transcript store. Not your app DB.
Each system owns a different job. MemoryOS is the only one that governs learned state — what changed, what is current, and who may reuse it.
One governance layer.
Multiple production paths.
Start with the general engine. Add a domain schema when your agent needs product-specific extraction, retrieval, and safety behavior.
General Engine
Durable user state for facts, goals, preferences, and procedures. Use the general engine when you want durable user context without choosing an industry schema first.
EdTech Schema
Extraction, retrieval, and safety tuned for learning products. Tracks learner progress, weak topics, and exam context.
Support Schema
Remembers open issues, account context, sentiment risk, communication preferences, and resolution history.
Memory Passport
Portable, consent-controlled memory the user can approve, inspect, correct, and revoke.
Five stages. One governed context layer.
Keep your model, tools, and agent framework — MemoryOS handles the memory lifecycle around them.
- 01
Ingest
messagescorrectionseventsRelevant conversations, corrections, and application events enter MemoryOS as raw signals.
Signals arrive from agents, transcripts, and your backend. Nothing is committed as memory yet — they are candidates pending decisions.
- 02
Extract
factspreferencesgoalsproceduresCandidate durable state is extracted with supporting evidence.
MemoryOS pulls facts, preferences, goals, and procedures — each one attached to the source and the evidence that produced it.
- 03
Reconcile
mergerevisecorrectconflictExisting claims, revisions, corrections, and conflicts are resolved.
When a new fact conflicts with an old one, MemoryOS uses source authority, evidence, and recency to decide — and preserves the version history.
- 04
Govern
quality gateprovenancetenant scopeconsentValidity, provenance, authority, lifecycle, and access policy are enforced.
Each memory is checked by quality gates, scoped to the right tenant, user, and agent boundary, and tagged with who may reuse it.
- 05
Retrieve
rankcompactprompt-readyCurrent, authorized context is returned — compact and prompt-ready.
Relevant memories are ranked, source-aware, and small enough to use without handing the model an unfiltered history.
Signals arrive from agents, transcripts, and your backend. Nothing is committed as memory yet — they are candidates pending decisions.
From user signal —
to governed context.
Select a common memory scenario to see how MemoryOS identifies durable information, handles conflicts, applies controls, and prepares context for an agent.
Receive the signal
LLM extracts memory
Detect conflicts
Quality + consent
Prompt-ready context
// run the decision to populate governed context
Integrate in an afternoon.
Keep your model, tools, and agent framework.
Add add() on the way in and get() on the way out. MemoryOS handles the memory lifecycle around your stack — in Python, TypeScript, REST, or as MCP tools.
$ pip install memoryo-sdkimport osfrom memoryos import Memoryclient = Memory(api_key=os.environ["MEMORYOS_API_KEY"])# Ingest a conversation signalwrite = client.add(messages=[{"role": "user", "content": "I prefer concise answers."}],external_user_id="customer-123",)if write.job_id:client.wait_for_job(write.job_id)# Retrieve governed context before the next model callresult = client.get(query="How should I answer this user?",external_user_id="customer-123",)prompt_addition = result.system_prompt_addition if result.has_context else ""
A full memory lifecycle, in one terminal.
Install the SDK, ingest a signal, watch MemoryOS extract, reconcile, govern, and retrieve — then attach the governed context to your next model call. No mockups, no fake chatbot — this is the actual decision path your agents will exercise.
- Real add() / get() flow shape
- Per-stage provenance and consent surfaced in the trace
- Compact context, ready to inject into the prompt
From zero to governed context
in one afternoon.
Install the SDK
Add the Python or TypeScript SDK to your backend. Bring your existing agent, model, and tools — MemoryOS sits beside them.
Wire add() and get()
Call add() on the way in with conversation signals. Call get() before the next model call to retrieve compact, governed context.
Govern and ship
Enable quality gates, tenant isolation, and Memory Passport. Watch the audit trail. Ship to production with confidence.
Reliable after the demo.
The controls teams usually discover only after their first memory prototype reaches real users.
Quality gates
Block duplicate, low-signal, over-budget, or rate-limited writes before they pollute memory.
if signal.score < 0.35 → reject if is_duplicate(memory) → skip
Conflict resolution
Use source authority, evidence, recency, and explicit review paths instead of storing contradictions forever.
old: codes in Python new: switch to TypeScript → revise · keep history
Provenance
Track which service wrote a memory, what evidence produced it, and why retrieval trusts it.
writer: support-bot/2.3 evidence: msg#42 · confidence 8.8 retrieval: weighted by source
Lifecycle controls
Reinforce useful memory, archive stale facts, preserve versions, and handle corrections without losing history.
state: active → reinforced → active → stale → archived → corrected → version+1
Graceful degradation
Keep your product responsive when quotas or dependencies force a partial memory experience.
if quota.exceeded: return empty_ctx log partial_mode = true
Tenant isolation
Keep customer memory scoped to the right tenant, user, agent, and permission boundary.
tenant: tenant-A user: customer-123 agent: support-bot scope: this_agent_only
You likely need governed context when
- Multiple agents, services, or channels update context about the same user.
- Corrections must replace stale state without erasing history.
- Sources have different authority, or provenance and auditability matter.
- Context crosses tenant, user, agent, category, or consent boundaries.
You may not need MemoryOS yet when
- Your product is a short-lived or single-session prototype.
- All required context already fits reliably in one prompt.
- You retrieve only static documents or general knowledge.
- There are no meaningful corrections, conflicts, permissions, or audit requirements.
Where MemoryOS sits in your stack.
One govern layer between your agent and your model.
MemoryOS does not replace your databases, transcripts, vector store, or tools. It sits beside them — ingesting signals, governing state, and returning compact context before the next model call. Your application keeps full responsibility for business data, actions, and final responses.
Your application handles the request. Existing systems (DB, transcript, tools) stay where they are.
On the way in: add() the conversation signal. Before the model call: get() governed context.
Extract · reconcile · govern. Quality gates, tenant isolation, provenance, and consent enforced.
system_prompt_addition attached. Model responds. App owns the final response and any actions.
Safe to put in
production.
MemoryOS is designed for teams who treat memory as infrastructure. Encryption, isolation, auditability, and compliance controls are built in — not bolted on.
Every memory is encrypted at rest with AES-256. Per-tenant keys ensure cross-tenant isolation is enforced cryptographically, not just at the storage layer.
API keys are scoped to a tenant + agent + category boundary. A key issued for support-bot cannot read memories written by copilot unless explicitly granted.
Choose where your memories live. Data stays in the selected region; no cross-region replication without explicit customer consent.
The audit trail records who wrote a memory, what evidence produced it, who retrieved it, and when. Exportable for compliance reviews.
Isolation is enforced at the retrieval layer — a cross-tenant query returns empty, not an error that leaks existence. Per-tenant encryption keys add a second boundary.
Set retention per category. User-initiated deletion propagates to all replicas, backups, and derived indexes within 30 days. Provenance is preserved but anonymized.
Share memory without hiding control.
Approve, inspect, correct, resolve, grant, and revoke — live.
This is a live console, not a mockup. Click a memory to inspect its provenance. Toggle a grant and watch the consent ledger update.
- Approved · support-bot2m ago
Preference: Prefers concise explanations
- Corrected · copilot1h ago
Fact: Codes primarily in TypeScript
- Granted · tutor agent3h ago
Scope: learning progress only
- Resolved · conflict5h ago
Two sources reconciled via authority
- Revoked · recommendations agent1d ago
Access removed by user
Context shaped for the product it serves.
Pick up where the last ticket ended.
Remember open issues, account context, sentiment risk, communication preferences, and resolution history — across channels and over time.
Teach the learner you already know.
Carry weak topics, exam context, learning style, language comfort, and progress signals into every session.
Share memory without hiding control.
Let users approve categories, inspect grants, correct facts, resolve questions, and revoke agent access — at any time.
One governed picture of the same person.
Support, onboarding, recommendations, and copilots each build a different picture of the same person. MemoryOS reconciles them.
What teams building with
governed memory actually say.
"We were hand-rolling a memory layer on top of Postgres and pgvector. MemoryOS replaced six weeks of bespoke reconciliation logic with a single add() call."
"The Memory Passport was the deciding factor. Our users in regulated industries need to see and revoke what agents remember — MemoryOS ships that out of the box."
"Conflict resolution alone is worth it. Before MemoryOS, contradictory facts would leak into prompts. Now the model gets one governed, source-aware view."
Built for the shape of
real agent workloads.
These are the numbers that matter when memory is in the hot path of every model call. Illustrative — based on design-partner deployment shapes.
The vocabulary of
governed memory.
These are the concepts that distinguish a memory layer from a database, a transcript store, or a vector search. Click a term to expand its definition.
Pay for governed context.
Not for idle storage.
Start small. Upgrade when your agents reach real users. Every plan includes the full lifecycle — ingest, extract, reconcile, govern, retrieve.
Free
For prototyping and side projects.
- 5,000 memory operations / mo
- 2M memory tokens / mo
- 3 calls / user / minute
- Core memory lifecycle
- Community support
Starter
For early production agents.
- 50,000 memory operations / mo
- 25M memory tokens / mo
- 10 calls / user / minute
- Core memory lifecycle
- Usage alerts
Growth
For growing multi-agent products.
- 500,000 memory operations / mo
- 250M memory tokens / mo
- 30 calls / user / minute
- Core memory lifecycle
- Usage alerts
Scale
For high-volume production systems.
- 1M memory operations / mo
- 500M memory tokens / mo
- 80 calls / user / minute
- Core memory lifecycle
- Priority usage alerts
Enterprise
For regulated, multi-agent systems.
- Custom operations & schemas
- Tenant isolation + SSO/SAML
- Custom domain schemas
- Graceful degradation + SLA
- DPA · SOC 2 · audit exports
- Dedicated solutions engineer
Questions teams ask
before they ship.
Short, technical answers. If something here doesn't cover your case, talk to us — we work through architecture with every team.
Shipping continuously.
What's live, and what's next.
General availability
- Domain schema registry (General, EdTech, Support)
- Memory Passport with grant/revoke + provenance drawer
- MCP server for MCP-compatible agents
- Quality gates, conflict resolution, tenant isolation
Production foundations
- 5-stage lifecycle (ingest → retrieve)
- Provenance chain + audit trail
- Graceful degradation on quota limits
- Python + TypeScript SDKs, REST API
On the roadmap
- Streaming extraction (SSE) for sub-second traces
- Self-hosted / on-prem deployment
- SOC 2 Type II + DPA
- Custom domain schemas (financial services, healthcare)
Give your next AI interaction
the context the last one earned.
Try the simulated playground, follow the quickstart, or talk with us about production onboarding.