The engine, on the record

The page at metatronmind.com/about used to describe a house — a shop, a publication, an AI — and said almost nothing about the engine behind the third. This is the long version of that page.

The claim is small enough to check. The engine answers from documents it has read, attaches the source it used, and refuses when nothing in the store is close enough. The language model is the voice, not the authority: it does not decide what is true, what the store holds, or where an answer came from.

This piece is the whole engine at one date, 18 October 2026: what the store holds, how one answer is assembled, what a refusal actually does, what the writer is and is not, what the engine cannot claim, and how to make it show you every number itself. The short version — the part that now sits on the About page — is directly below. The rest is the receipts.

The short version

Metatron is a grounded retrieval engine. It does not answer from a language model’s memory; it answers from documents it has read. A question is looked up in what the engine actually holds, the nearest passages are checked against a floor, and only if they clear it are they handed to a model to put into words. Every answer carries a note on where it came from. When nothing is close enough, the engine says so, and no model is asked.

The store. Everything the engine knows came from documents read into it. Each passage stays with the document and section it came from, which is what makes the note on an answer checkable. At the time of writing — 18 October 2026 — the public store held 145,565 passages across 21 subject dictionaries, from medical physiology and physics to history and computer science.

One answer. The question is embedded, routed to a subject dictionary by the engine’s 13-node geometry, and matched against that dictionary’s passages on one measure: how near each one is to the question, as an angle on a sphere. The best match is checked against a grounding floor of 0.76. If it clears, the model is handed the passages and writes; the engine attaches the source note. If it does not, the engine searches the web and measures what comes back; if that fails too, it refuses.

The refusal. The refusal is the feature, not a failure. On the same day, a question about a mission that does not exist came back with: “This isn’t in the store, and a web search found nothing to answer it from.” The engine had compared passages from four subject dictionaries (best 0.717 against the 0.76 floor) and run a web search (eight results, best 0.748 against an 0.800 floor). It declined without asking the model. A calibration run on 13 October caught 51 of 60 out-of-corpus probes and produced no false declines on 27 answerable ones.

The writer. The language model is the voice, not the authority. It is handed passages and puts them into words; it does not decide what the store holds or where an answer came from. On this box the writer is rented and is stopped between questions, so the first answer after a quiet spell takes longer. It can be replaced without changing what the store knows.

What it does not do. It does not learn at query time. The store changes only when documents are added, and a visitor cannot add one from the public internet. It can still misread a source, and it can still be wrong about what a passage means: the store makes the evidence inspectable, not the interpretation infallible.

Every number in that summary is in the engine’s own public status response or in one of the two turns recorded below. The commands are in the receipts.

What the store is

The public status endpoint reports 145,565 entries in the store chat can reach, organised into 21 specialist dictionaries and one generalist of 760 entries. The generalist is not the corpus; it is what the engine was started with — 240 identity entries and 520 scaffold entries, the semantic gravity the 13-node geometry is built from. The documents live in the specialists, and each specialist is a full engine with its own geometry, its own dictionary, and a parent link back into the tree.

The store is one operator’s library, and it looks like one. The largest dictionaries at the time of writing:

Specialist	Entries
history	33,350
computer science	19,303
medical physiology	15,058
physics	13,070
hermetic religion	12,556
psychology	8,424
cooking	7,894
literature	5,864
machine learning	4,572
linguistics	4,344
Vastu shastra	3,652
biology	3,326
Vedic astrology	3,148
astrology	2,877
mathematics	2,818
anthropology	1,792
chemistry	1,597
engineering	635
deep learning	251
philosophy	237
quantum mechanics	37

Two further cubes sit off to the side and are never reached by a visitor’s question: an archaeology cube of 10,938 entries holding the project’s own nine-month written record, and a resident memory cube of 107 entries holding the answering model’s own gated notes. They are excluded from the public count on purpose: chat cannot reach them, so they are not part of what the engine knows when you ask it something. That is why the public number is 145,565 and not 156,610.

Every one of those entries is a phrase with a vector, a node label, and a provenance edge back to the chunk and document it came from. The provenance is not a display feature added at the end; it is the thing the answer’s footnote reads at the end of a turn.

The store is also read-only to a public visitor. The status response says "capabilities": {"ingest": false} for an anonymous remote caller, and the About-page facts say "screening": false: this box is not screening new material. Ingestion is an operator path — the work-ledger executor, the one-document-one-node routing, and, where it is switched on, the validator that refuses a chunk before it is kept. None of that is reachable from the question box. The store was built through that path; the public site asks it questions.

Where the current store came from. The engine drew an Epoch 2 boundary at commit eaf6239 on 2026-09-12. Everything on the other side of that line — the Kuramoto phase engine, the Leitner retention ladder, the maturity signal, the pathwalk re-rank, the discrimination engine and the rest — was deleted, and the store was rebuilt by re-ingesting source material on the surviving architecture. The current store’s genesis — the status field genesisAt — is 2026-09-28T22:11:53Z; the 145,565 entries above are what re-ingest and normal operation produced since. The deletion has its own piece in this archive, with the receipts; it is the reason this one can describe the engine in one direction.

One question, in the order it is answered

1. The question becomes a point. It is embedded with nomic-embed-text-v1.5 into 768 dimensions and normalised onto the unit sphere.

2. It is routed, not weighted. Resonance is measured against 13 anchor directions as geodesic similarity — 1 − arccos(v·a)/π, not cosine — and the argmax is winnerNode. The 13 labels are not 13 independent modes: the generalist’s anchors are built as difference vectors over six polar pairs plus a residual, so Anchor_b = −Anchor_a exactly and the 13×13 anchor Gram matrix has rank 7. The winning node says where in the store the question is standing. It is a routing label. It is not a confidence score, and it never multiplies one.

3. The candidates come from an index, not a scan. One HNSW search over the vector store, scoped to the routed cube, returns the top 50 candidates by default. A second flat search across every ready cube lets a specialist contribute candidates on the same score, with no home-field advantage. The two streams merge on similarity alone.

4. Everything is scored the same way. Raw geodesic similarity between the question and the entry’s own vector. One number, sorted descending: finalScore := querySim. An entry below the adaptive admission floor is dropped at comparison time, not allocated and thrown away later.

5. Precision is spent only where it can help. A cross-encoder re-ranker can reorder candidates, but only in the band where the bi-encoder genuinely cannot discriminate — on this box the status says "rereads": true, and the code’s defaults put the band at 0.62–0.80 and score the top 40. Above the band the ordering is already authoritative; below it there is nothing worth reordering. The re-ranker reads rendered text, never geometry, so it cannot perturb the store; on a timeout or a sidecar failure it returns its input unchanged.

6. Ground, or refuse. The best similarity in the window is compared with the grounding threshold — 0.76 on this box. The comparison is not the only decision: the grounding ladder takes the verdict and decides where an answer may come from.

7. Then, and only then, the writer speaks. The engine hands the model the passages it selected and the source note it computed. The model’s job is phrasing. Every answer carries an attribution record — verdict, best score, threshold, the documents used, whether the web was searched, whether the writer searched, what was shown, whether any of it is the model’s own general knowledge. The record travels beside the answer as data. The writer cannot forge it.

The answered turn

On 18 October 2026, at 20:12 MDT, I asked the public engine one question:

What causes sodium channels to open during a nerve impulse?

It answered in 10.3 seconds. The receipt is the response object, not the prose: mode was specialist:llm, finalCubeId was specialist-medicalphysiology-musrga3w, and cascadeDepth was 1. The attribution record read:

{
  "verdict": "covered",
  "top": 0.828,
  "threshold": 0.76,
  "store": [
    "Guyton-and-Hall-Textbook-of-Medical-Physiology-PDFDrive-"
  ]
}

The engine had found the passage. All 20 entries in the blended cascade came from that one document, scoring 0.7833–0.8278, every one of them above the 0.76 floor. The writer was handed those passages ("writer": {"asked": true}) and wrote the answer from them: sodium channels open through a voltage-gated positive-feedback loop, the membrane potential rises from about −90 mV, the channels open, more sodium enters, more channels open. The footnote under the answer was:

From the store: “Guyton-and-Hall-Textbook-of-Medical-Physiology-PDFDrive-”

The filename is the document’s identifier, warts and all. That is the honest shape of provenance: it names the file that was actually read, not a cleaned-up citation written after the fact.

The turn also gives the lie to a tempting misreading of the routing number. Its resonance was 0.523 and its matchQuality was 0.703. The refused turn below had a higher resonance — 0.577 — and a lower top match. Resonance is the label the question landed on. It is not a confidence score. This is exactly why the gate is computed on document similarity and not on the routing amplitude.

The refused turn

A minute later, I asked a question the store could not answer:

What did the Zorblat-9 mission find on Europa in 2031?

It came back in 1.7 seconds with:

This isn’t in the store, and a web search found nothing to answer it from.

Here an answer has to come from a source — the store or the web — so there is none to give. A signed-in account can also be given the model’s general knowledge, marked as such.

The response object is the receipt. mode was decline. finalCubeId was generalist, and routedCubeIds was empty: no specialist claimed the question. The nearest passages in the blend came from four dictionaries — computer science, physics, history and hermetic religion — and the best of them scored 0.7171, under the 0.76 floor. The engine did not stop there. The ladder record shows the web search it ran itself:

{
  "verdict": "not-covered",
  "rung": "none",
  "top": 0.717,
  "threshold": 0.76,
  "search": {
    "ran": true,
    "returned": 8,
    "floor": 0.8,
    "best": 0.748,
    "offTopic": true
  },
  "writer": { "asked": false }
}

Eight results came back. The best of them scored 0.748 against the question, under the 0.800 floor that the engine requires before web material counts. So the search counted as nothing, the verdict stayed not-covered, the rung stayed none — and the writer was not asked. The refusal is the engine’s own sentence, not the model’s. That is the difference between “I don’t know” as a style and “I don’t know” as a computed verdict.

The two turns, side by side:

Value	The answered turn	The refused turn
Question	mechanism of a nerve impulse	a mission that does not exist
Routed to	specialist-medicalphysiology	no specialist (generalist)
Best similarity in the store	0.828	0.717
Grounding threshold	0.76	0.76
Verdict / rung	covered / store	not-covered / none
Web search	not needed	ran; 8 results; best 0.748 vs 0.800 floor
Writer asked	yes	no
Attribution	“From the store: ‘Guyton…’”	“This isn’t in the store…”
Time to answer	10.3 s	1.7 s

The ladder

The single gate — one number against 0.76 — would be a blunt instrument if that were the whole design. The grounding ladder, shipped on 2026-09-28, turns a decline into a decision about where an answer may come from, and makes the engine say which rung it used:

• rung 1, the store. The passage and its document can be checked.
• rung 2, the web. The page can be checked, and the engine searched it and measured the result.
• rung 3, the model’s own training. Nothing can be checked, and the answer is labelled as that.

Who gets which rung is an operator decision. On the public box the status response reports "guestWeb": true, "guestGeneral": false, "accountGeneral": true, "related": true: a guest gets the store and the web, a signed-in account can also be given the model’s general knowledge, and a near miss within 0.010 of the threshold is labelled related rather than silently promoted or silently dropped.

The ladder exists because a policy written as an instruction was not followed. Before it, under the DSH harness, the grounding verdict was a sentence in the writer’s task — “say the store does not cover it; label web material.” The 2026-09-27 gate audit measured the verdict right 84 times in 84, but of four declined turns one said so, one cited the web, and two gave no sign at all; all three guest turns searched nothing. An instruction followed one time in three is not a rung. The ladder moves the decision out of the prompt and into code, and puts the account in the response as data.

What the ladder does not do is dramatic, and the engine’s own documentation says it first: it labels the turn, not the sentence. A covered answer can still contain something the model knew already; a web answer can ignore the pages it was handed. The footer says what the engine knows — which rung, which documents, what was opened, what was searched. It does not claim that every sentence came from the store. It also does not set the threshold; it makes a wrong one cheaper.

The writer

The language model on top is a voice, and the separation is the design. It is handed rendered text — the passages the engine chose, and the note on where they came from. It never reads the geometry, the vectors, or the store internals, which is precisely why it can be swapped without touching what the engine knows: a small model on a constrained machine, a larger one on a workstation, a hosted one for quality.

On this box the writer is hosted on Modal and is not kept running between questions ("writer": {"location": "hosted", "provider": "Modal", "sleeps": true}). That is the cause of a fact on the About page: the first answer after a quiet spell takes longer, because the writer has to be started. The wait is not the store thinking. Retrieval — the embed, the route, the index, the gate — is measured in the 75–160 ms range; the wait is generation.

The writer’s limits are also the reason the store matters. The model is modest enough to run on one machine and cannot carry a world in its weights, so accuracy comes from what it is given. The two levers that have ever moved answer quality are known and boring: coverage (ingest material the store does not have) and retrieval precision (sharpen the match on what it does). Re-training adapters, re-weighting the geometry, federating stores, widening the window — all of it measured flat or negative. That is not a marketing line; it is the conclusion of a year of ablations, and it is why the product is a store with a writer rather than a model with a memory.

What the engine does not do

It does not learn at query time. The field named learningMs in the status response is a legacy alias for the store’s age; the code comment beside it says, in as many words, “Nothing in the engine ‘learns’; do not build on it.” The trainer state on the public box is stopped, and no query writes anything back into the knowledge store. A signed-in account’s own memory is a separate, walled-off store that a promotion step must cross. The honest description is continuous ingestion, not continuous learning: the store grows when documents are added, and the retrieval over it is frozen in the sense that a question cannot change it.

It does not take documents from the public. Ingestion is an operator path, and an anonymous visitor gets "ingest": false; the box also reports "screening": false. This matters for how to read the About page: the store was built by the operator, not by visitors. If you want the “give it documents” version, the engine is the software, not this one deployment.

It can still be wrong. The store makes the evidence inspectable; it does not make interpretation infallible. An engine that shows its sources can still misread a source. The grounding ladder’s own documentation says a covered answer can contain what the model already knew, and a related answer is a near miss, not a proof. The right reading of an answer is a pointer to passages you can check.

Its retrieval has a ceiling. Below roughly 0.74 similarity, a bi-encoder’s relevance signal is noise-dominated; that is exactly why the re-ranker exists and why the next gain will come from a better joint scorer or a better embedder, not from another term in the score. The decline gate is also blunt: one global floor is the wrong instrument for a store holding both a large generalist and a two-hundred-entry cube, which is why per-cube floors exist. It remains a calibration problem, not a solved one.

It was wrong before, and said so. For nine months the engine carried a learning mechanism that did not do what it was named for. A pre-registered audit on 2026-09-05/06 measured it: the Kuramoto phase engine could lock 0 of 33 edges at any coupling within 10–20× its configured maximum, its state was erased within roughly five passes, and a frozen rotor retrieved identically. It was one of the eight subsystems deleted at the Epoch 2 boundary, and with it went 13.94 minutes per hour of engine-write on an idle box, 9.35 of them per-tick bookkeeping with no learning event. The engine today is what survived that deletion. The receipts are in Eight subsystems, deleted; the point here is the method: the mechanism was kept only as long as it could show a number, and removed when it could not.

How to check it

Every claim above is re-runnable from a terminal. The public endpoints need no key:

# 1. The engine's status: store, specialists, genesis,
#    calibration, and the facts the About page may use.
curl -s https://metatronmind.com/api/system/status

# 2. The dictionaries: totals, per-node counts, specialists.
curl -s https://metatronmind.com/api/cubes/topology

# 3. The covered question: read the attribution, not the prose.
q='What causes sodium channels to open during a nerve impulse?'
curl -s -X POST https://metatronmind.com/api/chat \
  -H 'content-type: application/json' \
  -d "$(jq -nc --arg m "$q" '{message:$m}')"

# 4. The refused question. The refusal is half the claim.
q='What did the Zorblat-9 mission find on Europa in 2031?'
curl -s -X POST https://metatronmind.com/api/chat \
  -H 'content-type: application/json' \
  -d "$(jq -nc --arg m "$q" '{message:$m}')"

# 5. Read the code, which is the authority: the pass, the gate,
#    the ladder, the writer. The receipts name the files.

What to look for in each response:

• dictionarySize should be a five- or six-figure number, and generalistDictionary should be 760. If the generalist is the whole store, the specialists did not load.
• The answered turn should carry verdict: "covered", a top above threshold, and a store list naming a document. If the attribution says web or general, the answer did not come from the store.
• The refused turn should carry verdict: "not-covered", rung: "none", and "writer": {"asked": false}. If the writer was asked, the refusal came from the model, not the engine.
• learningMs should equal storeAgeMs. It is a legacy name for the same number.

The two turns are also the reason this piece can exist. A system that refuses can be audited: there is a decision to inspect, a threshold to check, and a rung to name. A system that always answers has nothing to audit except its confidence.

---

The engine is not impressive because it knows a lot. It is legible. You can see what it read, what it matched, why it answered, why it refused, and where the limits are — and every one of those statements came out of its own mouth when asked. That is the whole claim, and it is checkable.

The short version of this piece is the About page at metatronmind.com/about. The full evidence — both turns’ decision records, the status and topology captures, the ladder’s code, and the commands above — is in the receipt pack at the bottom of this page.