The audit-grade memory engine for enterprise multi-agent fleets. Every memory scored across five orthogonal dimensions (STARE) so retrieval is deterministic, every entry traces back to source, and the whole fleet acts on the same memory of what mattered.
Meaning Memory scores every entry across five orthogonal cognitive primitives. They compose multiplicatively at retrieval time, 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 fake with post-hoc filtering. In Meaning Memory, every memory carries explicit attribution and trust gradients native to the data model.
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 trust gradient: asymmetry_modifiers is a JSONB field per entry, and the asymmetry scale multiplies into retrieval ranking.
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 trust-aware retrieval.
Multi-hop graph traversal across typed targets
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.
Multi-hop traversal lets agents reason across the graph: "show me everything connected to this customer ticket within two hops." Recursive CTE queries on Postgres return path-explain answers, with a configurable depth cap and a statement-level timeout so a misconfigured query can never freeze the request path.
Vector similarity surfaces "memories that look like this." Relational edges surface "memories that matter to this." The first is retrieval. The second is reasoning. Production agent fleets need both.
Clustering observations into cohesive narrative arcs
Episodic clusters memories into narrative arcs. A customer conversation isn't a list of facts, it's an episode with a beginning, a turning point, and a resolution. Most memory systems flatten that structure. Meaning Memory preserves it.
Every memory can carry an episode_id. The mm_episodes summary table maintains per-episode metadata. Agents can query "summarize this episode" without loading every underlying memory.
The unit of recall in human memory is not the fact. It's the episode. When you remember a conversation, you don't reconstruct it token by token, you replay the arc. Agent memory built on the same principle composes better, retrieves better, and audits better than fact-shaped retrieval.
Every memory carries all five scores. Retrieval ranks them multiplicatively, not as a hierarchy. 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.
OTEL-native: traces, metrics, and audit events exportable to your existing observability stack. Hash-chain audit on every state change. Deterministic five-phase pipeline above the storage layer.
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. We are engine custodians, not hosting operators.
Same engine. Same API. Same pipeline. You choose based on deployment shape: multi-tenant production fleet, or agent-isolated and air-gapped.
Best fit: 10+ agents, multi-tenant deployments, regulated industries needing SQL-queryable audit trails.
Best fit: Single-tenant agents, air-gapped deployments, regulated environments that prefer file-system inspection over a database service.
Features requiring Postgres primitives (pgvector semantic search, multi-hop graph traversal, recursive audit queries) are PG-only by architecture. Everything else (5D STARE scoring, deterministic five-phase pipeline, hash-chain audit, MEMORY.md compile) works identically on both. See BACKEND-CAPABILITY-MATRIX.md in the customer kit for the per-feature breakdown.
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. Discount-stacking incidents drop 80 percent. Recovery rate climbs above 22 percent.
Tier-2 reads compiled significance from tier-1, not the full transcript. Mean handle time falls 25 to 35 percent on escalated tickets.
CSM Sarah's "champion on leave, not churn risk" survives PTO and reaches CSM Mike. Health-score false positives drop 50 percent.
Private beta gets you the architecture deep-dive, the customer kit (wheel + INSTALL.md + reference deployments), and a working session with the engineering team.