Now shippingHMD v2·Production Network

Memory that feelshandcrafted for autonomous agents

OpenMemory treats every conversation like a living system—capturing emotion, context, and time with graceful decay and automatic reinforcement.

01

Five-sector embeddings

Factual, emotional, temporal, relational, and behavioral memory.

02

Graceful decay curves

Automatic reinforcement keeps relevant context always sharp.

Trusted by teams building
Agents
Assistants
Knowledge Graphs

Pulse

Retention

94.7%

Memory health

97%

Live sync

Factual

23k

Anchored nodes

Emotional

18k

Sentiment cues

Temporal

6h

Average recall

Natural decay
Reinforcement pulse

Sync map

API latency36ms
Graph updates+128
Decay events3
Why OpenMemory

2-3× Faster, 6-10× Cheaper

OpenMemory delivers superior contextual recall at a fraction of the cost of hosted memory APIs

Query Latency

110ms

vs 350ms (SaaS)

Scalability

Horizontal sharding

Cost / 1M Tokens

$0.35

vs $2.50+ (SaaS)

Throughput

40 ops/s

vs 10 ops/s (SaaS)

Monthly Cost

$6

vs $90+ (SaaS)

Feature
OpenMemory
SupermemoryMem0Vector DBs
Expected Monthly Cost (100k)$5-8$60-120$25-40$15-40
Hosted Embedding Cost$0.35/1M$2.50+/1M$1.20/1MUser-managed
Storage Cost (1M memories)~$3/mo~$60+~$20~$10-25
Avg Response (100k nodes)110ms350ms250ms160ms
CPU UsageModerateServerless billedModerateHigh
ArchitectureHMD v2Flat embeddingsJSON memoryVector index
Retrieval DepthMulti-hopSingle embeddingSingle embeddingSingle embedding
Ingestion
Multi-format
Explainable Paths
Open Source
Self-Hosted
Local Embeddings
Data Ownership100%Vendor100%100%
Decay Engine

How memory decay stays graceful and useful

Memories fade following curved trajectories, while reinforcement pulses lift critical context back above the retention threshold.

Sector-aware decay

Each memory dimension carries its own slope and minimum floor so emotional cues linger longer than transient facts.

Automatic reinforcement

Signal spikes from conversations or tool outcomes fire a pulse that restores strength without manual resets.

Attribution trails

Every reinforcement links back to its trigger so agents can explain why context remained in play.

Strength
Timeline
Natural decay slopeReinforcement pulseRetention threshold
Features

Everything You Need

Production-ready features for intelligent memory management

Structure

Multi-sector embeddings

Encode conversations into five synchronized dimensional vectors that elegantly preserve nuance across sessions.

  • Cross-sector weighting and drift control
  • Vector normalization per session
Dynamics

Intelligent decay orchestration

Memories decay gracefully along custom curves, while high-signal events trigger reinforcement without manual tuning.

  • Reinforcement thresholds per sector
  • Scheduled decay audits every 12h
Context

Waypoints & graph routing

Every memory anchors to a dynamic waypoint graph, powering contextual recall and multi-hop reasoning.

  • Bidirectional edges with weight decay
  • Streaming updates via SQLite triggers
Ingestion

Multimodal pipelines

Stream documents, call transcripts, and events through adaptive chunking with automatic context stitching.

  • Async ingestion queue with retries
  • Root-child relationships for long docs
Performance

Cold-start free retrieval

SQLite vector search with RAM caching gives you sub-40ms responses without managing infra.

  • Deterministic startup with seeded sectors
  • Vector quantization for fast recall
Providers

Modular embedding engines

Swap between OpenAI, Gemini, Voyage, or local models without rewriting your pipeline.

  • Advanced vs basic embedding strategies
  • Provider fallbacks with health checks
System Architecture

Hierarchical Memory Decomposition

Multi-sector embeddings with single-waypoint linking for biologically-inspired memory retrieval

Layer 1

Input & Ingestion

Documents

Conversations

Events

Audio

Web Pages

Layer 2

Text Processing Pipeline

Parse & Clean

Extract text, remove noise

Chunk

Semantic segmentation

Classify Sector

ML-based routing

Generate Embeddings

5-sector vectors

Layer 3

Multi-Sector Memory Storage

Episodic

Events & experiences

Semantic

Facts & concepts

Procedural

Skills & patterns

Emotional

Sentiment arcs

Reflective

Meta-cognition

Vector Store (SQLite)

768-dim embeddings per sector with quantization

Waypoint Graph

Single-waypoint associations with weight decay

Layer 4

Composite Retrieval Engine

Sector Fusion

Query against 2-3 likely sectors simultaneously

cosine_similarity()

Activation Spread

1-hop waypoint graph traversal for context

graph.expand(depth=1)

Composite Ranking

Weighted scoring with decay factors

0.6×sim + 0.2×sal + 0.1×rec
Layer 5

Response & Background Jobs

Ranked Results

JSON with attribution paths

Decay Scheduler

Runs every 12h via cron

Reinforcement

Auto-boost on access

Backend Stack

  • TypeScript + Node.js 20+
  • Fubelt REST API
  • Node-cron scheduler

Storage Layer

  • SQLite 3.40+ (WAL mode)
  • Vector quantization
  • In-process graph logic

Embedding Engines

  • OpenAI / Gemini
  • Ollama (E5, BGE local)
  • Modular provider system
Pipeline

A calm workflow from ingestion to meaningful recall

Everything is designed so that product teams can deploy rich agent memories without wrangling infrastructure or custom tooling.

Step 01

Capture

Stream documents, conversations, telemetry, and events into OpenMemory via a single REST surface.

  • Auto-detects modality and optimum chunking
  • Metadata preserved for routing
Step 02

Compose

Embeddings route into five sectors, re-weighted by the reinforcement engine and waypoint graph.

  • Sector heuristics + custom scoring functions
  • Decay curves tuned per memory type
Step 03

Recall

Query memories with hybrid semantic + graph lookups that surface the right context for every agent decision.

  • Deterministic ranking with attribution trails
  • Streaming mode for multi-turn conversations

Median latency

36ms

Context depth

5 hops

Use Cases

Built for Real Applications

From chatbots to autonomous agents, power your AI with long-term memory

Conversational

Conversational AI

Equip chat products with persistent preferences, tone awareness, and long-tail recollection so they sound brilliantly personal.

Context windowsSentiment memorySession stitching
Assistants

Personal assistants

Launch companion agents that accumulate rituals, goals, and collaborative context while staying effortlessly organized.

Habit graphsTask recallAdaptive prompts
Knowledge

Knowledge management

Convert knowledge bases into living graphs the moment documents land, unlocking razor-sharp semantic discovery.

Document syncWaypoint graphsSemantic search
Autonomy

Autonomous agents

Give mission-critical agents durable context for planning, tool choice, and retrospective learning.

Workflow memoryTool outcomesAdaptive loops
Quick Start

Get Started in Minutes

Simple, intuitive API that gets you from zero to production-ready memory in just a few lines of code

example.js
// Add a memory with automatic multi-sector embedding
await fetch('http://localhost:3000/memory/add', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    content: 'User prefers dark mode and minimal UI design',
    metadata: { source: 'preferences', category: 'UI' }
  })
});

// Query memories with decay-weighted relevance scoring
const response = await fetch('http://localhost:3000/memory/query', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    query: 'What are user interface preferences?',
    topK: 5
  })
});

const { results } = await response.json();
// Results include memories with decay scores and sector breakdowns
Launch ready

Ready to get the memory stack your agents deserve?

Deploy OpenMemory with a hardened decay engine, multi-sector embeddings, and production-grade retrieval in just a few minutes.

Instant deployment

Spin up the memory graph with one command and start reinforcing context immediately.

Always-on retention

Decay audits, reinforcement pulses, and attribution trails are baked in from day one.

Launch kit

90s setup

CLI bootstrapready
Decay engine auditauto
Agent bindingsNext, Python
Decay curveReinforce pulse