Architecture
M.N.E.M.O. — short for Multidimensional Neural Elastic Memory Organization — is vector-free: no embeddings, no vector database, and no nearest-neighbor search anywhere in the retrieval path — verified across the full codebase. M.N.E.M.O. runs on Symbolic RAG — retrieval-augmented generation without vectors. An eNN (elastic nearest neighbor) reasons over a descriptive index of Memory Paths to find the right place, then OAT deterministically retrieves the exact data at O(1).
WHERE — RAG the index
The eNN (via LLM) does not scan raw data. It looks at a finite set of human-readable Memory Paths — semantically descriptive key-value maps that identify a location in the Omni Axis Tree — and selects the one that best matches the question.
Memory Paths are descriptive, enumerable, and independent of the underlying data values. The LLM decides WHERE to look; it does not touch the data yet.
Bridge — eNN Cascade
The eNN Cascade sits between index selection and retrieval. It reasons over intent and dimensions, selects a subject, locks in the Memory Path, classifies the operation, and produces an OAT execution plan — all before a single data record is read.
WHAT — OAT the data
Once the path is chosen, M.N.E.M.O.'s Omni Axis Tree fetches the exact data via multi-axis intersection: Who, What, When, Where, Why, How. No fuzzy matching, no approximate nearest-neighbor, no re-ranking.
OAT returns exact data nodes in O(1): the lookup does the same amount of work whether the tree holds a thousand memories or fifty thousand, and the index never falls behind the data.
Precisely: O(1) describes per-node coordinate access — once a Memory Path is chosen, resolving it to its data is a direct lookup, the same way a hash map stays O(1) regardless of how many other keys exist. It does not describe the eNN step that chooses the path (a separate LLM reasoning call, timed and reported on its own on the benchmarks page), and a query that legitimately matches many nodes still costs work proportional to how many nodes it returns — same as any retrieval system. What stays flat is the lookup itself, not the size of what you ask it to return.
In M.N.E.M.O. today, that constant-time intersection lookup answers requests that name several axes at once. A request for everything under a single path walks that path's subtree instead, so its cost grows with how much sits under it.
End-to-end flow
A user asks a question → eNN understands intent and extracts entities → RAG the Index selects the right Memory Path (WHERE) → eNN creates multi-axis coordinates for OAT → OAT executes the exact intersection and returns data in O(1) → the LLM generates the answer → a deterministic, precise, grounded response.
The LLM is NOT the memory. It is the bridge between natural language and M.N.E.M.O.'s deterministic memory.
Symbolic RAG vs. vector RAG
kNN measures distance: a fixed number of nearest matches, every time, regardless of the question. eNN makes a decision: the LLM reasons per question about how far across memory to walk — chat history, then OAT memory, then the path index, then a full memory search — stretching only as far as the question demands.
| Vector RAG — kNN | Symbolic RAG — eNN | |
|---|---|---|
| Retrieval algorithm | Fixed k, distance metric, approximate nearest-neighbor | Elastic nearest-neighbor — the LLM reasons about how far to look |
| What it returns | The closest match by vector distance — may be wrong or partial | The exact stored fact, via deterministic structural lookup |
| Retrieval depth | Same fixed k neighbors, regardless of the question | Walks only as far as the question needs — no further |
| As data grows | Needs re-embedding and reindexing | Index never falls behind the data; retrieval stays O(1) |
| Explainability | Opaque — a position in a high-dimensional vector space | Human-readable Memory Paths — the reasoning is inspectable |
Not graph traversal, either
Graph-based memory (knowledge graphs, GraphRAG) also avoids vector similarity, but it still searches — traversing relationships hop by hop, with runtime that grows as the graph grows. OAT's intersection index means an exact multi-axis query resolves in constant time regardless of how much memory is stored, because the answer is found through direct lookup, not by walking a path to find it.
Measured, not claimed
Lookup time as memory grows, and the head-to-head benchmark, are on their own page.One-sentence summary
RAG the Index. OAT the Data. Semantic reasoning selects WHERE. OAT deterministically retrieves WHAT.The LLM is not the memory — it is the bridge between human language and M.N.E.M.O.'s deterministic memory. Use both for the best of semantic understanding and exact context. That same deterministic memory is what gets published and subscribed to when it's shared between agents and teams — retrieval stays exact whether it's being read by its owner or a subscriber.
