Meaning Memory is a persistent memory layer for enterprise AI agent fleets. Modeled on how human memory itself is organized, it scores each memory across five orthogonal STARE dimensions: significance, temporality, asymmetry, relational, episodic. Operators get explicit control over ranking and decay. Retrieval runs through a deterministic compile pipeline, so results are repeatable and reviewable. Every entry links to source provenance, and what one agent learns becomes inherited context for the next across the fleet.
Now included with every license: Switchback agent coordination MCP →
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.
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.
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.
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.
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.
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.
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.
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."
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).
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. Multi-step narrative clustering is beta and opt-in (MM_E_CLUSTER_MODE_B_ENABLED); the deterministic narrative renderer runs only when Mode B is enabled.
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.
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.
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.
Pending entries validated and moved to ready. Failed entries quarantined with audit trail.
Embedding-based supersede detection. Identical-meaning entries merged with provenance preserved.
LLM-driven STARE scoring. All five dimensions populated. Extractor catches what the agent forgot.
Merge, supersede, contradict, link. Hash-chain audit event emitted for every state change.
Deterministic MEMORY.md projection from PG canonical. Byte-identical on replay. Manifest-anchored.
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.
26 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.
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.
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 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.
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.
First-class adapter for the Letta agent framework. Code adapter ships in the customer kit at adapters/letta.py with a reference deployment recipe.
mm command-line tool. Wraps every engine operation. Use it from bash scripts, cron jobs, or any framework that can shell out.
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.
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.
Cart memory across device switches and agents. Illustrative outcomes: fewer discount-stacking incidents, stronger cart-recovery continuity across touchpoints.
Tier-2 reads compiled significance from tier-1, not the full transcript. Illustrative outcomes: shorter escalated handle time, fewer repeat contacts.
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.
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.
STARE 5D scoring, deterministic compile pipeline, file and Postgres backends, audit-grade provenance. BYO-RAG adapter included.
Everything in Engine, plus hybrid retrieval (dense + BM25 + RRF), cross-encoder reranking, knowledge graph, and a bundled vector store.
Private beta gets you the architecture deep-dive, the customer kit (wheel + INSTALL.md + reference deployments), and a working session with the engineering team.