Meaning Memory Request Access
Introducing Meaning Memory

Structured Cognition for Agent Fleets

Meaning Memory is the persistent memory layer for enterprise AI agent fleets. Four memory types, semantic, episodic, procedural and commitment, each scored across five STARE dimensions, compiled deterministically, and shared across agents with provenance on every entry. Your agents remember what matters, keep their promises, and see what happened in the sessions they were not in.

Request a License Explore STARE

Now included with every license: Switchback agent coordination MCP →

STARE 5D radar chart: Significance, Temporal, Asymmetry, Relational, Episodic dimensions on a single memory entry.
Works with
The STARE Framework

Five Dimensions of Meaning

Meaning Memory scores every entry across five orthogonal cognitive primitives. Dimensions compose at compile time (additive richness boost) and at retrieval time (attribution-aware weighting), so significance, recency, attribution, relational fit, and episode membership all gate the rank, not just one weighted vector score.

S

Significance

First-class composite importance, measured twice

Significance is the foundational dimension, the one every other memory system gets approximately right and then stops. Meaning Memory treats it as a first-class composite, not a scalar.

Every memory carries two significance scores: sig_self (how important the agent thinks it is) and sig_external (how important the operator's policy thinks it is). When they diverge, the system records the divergence and the rationale. This is the encoding-compliance moat: a dual-write architecture where an extractor LLM catches the moments the agent forgot to call mm_remember, with STARE Sig arbitrating which write survives merge.

Why it matters

Probabilistic LLM agents silently fail to record what mattered. No retrieval, decay, or calibration system can recover what was never written. Significance, measured twice and arbitrated deterministically, is what closes the encoding hole.

Scenario
"A customer-service agent is told 'I'm thinking about cancelling, this is my third call about the same issue.' The agent answers helpfully but never calls mm_remember(). In every other memory system, that statement is lost. In Meaning Memory, the passive extractor catches it, scores it (sig 0.92, high), and the operator's churn-risk playbook escalates the next interaction. The agent's miss didn't cost the company the customer."
How Meaning Memory implements it
sig_self + sig_external numeric columns. divergence_rationale text for audit. Operator-controllable sig floor per tenant, per playbook. Grounded in Conway and Pleydell-Pearce 2000 Self-Memory System theory.
T

Temporal

Configurable decay curves and validity windows

Temporal is more than a timestamp. Every memory in Meaning Memory carries three time signals: when it was observed, when it becomes valid, and when it stops mattering.

Decay curves are operator-configurable per playbook. Some memories decay fast (today's traffic numbers). Some stay forever (a customer's allergy). Some don't decay but expire on a deadline (a paused deploy that resumes after security review). Meaning Memory tracks both decay and validity windows independently.

Why it matters

KV caches solve freshness with TTL. Vector stores solve recency with score boosts. Neither captures the truth that some memories fade, some expire, and some stay forever, and which is which is a governance question, not a heuristic.

Scenario
"A developer agent learns at 9am: 'The deploy is paused, security review in progress.' At 3pm, the security review closes. In a TTL cache, the memory expired hours ago. In Meaning Memory, valid_until=15:00 marked it temporally invalid the moment the review closed, and the audit trail shows exactly when, why, and which event triggered the transition."
How Meaning Memory implements it
valid_from / valid_until columns. Three decay shapes ship today: none, step, and exponential, selectable per playbook. Phase 4 compile honors both decay and validity.
A

Asymmetry

Explicit attribution and trust gradients

Asymmetry, also called Attribution, is the dimension most memory systems treat as post-hoc filtering. In Meaning Memory, every memory carries explicit writer attribution and an attribution-register score native to the data model, with per-perceiver retrieval-policy modifiers derived from it; corroboration-based warrant scoring on the roadmap.

In multi-agent deployments this matters enormously. The same statement ("our churn rate is 4.2%") from the CFO and from a customer comment should not carry the same retrieval weight. Asymmetry encodes the attribution-register gradient at the schema level so register-aware retrieval is possible without bolt-on filters.

Why it matters

Enterprise multi-agent fleets are political ecosystems. Marketing's agent sees one version of "true." Engineering's sees another. Legal's sees a third. Without attribution as a first-class primitive, cross-agent memory becomes either dangerously homogenized or frustratingly siloed. Asymmetry lets you have shared facts with register-aware retrieval.

Scenario
"Three agents in the same scope group store the memory 'the bug is in payments.' One is the QA bot. One is a customer-service summary. One is the engineering on-call escalation. Attribution-register scoring lets retrieval weight the more-strongly-attributed memory higher for evidence-driven roles. Same fact, different attribution register; register-aware ranking (per-perceiver policy in validation)."
How Meaning Memory implements it
Attribution-register score and per-perceiver modifier JSONB on every entry. Writer attribution captured at write time. Register-aware retrieval ranking (per-perceiver policy, fail-closed) — activation in validation. Corroboration-based warrant scoring and hostile-input detection are on the roadmap.
R

Relational

Typed edges, 1-hop filters, and provenance

Relational turns memories into a typed graph. Every memory can connect to other memories, agents, documents, customers, projects, people, concepts, events, or commitments. Nine bounded target types ship today, plus a custom:* namespace for domain-specific extensions.

Production R-dim today means clean schema primitives: vocabulary normalization, typed edges with provenance, predicate-gated retrieval, and 1-hop filters via mm_search(related_to=, min_r=). Vector similarity surfaces "memories that look like this." Relational edges surface "memories that matter to this."

Why it matters

Enterprise agent fleets need explicit linkage between memories, customers, and commitments, with audit-grade provenance on every edge. That is the shipped Relational contract. Multi-hop graph traversal remains a research track; LoCoMo-scale benchmarks have not shown proven retrieval lift at current architecture (pending further benchmark validation).

Scenario
"A customer escalation comes in. The agent searches with related_to= on the ticket memory and min_r= on the engineering bug link. One hop returns the bug report, the deploy memo, and the QA verification, each edge typed, each with asserted_by provenance. No hand-wired context stitching."
How Meaning Memory implements it
r_score numeric column on mm_entries. mm_relationships typed-edge table (PG) or edges.jsonl (FileBackend) with bounded target type enum. append_relationship(), get_relationships(), and 1-hop retrieval filters on both backends.
Research note: depth-N multi-hop traversal (mm_traverse_relationships) exists in-engine but is not a customer-facing lead, deferred pending benchmark validation that proves value at fleet scale.
E

Episodic

Episode summaries and optional narrative clustering

Episodic groups memories into bounded arcs. A customer conversation isn't a list of facts, it's an episode with a beginning and a resolution. Most memory systems flatten that structure. Meaning Memory preserves it.

Every memory can carry an episode_id. Episode summaries (mm_episode_summary, mm_search(episode_id=)) ship stable on both backends. Open Threads, which weaves related episodes into a single thread the agent can follow, ships as an opt-in beta since v3.18 (MM_E_ARC_WEAVE_ENABLED, default off); the deterministic narrative renderer runs only when Mode B is enabled.

Why it matters

The unit of recall in human memory is not the fact. It's the episode. Episode summaries give operators and agents a bounded working set without loading every underlying memory. Narrative clustering adds chronology when you opt in.

Scenario
"A multi-day support escalation involves 14 separate agent interactions. The on-call SRE calls mm_episode_summary on episode 7a3f and gets title, time bounds, entry count, and summary metadata, stable today. With Mode B enabled, Phase 4 compile can emit a chronologically ordered narrative outline for the same episode."
How Meaning Memory implements it
e_score numeric + episode_id UUID on every entry. mm_episodes summary table (PG) or workspace sidecar (FileBackend). Episode summaries stable; Open Threads arc weaving opt-in beta, default OFF.
STARE composition: one memory entry scored on five dimensions, composed at compile time as an additive richness boost and at retrieval time as attribution-aware weighting, producing the ranked result.
STARE Composition

STARE dimensions compose across compile and retrieval.

Every memory carries all five scores. Dimensions compose at compile time (additive richness boost) and at retrieval time (attribution-aware weighting), giving operators explicit control over how memories are ranked. The result is structured cognition, not flat key-value recall.

A memory that is high-significance, recently valid, from a trusted source, linked to the current episode, and connected to an active relational graph composes to the top of every query, without a single hand-tuned weight.

Observability

The 5-Phase Deterministic Pipeline

Memories don't just get written. They flow through a deterministic 5-phase pipeline. Each phase has explicit success and failure semantics, watchdogs, and OTEL-friendly observability surfaces.

Five-phase deterministic processing pipeline: Drain, Dedup, Extract, Synthesize, Compile.
Phase 0

Drain

Pending entries validated and moved to ready. Failed entries quarantined with audit trail.

Phase 1

Dedup

Embedding-based supersede detection. Identical-meaning entries merged with provenance preserved.

Phase 2

Extract

LLM-driven STARE scoring. All five dimensions populated. Extractor catches what the agent forgot.

Phase 3

Synthesize

Merge, supersede, contradict, link. Hash-chain audit event emitted for every state change.

Phase 4

Compile

Deterministic MEMORY.md projection from PG canonical. Byte-identical on replay. Manifest-anchored.

Beyond Retrieval

Memory with consequences.

A vector store hands back whatever matches. A memory layer has to know what it owes, what happened elsewhere, and how the story fits together. Three mechanisms in the current release do exactly that.

4memory types
5STARE dimensions
46MCP tools
7,600+tests in the suite
2backends, Postgres or file
Commitments

Memory that keeps promises.

"I'll handle it tomorrow" is not a fact, it is an obligation. Meaning Memory stores it as a commitment: a due date, a lifecycle the engine enforces, and an audit trail. Recurring duties carry a bookmark that only moves when an agent satisfies or waives the current occurrence. Nothing advances it on its own, so a missed duty cannot quietly disappear.

mm_due_commitments · mm_satisfy_commitment · mm_waive_commitment

How to make your agent keep its promises →
A recurring commitment timeline: satisfied, waived, the bookmark on the occurrence due now, and the next one. The bookmark moves only on satisfy or waive.
Throughline

Working memory across every channel.

Chat, direct messages, scheduled jobs, agent-to-agent traffic: each session ends somewhere the others cannot see. Throughline captures every session deterministically, surfaces the last 48 hours as a Recent tier in the compiled memory, then promotes what mattered to long-term memory with a lineage link and lets the rest evaporate. An agent asked "how did the incident room go?" can answer, even if it was never in the room.

Introducing Throughline →
The Throughline pipeline: a session ends in any channel, is captured, drains to the database, surfaces in the 48-hour Recent tier, then is promoted to long-term memory or evaporates.
Open Threads beta

Follow the story, not the pile.

Related episodes recorded across days get woven into a single thread anchored on the first one, so the agent recalls "the migration" as an arc with an open end, not four unrelated events. Deterministic anchor mode, opt-in and off by default, shipped in v3.18.

Meaning Memory Explained: Open Threads →
Four separate episodes on the left are woven into one anchored thread on the right, ending in an open item.
Architecture

Three layers. Your stack on top and bottom.

Your agent fleet on top. Meaning Memory engine in the middle. Your storage and observability layer underneath. Bring what you already trust.

Hash-chain audit on every state change. Deterministic five-phase pipeline above the storage layer. Three-layer config inheritance for vertical specialization.

OTEL-native observability.

46 MCP tools instrumented with OpenTelemetry. Tenant-aware spans, tool-call lineage, exportable to Phoenix, Datadog, Honeycomb, Tempo. The audit trail is your platform team's existing telemetry, not a parallel system.

Licensed self-host. You operate the engine.

Meaning Memory ships as a Python wheel plus customer kit. You deploy in your own VPC (Docker Compose, K8s with Helm, or bare metal). No data leaves your perimeter.

Three-layer architecture: your agent fleet on top, running on OpenClaw, Hermes, Claude Code, Cursor or Letta and talking MCP, REST or the Python SDK, the Meaning Memory engine (STARE 5D, five-phase pipeline, four memory types, audit chain) in the middle, your storage and observability underneath.
Dashboard

See what your fleet remembers.

A web admin surface for operators: STARE 5D fidelity at a glance, the full memory browser, write-to-retrieval lifecycle, and per-memory "Why this memory?" composition. Ships with the engine.

Meaning Memory admin dashboard overview with STARE 5D radar, Memory Health Score, License tile, fidelity matrix, and recent activity strips.
Memory browser with paginated list of entries showing significance score, type, writer agent, scope, and creation date.
6-stage memory lifecycle funnel showing per-stage counts and drop-off percentages.
Per-memory detail popup with STARE 5D radar chart, sig_self and sig_external scores, decay_curve, t_validity window, and scope_groups.
Adapters

Framework-agnostic. Native where it counts.

Meaning Memory exposes the engine through multiple integration paths so it slots into whatever orchestration layer you already run. Native adapters ship for the highest-velocity frameworks; CLI and REST cover the rest.

Native

MCP Server

Model Context Protocol. Drop-in for OpenClaw, Hermes, Claude Code, Cursor, and any MCP-compliant agent runtime. The fastest path for the 2026 agent stack.

Native

Letta

First-class adapter for the Letta agent framework. Code adapter ships in the customer kit at adapters/letta.py with a reference deployment recipe.

Universal

CLI

mm command-line tool. Wraps every engine operation. Use it from bash scripts, cron jobs, or any framework that can shell out.

Universal

REST API

OpenAPI-described HTTP surface. Works with LangGraph, AutoGen, CrewAI, OpenAI Assistants, or any custom agent runtime via plain HTTP calls.

On the roadmap: native Python adapters for LangGraph, AutoGen, and CrewAI are in development. The REST adapter covers the same surface today; talk to us about prioritization.

Already running OpenClaw or Hermes? Drop Meaning Memory in as a memory MCP server. Your agent loop stays exactly the way you built it.

Use Cases

Where Meaning Memory earns its keep.

Multi-agent fleets show up in every workflow that runs longer than a single context window. The shape of the work differs; the failure mode rhymes.

E-commerce

One shopper, many touchpoints, one timeline.

Cart memory across device switches and agents. Illustrative outcomes: fewer discount-stacking incidents, stronger cart-recovery continuity across touchpoints.

Customer Operations

Escalation without context amnesia.

Tier-2 reads compiled significance from tier-1, not the full transcript. Illustrative outcomes: shorter escalated handle time, fewer repeat contacts.

DevOps / SRE

Reconstruct what each agent knew, minute by minute.

Three remediation agents, one 47-minute P1, hash-chained provenance per minute. Illustrative outcomes: faster post-incident review when the timeline assembles from STARE-scored memory.

All five scenarios →
Editions

Two editions. One engine.

Pick the edition that fits your stack. Engine is the cognitive memory core. Studio adds Vexilon, our bundled hybrid retrieval layer, for teams who want corpus search in the box. Both editions include Switchback, our agent coordination MCP.

Audit-grade cognitive memory

MM Engine

STARE 5D scoring, deterministic compile pipeline, file and Postgres backends, audit-grade provenance. BYO-RAG adapter included.

Memory + Vexilon retrieval, in one install

MM Studio

Everything in Engine, plus hybrid retrieval (dense + BM25 + RRF), cross-encoder reranking, knowledge graph, and a bundled vector store.

Compare editions →
Private Beta

Want the deep technical brief?

Private beta gets you the architecture deep-dive, the customer kit (wheel + INSTALL.md + reference deployments), and a working session with the engineering team.