The thesis was seductive and we repeated it until we stopped hearing ourselves say it: just as DNS resolves a name to a location without searching every machine on earth, a memory network should resolve a question to its knowledge without searching every record. Every memory carried a rich address — domain, subdomain, entities, kind, temporal and epistemic state. Retrieval would narrow zone by zone until the answer was found where the address said it lived. The alternative to searching a haystack was knowing the shelf.

After an audit had already caught the address system misfiling (a separate story), the placements were repaired, verified, and made trustworthy. So the question could finally be asked cleanly: can a repaired address, with a real resolver, route a query?

It failed three times, three different ways:

  • Route by domain: lost 28% of the answers a full scan found.
  • Route by entity: lost 53%.
  • Best hybrid (three domains wide, overlay, graph walk for strays): still lost 9% — and narrowed the search space by a factor of only 1.4.

Every design lost recall. None constricted meaningfully. The dumb full scan beat all of them.

Then came the measurement that turned failure into finding. We ran an oracle: route each query to the answer’s true domain — the one no real query could know in advance. The oracle beat the full scan: recall rose from 0.948 to 0.966 while examining a third of the corpus, because narrowing to the correct zone removes distractors. So the map was good. The addresses genuinely predicted where things were. The fault was entirely in the aiming.

The reverse-engineering explained it. A memory was asked to route to itself: its own gist, classified alone, named its own filed domain 70% of the time. A question about that memory named the right domain 59% of the time, and named an entity the memory actually contained 30% of the time. That first number is the ceiling for all the others. If a memory’s own content only names its own zone 70% of the time, no paraphrase of that content ever will.

And that is the discovery in one line: a query is a paraphrase of a memory’s meaning, and every routing key you can build from an address is derived from something a paraphrase destroys. The subdomain key came from a cluster average — a blur that any single memory sits far away from. The domain key came from conversational context — which the query never had. The entity key came from surface names — and the query says “the storage box” while the memory says the brand name of the device. Only meaning survives paraphrase. The only handle the system had on meaning was the embedding.

There was an uncomfortable twist. The best-founded fix in the whole program — refiling memories by the situation they serve rather than the action they describe, which kept life episodes whole — is exactly what made content-based routing impossible, because the situation lives in the conversation, not in the memory’s text. Episode coherence and content-routability turned out to be a trade. Nobody had seen that a trade was being made until the experiment forced it.

The measurement that retired the thesis, rather than just wounding it, was the cost of the thing routing was supposed to avoid. One query against seventeen thousand memories: 3 milliseconds. Against a hundred thousand: 12 ms. Against a million: 90 ms. (The first internal estimate was wrong by a factor of four hundred — it had priced comparing every memory against every other, not one query against each. The record preserves the wrong number next to its correction.) The address existed to avoid looking at everything, and looking at everything was already free. Even a perfect router would have optimized a solved problem.

The replacement was built before it was believed: represent the query as meaning, find nearest memories by meaning, serve those. Measured honestly — which required fixing the ruler first, because 92 of 300 test probes asked the retriever for memories governance forbids it to serve — the semantic seeder alone found the answer in its top 25 candidates 96.6% of the time, examining 25 memories out of 12,096: a 484-fold narrowing, in 17 milliseconds, with better recall than the full scan it replaced. Same mechanism the oracle had revealed: a governed corpus is itself a constriction, and constriction removes distractors.

What died: the address as a retrieval key, and the DNS analogy. What survived: everything else the address does — governance, provenance, lineage, the organization of the corpus that makes the constriction trustworthy. The address encodes why a memory mattered. A query only knows what the memory was about. Those are different questions, and the address answers its own question well.

The production test was not a benchmark. In the retriever’s first substantial logged session — early one July morning, a funding application being assembled — the consuming model asked the memory system for what the work needed: hardware prices, the budget allocation, the classification code chosen months earlier, the client company’s history. Back came the decisions, exact, from conversations long since closed, every request and served set preserved in telemetry with timestamps and provenance. Nobody re-derived a number. The keyword search this replaced finds the right memory 53% of the time. This finds it 96.6%.