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). Retrieval stays flat as data grows, 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 in the benchmark below), 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.
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 a 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.
Benchmarked, not just argued
The comparison above is the architecture. Below are real numbers from mnemo-benchmark — a module that runs all three retrieval approaches against the same synthetic dataset: OAT through a real, unmodified MNEMO agent (not a reference implementation), vector search through real OpenAI embeddings and brute-force cosine similarity, GraphRAG through real LLM entity/relationship extraction and graph traversal. Every synthesized answer uses the same LLM for all three systems, so the numbers below isolate retrieval quality, not model quality.
Retrieval time and full-turn time are reported separately on purpose: OAT's structural lookup is the O(1) claim above; the eNN reasoning step that decides where to look is real, necessary work the other two systems' simpler indexes skip — shown honestly, not folded into one blended number.
Accuracy grades the full pipeline's final synthesized answer against ground truth — not retrieval in isolation. A wrong or incomplete retrieval fails accuracy too, since the LLM can't correctly answer from data it never got.
Groundedness is graded independently of correctness: does the synthesized answer's claims trace to what was actually retrieved? A confidently wrong answer built from mis-retrieved data can still score as grounded by this definition — it's checking traceability, not correctness. The two numbers are meant to be read together, not collapsed into one.
The correctness judge sees the question, the reference answer, and the candidate answer — not the retrieved content. The groundedness judge sees the candidate answer and the retrieved content — not the reference answer. Both use the same fixed judge model and prompt applied uniformly across all three systems, so no system is graded more leniently than another.
On Multi Axis Pivot and Aggregation queries, OAT's full-turn time equals its retrieval time — there's no LLM synthesis step to time. accumulate computes the exact aggregate directly, and the answer is formatted straight from that value.
Primary comparison
Time to retrieve the answer once the system knows where to look — local computation only, no network/LLM call counted.
Same comparison, full turn
Retrieval + reasoning + answer synthesis combined — the number a user actually waits for.
Content shape and confidence
Structured records, unstructured prose, multi-axis pivot tables, and flat lookup tables — the same three systems, four content shapes. Hallucination is independent of correctness: does the synthesized answer stay traceable to what was retrieved, graded by a fixed judge model applied uniformly across all three systems.
Accuracy
Hallucination rate
Entity Relationship is OAT's one weaker category (80% accuracy, vs. 100% for vector and GraphRAG). When a customer has several tickets for different products, subject selection occasionally resolves to the wrong one — a real, disclosed limitation, not smoothed into the average below.
| Query type | System | Retrieval | Full turn | Accuracy | Groundedness |
|---|---|---|---|---|---|
| Exact Lookup | OAT (MNEMO) | 11ms | 733ms | 100% | 100% |
| Vector RAG | 20ms | 1.8s | 0% | 100% | |
| GraphRAG | 3ms | 705ms | 100% | 100% | |
| Multi Axis Pivot | OAT (MNEMO) | 10ms | 10ms | 100% | 100% |
| Vector RAG | 15ms | 1.9s | 0% | 90% | |
| GraphRAG | 3ms | 2.5s | 0% | 100% | |
| Aggregation | OAT (MNEMO) | 11ms | 11ms | 100% | 100% |
| Vector RAG | 12ms | 3.9s | 80% | 97% | |
| GraphRAG | 1ms | 1.4s | 20% | 51% | |
| Entity Relationship | OAT (MNEMO) | 7ms | 709ms | 80% | 100% |
| Vector RAG | 12ms | 1.5s | 100% | 100% | |
| GraphRAG | 2ms | 1.5s | 100% | 100% | |
| Semantic Fuzzy | OAT (MNEMO) | — | — | 80% | 100% |
| Vector RAG | 15ms | 1.7s | 0% | 84% | |
| GraphRAG | 1ms | 1.8s | 0% | 0% | |
| Overall | OAT (MNEMO) | 10ms | 348ms | 92% | 100% |
| Vector RAG | 15ms | 2.1s | 36% | 94% | |
| GraphRAG | 2ms | 1.6s | 44% | 70% |
Reading these numbers
Faster isn't the same as better.GraphRAG's raw retrieval is measurably quicker than OAT's in this benchmark — a real result, not spin. But speed only matters if the answer is actually right and doesn't invent details. On accuracy, OAT leads (92% vs. GraphRAG's 44%). On hallucination it isn't close: OAT fabricated nothing in this entire benchmark (0%), while GraphRAG hallucinated on 28% of its answers. A fast, confident, wrong answer is worse than a slower correct one — on the metrics that actually determine whether an answer can be trusted, OAT leads.
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.
