Memanto: Universal Memory for Autonomous AI

• Memanto is a universal long-term memory system for autonomous AI agents featuring a typed semantic schema, temporal versioning, and deterministic, single-query retrieval.
• It organizes memories into 13 predefined types (e.g., fact, decision, goal) to enable efficient conflict detection and rapid, semantically filtered retrieval.
• Memanto achieves sub-90 ms retrieval and state-of-the-art benchmark scores (89.8% on LongMemEval and 87.1% on LoCoMo) with lower operational costs compared to hybrid systems.

Memanto is a long-term memory system for autonomous AI agents, presented as a universal memory layer for agentic artificial intelligence. It is designed for persistent, multi-session settings in which an agent must retain facts, preferences, commitments, goals, events, instructions, and other semantically typed memories across sessions, then retrieve them quickly and deterministically when needed. Its defining components are a typed semantic memory schema with thirteen predefined categories, contradiction handling, temporal versioning, and a retrieval backend built on Moorcheh’s Information Theoretic Search engine, which the paper describes as a no-indexing semantic database with deterministic retrieval within sub-90 ms latency. On the LongMemEval and LoCoMo suites, the reported final configuration reaches 89.8% and 87.1%, respectively, while emphasizing a single-query retrieval path, zero-LLM ingestion, and lower operational complexity than hybrid graph/vector systems (Abtahi et al., 23 Apr 2026).

1. Architectural rationale and problem framing

Memanto is motivated by a shift from stateless language-model inference toward persistent agents that operate across long horizons and multiple sessions. In that setting, memory becomes infrastructure rather than a convenience: the system must preserve evolving user facts, decisions, obligations, and context changes while remaining low-latency, low-cost, and operationally simple. The paper presents this as a direct challenge to the dominant family of hybrid graph/vector memory stacks, represented by systems such as Mem0, Zep, Letta/MemGPT, and A-MEM, which it associates with a “Memory Tax” arising from LLM-mediated entity extraction, explicit graph schema maintenance, synchronization between multiple storage systems, indexing delays, multi-stage retrieval complexity, and high end-to-end latency (Abtahi et al., 23 Apr 2026).

The conceptual claim is not that semantic structure is unnecessary, but that much of the practical benefit can be recovered without graph-centric ingestion and retrieval. Memanto therefore treats typed semantic memory, conflict handling, and temporal versioning as sufficient structure for many agent deployments. A plausible implication is that the design shifts complexity from write-time graph construction to read-time semantic retrieval, while keeping the retrieval path itself single-query and deterministic.

2. Typed semantic memory schema

The most distinctive structural feature of Memanto is its typed semantic memory schema. Rather than storing all memories in a single undifferentiated pool, the system defines thirteen predefined categories. These types support type-filtered retrieval and carry implicit priority and decay semantics. The paper connects this design to cognitive distinctions among episodic, semantic, and procedural memory, and also cites ENGRAM as prior evidence that typed separation improves memory performance. One implementation caveat is explicit: although the system overview says /remember performs “automatic typing,” the appendix states that memory type assignment is currently performed by the user at write time, with automated type assignment planned for a future release (Abtahi et al., 23 Apr 2026).

Type	Example	Semantics / priority signal
fact	“User is in PST timezone”	stable, high confidence
preference	“Prefers dark mode”	moderate decay
decision	“Chose PostgreSQL for DB”	high persistence
commitment	“Deliver report by Friday”	time-critical
goal	“Reach 10K users by Q4”	active until achieved
event	“Meeting with CEO at 2pm”	episodic, decaying
instruction	“Always validate input”	procedural, persistent
relationship	“Alice manages Bob”	graph-like, stable
context	“Currently in budget review”	highly temporal
learning	“Users need simpler onboarding”	accumulating
observation	“Traffic peaks on Fridays”	statistical, evolving
error	“Do not use deprecated API”	persistent guard
artifact	“Q3 budget spreadsheet”	reference pointer

These categories are not cosmetic labels. They determine both what an agent can ask for and how memories are expected to age. Commitments are time-critical, preferences decay moderately, events are episodic and decaying, and instructions persist. This typed organization also narrows retrieval scope: an agent can query only commitments, only decisions, or only instructions, rather than searching across a flat memory store.

3. Ingestion model, namespaces, contradiction handling, and temporal versioning

Memanto is implemented as a persistent FastAPI-based local agent platform exposing three principal endpoints: /remember, /recall, and /answer. /remember stores memories with typing, tagging, timestamping, conflict detection, and optional namespace scoping; /recall performs semantic retrieval over the memory store using Moorcheh’s ITS engine; and /answer adds an LLM-based RAG layer over retrieved memories. The broader backend also includes services such as Remember, Recall, Answer, Conflict Resolution, Daily Summary, Agent Manager, Session/Auth Manager, MEMORY.md sync, and Tool Connect. Each agent receives an independent namespace, and sessions have a default duration of six hours, but retrieval is not restricted by session boundaries: all memories in a namespace remain accessible across sessions (Abtahi et al., 23 Apr 2026).

Contradiction handling is built into the write path. When a new memory semantically conflicts with an existing memory of the same type in the same namespace, the system flags the issue before persisting the contradiction. The example given is a project deadline changing from April 15 to May 1. Detection is described as semantic similarity matching with a configurable contradiction threshold. The system then exposes three explicit resolution options: supersede, which replaces the old memory; retain, which keeps the old memory; and annotate, which preserves both and attaches a conflict flag for human review. The paper does not provide pseudocode or a formal contradiction-scoring equation, so the exact conflict classifier remains unspecified.

Temporal versioning extends this consistency model into historical querying. Memanto keeps superseded facts rather than destructively overwriting them, enabling three temporal query modes: as-of queries, changed-since queries, and current-only queries. This lets stale facts, updates, and contradictions coexist in history while preserving a clean current state for ordinary recall. The system also generates “daily intelligence” artifacts, including daily summaries, contradiction reports, and conflict-resolution prompts stored as local Markdown and optionally synced to cloud storage.

4. Retrieval substrate and operational semantics

Memanto’s retrieval backend is Moorcheh’s Information Theoretic Search engine. The Memanto manuscript provides a high-level description rather than full retrieval equations, but it names three components: Maximally Informative Binarization (MIB), which compresses floating-point embeddings into binary form with a claimed 32× compression and “no measurable loss in retrieval-relevant signal”; Efficient Distance Metric (EDM), which replaces cosine similarity with an information-theoretic distance; and Information Theoretic Score (ITS), a normalized relevance score in $[0,1]$ (Abtahi et al., 23 Apr 2026).

Operationally, Memanto’s retrieval path is intentionally minimal. The final system uses a single retrieval query per question, with no multi-query retrieval, no recursive querying, and no reflective passes. The appendix specifies a dynamic retrieval budget of up to 100 chunks, governed by ITS threshold gating rather than fixed top-$k$, with an ITS threshold of 0.05. The paper’s design interpretation is explicit: for agent memory, recall matters more than early precision pruning, and modern LLMs can act as the final filter over a broader retrieved context.

The system also emphasizes zero-indexing behavior. New memories become immediately searchable at write time because there is no separate ANN index-construction phase. Ingestion uses zero LLM invocations at write time, which sharply contrasts with systems that require entity extraction or note construction on every write. The paper further cites underlying Moorcheh engine metrics from separate validation on the MAIR benchmark: 64–74% NDCG@10, 9.6 ms distance calculation latency versus 37–86 ms for PGVector and Qdrant, 2,000+ QPS, and a 6.6× end-to-end speedup versus a Pinecone plus Cohere reranking pipeline. Within Memanto itself, the reported operational envelope is sub-10 ms ingestion and sub-90 ms retrieval.

5. Empirical evaluation and ablation trajectory

The main evaluation is on two long-horizon conversational-memory benchmarks. LongMemEval$_S$ contains 500 manually curated questions across six categories and uses roughly 115K tokens across ~50 sessions. LoCoMo contains long-form multi-session dialogues spanning 35 sessions, 300 turns, and about 9K tokens on average. These tasks stress multi-session recall, temporal reasoning, knowledge update, and synthesis over long interaction histories (Abtahi et al., 23 Apr 2026).

Memanto’s final reported scores are 89.8% on LongMemEval and 87.1% on LoCoMo. The paper characterizes this as state-of-the-art for vector-only systems. It also reports a comparison-table caveat: Hindsight scores higher overall, at 91.4% on LongMemEval and 89.6% on LoCoMo, but does so with a more complex hybrid reflection/vector, parallel, multi-query architecture. Other reported baselines include EmergenceMem at 86.0% on LongMemEval, Supermemory at 85.2%, Zep at 71.2% / 75.1%, Letta at 74.0% on LoCoMo, Mem0$_g$ at 68.4% on LoCoMo, Mem0 at 66.9%, LangMem at 58.1%, and Full Context at 60.2% / 72.9%.

The five-stage progressive ablation is central to the paper’s interpretation:

Stage	Configuration change	Result
1	$k=10$, threshold $=0.15$, Claude Sonnet 4	56.6% LongMemEval, 76.2% LoCoMo
2	retrieval limit 10 $\rightarrow$ 40; threshold 0.15 $\rightarrow$ 0.10	77.0%, 82.8%
3	optimized answer-generation and judge prompts	79.2%, 82.9%
4	dynamic retrieval up to 100 chunks; ITS threshold 0.05	85.0%, 86.3%
5	answering model upgrade from Claude Sonnet 4 to Gemini 3	89.8%, 87.1%

The largest gain occurs in Stage 2, where expanding retrieval breadth yields +20.4 pp on LongMemEval and +6.6 pp on LoCoMo. Stage 3 shows that prompt optimization contributes relatively little once retrieval is fixed. Stage 4 shows further gains from maximum recall, and Stage 5 adds +4.8 pp on LongMemEval through the model upgrade. The retrieval-limit curve shows an inflection around $k=40$ and plateaus above $k=60$, while average tokens per query rise from about 4.2K at $k$0 to 17.5K at $k$1 and 42K at $k$2. The paper’s stated takeaway is that the dominant bottleneck is recall, not graph complexity or prompt engineering.

Per-category results expose the remaining hard cases. On LongMemEval, Memanto reaches 100.0% on Single-session Assistant, 95.7% on Single-session User, 93.3% on Single-session Preference, 93.6% on Knowledge Update, 88.0% on Temporal Reasoning, and 81.2% on Multi-session. On LoCoMo, it reaches 78.7% on Single-Hop, 70.8% on Multi-Hop, 92.4% on Open Domain, and 85.4% on Temporal. Multi-session and multi-hop remain the lowest-scoring categories.

6. Operational profile, limitations, and place in the memory-systems landscape

Memanto’s systems argument is as important as its benchmark results. In the paper’s “Memory Tax” comparison, Memanto requires 0 LLM calls per write and 1 per retrieval, uses Moorcheh Vector DB + API key as infrastructure, has <10 ms ingest latency, and incurs zero idle cost. The corresponding entries for Mem0, Mem0$k$3, and Zep report higher LLM-call counts, ingest latencies of approximately 500 ms, ~2 s, and ~3 s, and fixed idle cost. For an agent performing 10K daily memory operations, the paper estimates \$k$42.32/day for Mem0-Graph</strong> and <strong>\$k$5662 annual savings per agent relative to Mem0-Graph (Abtahi et al., 23 Apr 2026).

The limitations are explicit. The benchmarks are conversational and do not test non-conversational workflows such as coding, research assistance, or multi-agent coordination. The paper estimates that about 5% of LongMemEval and 6–7% of LoCoMo contain ambiguities or inconsistencies, which may cap measurable progress. Final performance depends partly on the inference model, as shown by the Gemini 3 upgrade. Moorcheh itself has been validated at larger retrieval scale, but Memanto has not yet been benchmarked under thousands of concurrent agents. Namespace isolation is the current design, while shared memory among multiple agents is future work. Finally, despite some system descriptions implying automatic typing, current memory-type assignment is manual.

Within the broader development of agent-memory systems, Memanto represents a strong argument for typed semantic memory, temporal consistency management, and deterministic single-query retrieval as an alternative to graph-heavy architectures. A plausible implication is that its main contribution lies less in introducing a new cognitive metaphor than in defining a lower-complexity operating point: typed writes, immediate write-to-search availability, contradiction-aware history, and high-recall retrieval backed by an information-theoretic retrieval engine.