MAR, Beyond RAG: Retrieving Meaning, Not Words
A hypothesis to move past RAG by storing atomic concepts instead of text chunks: exact axis filters and minimal context for any existing AI model.
1. The information is in the archive, yet the system misses it
Anyone who has put RAG into production inside a company knows this situation well: you know for certain a piece of information sits in your documents, you ask the assistant, and it replies as if that line had never been written.
It happens whenever a useful concept gets expressed just once, in passing, while discussing something else. Four months ago, looking for a synthetic jacket instead of leather, you typed “my parents are vegan”. Tonight you ask: “what should I cook for my parents on Saturday?”. A person connects the two right away; in today’s tools that link drops.
An independent researcher turned this scene into a public benchmark, The Buried Clue: 150 chats from a simulated user, three constraints mentioned in passing, and one explicit control question, all run on the same 8-billion-parameter model. Across the three hidden constraints, every method failed:
- No memory: 0 out of 4, as expected.
- Standard RAG: 1 out of 4. It finds only the explicit control question about the sister’s name; it never retrieves the vegan-parents chat.
- All 150 chats in the prompt: 0 out of 4. Every conversation is in the window, yet gets lost inside 27,000 tokens (roughly twenty thousand words).
- Memorilla (16 compressed dense vectors): 0 out of 4. At 150 chats, the sister’s name Priya turns into Emily.
Four questions do not make a statistical study, and the benchmark’s author says so upfront. Still, they expose a clear structural flaw: the information exists in storage, and the retrieval mechanism misses it.
In Thinking Without Words I proposed a molecular language to represent concepts without relying on words, noting near the end that external storage should share that format. Here I bring that idea closer to everyday work: storing and finding everything we communicate. I call it MAR, Meaning-Atom Retrieval.
Like the companion notebook, this remains a theoretical hypothesis: I have not built or trained the system yet. At the end I lay out where it can break and the first test I would run to check it.
2. The fixed-size box and where RAG breaks
Standard RAG splits documents into chunks of similar length, turns each chunk into a numeric vector (an embedding), and retrieves the five closest to the question. That works as long as question and answer use similar words. It breaks in three places:
- Every vector has the same width regardless of what you communicate. It is like shipping everything in the same fixed-size box: a one-word reply (“Yes”) takes, say, fifteen hundred numbers just like a dense page packing twenty distinct concepts. Short passages get padded with meaningless detail; dense passages get squashed into a single average.
- Fixed-length slicing splits concepts apart. When a thought lands across the boundary between two chunks, neither chunk keeps the whole concept.
- It matches the words used, not the meaning. “Synthetic jacket” and “what do I cook Saturday” share zero vocabulary. The concept linking them in the jacket chat is never written as a cooking rule: it has to be understood.
Recent alternatives shift the problem around without solving it. Putting the entire archive in the prompt raises latency and cost while burying details. Letting an agent keep written summaries (like Mem0 or MemGPT) trims volume, yet loses pieces along the way: whoever summarizes drops whatever looks minor at the moment. Compressing the archive into sixteen vectors (recomputed per question, yet locked to the same fixed budget), as Memorilla does, is fast (0.12 seconds once read, roughly six times quicker end-to-end than full context on 512 documents), yet pushes point 1 to the limit: names and concepts mix like wet paint in one cup. Switch the sample message below to see the difference.
Same fixed box for everything (RAG) versus scaled concepts (MAR)
Click the three messages: MAR never discards even a “Hey!”, translating everything you communicate into concepts using only the space needed.
“Hey! All good? Whenever you are free let’s catch up over coffee, have a nice day!”
Exact same fixed vector (e.g. 1,536 floats), clinging to literal tokens like “coffee” and “day” rather than the social intent.
Throws nothing away: even “Hey, all good?” carries real communicative meaning and gets fully decomposed, freed from surface wording.
3. Translating every communication into atoms, molecules, and bonds
MAR is not a database extractor keeping dry facts while throwing everything else out: it is a system of atomic concepts that translates everything a text communicates, discarding only sentence wording.
Even typing “Hey! All good? Let’s grab coffee!” conveys plenty: opening contact, informal register, care for the listener, and a future invite. Nothing gets thrown away unless it truly carries zero meaning; in fact, a greeting rich in social intent may light up more axes than a dry note. Representation size simply follows conceptual richness, adding nothing and dropping nothing from what was meant.
Distinguishing atoms, molecules, and bonds matters here, as shown in Thinking Without Words: a lemon, a house, or an animal are already composite molecules assembled from smaller elementary properties (biological life, sentience, motion, acidity, size). Butter or a wool sweater are obviously neither alive nor moving: what links them to meat and leather is a provenance bond (derived_from → animal), which we call animal_origin for short. Thus the line “looking for a synthetic jacket, my parents are vegan” writes two distinct bonds:
- the item requested that day (
jacket), excluding anythingderived_from → animal; - on the
parentsnode, a lasting refusal toward anythingderived_from → animal.
Months later, asking what to cook or which sweater to buy your father opens parents (or climbs up to it from father) and surfaces that refusal, ruling out meat, butter, wool, and leather because all four point by provenance to the animal molecule.
What about metaphors? Writing “my father is a bear in the morning” and deleting the bear would be a mistake: if tomorrow I ask “which animal do I compare my father to when he wakes up?”, the answer would be gone. MAR keeps both sides: it records the literal trait (gruff on waking) alongside a bond tagged as metaphor pointing to the bear molecule. Literal wildlife searches skip him, while a query about the comparison itself finds the bear right away. Check the three cases below.
Provenance bonds (“derived from → Animal”) and preserved metaphors (“is a bear”)
Test the three cases below: even the bear metaphor stays in storage under a figurative tag, never colliding with literal wildlife.
Literal lookups stay unpolluted while preserving the exact figurative comparison the speaker used.
4. A thousand possible axes, zero space for unused ones
A geometric objection comes up right away: if the full space spans a thousand axes, does every small concept have to drag around a thousand mostly empty cells?
No. A concept touching four axes is a four-dimensional object inside a thousand-dimensional space, and calculations stay clean. On disk you store only (axis, value) pairs actually measured, including a real 0 like lukewarm water; the other nine hundred ninety-six axes are omitted and take zero space, just like sparse vectors in search engines.
Math breaks in only one case: treating silence as zero. Keeping the three states from the first essay separate prevents that error:
- Measured: the text states a value along that axis, positive, negative, or centered (
0). “They are vegan” and “they eat everything” are both measured, with opposite signs. - Unknown: the property makes sense for that subject (say, gluten for the parents), yet nobody has mentioned it.
- Not applicable: the property makes no sense for that concept at all, like boiling point for the number
5.
Two concepts are compared strictly on measured axes: what we do not know stays unknown, what is irrelevant stays not applicable, and neither becomes a fake zero. Inspect the three examples below.
A few axes stored out of a thousand, and why silence is never zero
Pick one of the three examples: see the single column written to disk (Measured) versus the two that take zero space.
- physical matter = yes (+1)
- solidity = liquid
- temperature = 0 (measured lukewarm!)
- source (tap or bottle?)
- exact mug volume
- gruff personality
- corporate role
Disk stores only those 3 values (including lukewarm’s real 0!). The other 997 axes take zero bytes: unmentioned traits stay “unknown”, never fake zeroes.
5. Level one: axis filters and minimal context
Once archive and prompt sit in the same coordinate space, retrieval becomes a filter over axes rather than a lexical similarity contest. Three steps:
- Touches nodes and their specific groups: asking “what do I cook for my parents?” opens
parentsand steps down to its members (father,mother). Asking “what gift should I get my father?” starts atfatherand climbs up toparents, without spilling over to other members. - Gathers bonds compatible with the request: on touched subjects, it pulls active constraints touching the same nodes or bonds as what is being chosen (food, wool, and leather via
derived_from → animal), while also filtering along the time axis (for instance what holdstodayor from today onward). - Cuts across continuous degrees and numeric thresholds alongside bonds: asking for “a gift for my father: warm, soft, and under €50” (filtering across notes or product cards encoded in the same space) combines in one pass the bond climb (
father → parents → NOT derived_from → animal, ruling out wool), degrees on continuous axes (highthermal_insulation, highsoftness, ranking brushed cotton ahead of stiff canvas), and the Geohash threshold (price < €50). There is no contradiction with section 4: searching where budget or price is discussed keeps only points that measured that axis, whereas checking a person’s constraints never turns an unknown axis (like unmentioned gluten) into a ban.
When the first filter suffices, you stop. When ambiguity appears instead (a singular prompt matching two different Marios, conflicting sources, or a required cell sitting on unknown), that ambiguity triggers a targeted second filter, such as reading the prior chat turn; and a model could be trained to pick the shortest filter path.
Level one outputs a minimal, exact context: a few clean lines handed to a standard language model so it can reason with a clear head, paired with an ID pointing to the raw passage inside a conventional database (Redis, Postgres, or NoSQL) whenever verbatim text is needed. Run the three sample queries below.
Illustrative example (Level 1): axis filter versus word similarity
Simulation on 6 sample notes: compare what lexical similarity pulls versus the minimal context MAR would pass along.
Initial project budget is €50,000.
My sister is Priya, her birthday is in April.
Looking for a synthetic jacket, my parents are vegan.
What to cook tonight for coworkers? Carbonara recipe.
Update: from May onward approved budget is €80,000.
Mario Rossi (vendor) and Mario Bianchi (project B).
Word similarity: pulls #104 (“cook”, “recipe”) and #57 (“my”), missing #88 because it talked about jackets.
Minimal context handed to AI: “User parents: refusal on derived_from → Animal [source #88, March].”
6. Level two: conceptual constraint drafts and the identity catalog
The next step would assemble a structured draft of the answer directly in concept space: prior to final prose, the system locks the exact set of concepts and constraints the reply must obey. Downstream, any language model would then write fluent sentences while staying inside those guardrails.
A practical question arises here: once words are set aside, how do you know at the end that a node is Mario, or Napoleon? And when referring to that specific chair you have used for years, rather than any chair, how do you tell it apart?
You pair the space with an identity catalog. As in Thinking Without Words, every specific exemplar (Mario, Napoleon, Priya, that single chair) receives a stable address, and the catalog links it to its exact character-by-character label. At input, crossing name, traits, and context reconnects the same Mario across a hundred chats (leaving or on ambiguous homonyms); at output, exporting the conceptual draft alongside only touched identities keeps Priya as Priya, never averaged across vectors.
7. Level three: a navigable geometric brain
Taking one further step, if every recorded concept or episode is a four-, eight-, or ten-dimensional object, an entire knowledge base becomes one thousand-dimensional space inhabited by shapes of varying sizes.
Backed by a database built natively to hold and traverse sparse geometry, even the boundary between retrieval and reasoning disappears: a model trained with standard machine learning would enter at the prompt’s coordinates and walk along shared axes and arrows. The hardest training challenge would become teaching it the exact point to stop thinking because gathered evidence completes the answer.
This is the farthest horizon of the hypothesis; the first two levels could already work on their own in front of current models. Compare what each of the three levels produces below.
One question across three levels: what each step actually produces
Starting question: “A gift for my father: warm, soft, and under €50”. Switch levels to inspect the concrete output.
• Draft reply: warm (+0.8) · soft (+0.7) · price < €50 · FORBIDDEN: derived_from → Animal
• Touched identity catalog: #ID_04 = “Dad Mario” (stored character by character)
Payoff: the final language model simply renders locked constraints into fluent prose, unable to suggest wool or garble names.
8. Existing work: atomic sentences, temporal graphs, and what changes here
Two neighboring research threads show both what already works and where an open gap remains.
The first breaks documents into minimal text units: Atom-RAG indexes passages as short “atomic facts” and decomposes questions into subqueries, while AtomicRAG links “knowledge atoms” in a graph through mentioned entities and seeds lookup by vector similarity. In both papers, though, an atom remains a natural-language sentence (such as “Japan is an island country”) designed around declarative facts and matched by vector: they split sentences into shorter sentences, whereas MAR decomposes all communication onto elementary axes.
The second thread relies on knowledge graphs: HippoRAG propagates retrieval across entity links, and Zep maintains a temporal graph tracking when conversational facts start and stop holding. A graph database already handles discrete arrows like butter → milk → cow, closes superseded budgets, and filters numbers or thresholds, yet strictly on fields someone designed into that domain’s schema: if nobody declared a softness column for a catalog, the value simply is not there. MAR relies instead on one shared table of graduated axes populated automatically by the encoder straight from prose: “thick fleece sweatshirt” lights up warmth and softness without anyone designing sweatshirt columns, and those same axes apply to a blanket or a winter day without locking every concept inside its own whole-word label.
9. Where it can break, and the first test to run
Precisely because the design holds together on paper, the three places where it can stall in practice belong upfront:
- Axis table design, learned interpretation, and version changes. Keeping the grid aligned between writer and reader works like QR code versions: once a schema version is pinned (even a lean one for a vertical knowledge base or typical user questions, leaving the full table for a geometric brain), ingestion and lookup share the exact same coordinates. Lean versions are simply subsets of the same shared table, so every axis keeps the exact same meaning across versions. Two real hurdles remain. First, unlike a QR code applying a deterministic rule to characters, mapping prose onto axes is a learned interpretation, so “they are vegan” and “they avoid animal foods” could still land on slightly different coordinates if the encoder drifts. Second, widening a subset only requires computing the newly added axes, whereas changing the master table (such as splitting one axis in two) requires re-encoding the entire archive.
- Encoder misreadings on raw input. Atomic coordinates remove ambiguity after encoding, during filtering and reasoning; at ingestion, though, the encoder still reads ambiguous human sentences and can misread a negation or an implied subject. Keeping the raw passage ID in a conventional database remains essential to inspect original wording when doubt arises (and to re-encode if the axis version changes).
- Write-time compute cost. Decomposing every page through a giant language model would cost far more than a standard embedding, making early prototypes heavy. Once an axis version stabilizes, the practical path would be training a compact machine-learning model dedicated strictly to converting text into atomic coordinates, paying ingestion once in exchange for lighter lookups afterward.
My first check stays straightforward: take the 150 chats of The Buried Clue and test level one. Simply verify whether asking “what should I cook for my parents on Saturday?” brings the vegan-parents constraint into the minimal context without dragging recipe decoy chats along. Standard RAG scored zero there; seeing how axis filtering behaves would provide the first real measurement.
Not an archive piling up sentences in hopes of matching them by echo, but a concept space queried and traversed through exact filters.