What Mnemosyne is, and what actually runs today

A separate always-on process checks each claim against its evidence with a bank of independent oracles, and nothing is committed until it does.

The adjudicator records its verdicts and their proofs to an audit chain, and is structurally incapable of writing to the knowledge graph.

Every knowledge event is written to an append-only signed record, and the record's root is published outside the machine — so tampering is detectable by someone who does not trust you.

Conversations tell her where to look. Documents tell her what is true. There is exactly one gate between the two, and it re-derives the claim from documents alone.

Clearance evaluated per fact at the moment keys are wrapped, so access is enforced by cryptography rather than by filtering results after the fact. Designed in Mk1; deliberately not yet specified for Mk2.

A separate process watching the system, able to verify what it is asked to co-sign without ever holding the right to read the contents.

Retrieval enters at the level the question needs. A pinned fact is reached by following structure, not by hoping it ranks highly.

How often a fact is read never makes it rank higher. A rarely-opened document that answers your question outranks a popular one that does not.

Graph, vector and columnar stores each hold the part of the ladder they are genuinely best at, rather than one database doing everything badly.

She keeps reasoning while an objection stands, and stops when the adjudicator has run out of them. How long she thinks is learned, not a number someone configured.

When the corpus cannot answer, she says so — and the gap is recorded as a question the company has asked, weighted by how often it is asked.

Readiness is per document, so she answers while material is still being ingested — and every answer says what was still unread when she gave it.

A request in ordinary language becomes a small set of tracked deliverables — equipped, ordered, assigned, and admitted as the contract for that turn.

One learner discovers how this company's knowledge is shaped and how to move through it. It may make her faster and sharper. It may never make her correct.

Between questions she reconciles her memory, fills gaps she has noticed, and refines her own policies. The loops that run during a query are deterministic; only the idle ones learn.

The language model is allowed to propose one thing: single indivisible facts, each anchored to the exact span it came from. It never authors the structure above them.

Everything above a single fact is assembled by deterministic workers, so the same documents always produce the same knowledge — and any rung can be recomputed and checked.

Every link between a fact and the structure built from it points both ways and is tested, so the system cannot hold evidence it can no longer find.

A readable page per subject in which every sentence traces to a checked source — assembled from the record, never composed freely by a model.

Verified company documents are answered from. Meeting notes, chat threads and transcripts are reasoned over but never answered from — a governance dial the company sets, not a hidden implementation detail.

Every outside capability — a search, a calculation, a rendered chart, a lookup — is registered, invoked, budgeted and logged in one place. It can refuse a call; it can never choose one.

"Author a document with text, diagrams, computed numbers and researched citations" is one skill with a goal — something that can be done well or badly — not five separate tool calls.

Work happens in a sandbox with a recorded egress trail. Nothing durable depends on it — which is exactly what makes it safe to delete.

Two deployment modes, one binary, one cryptosystem. In both, the customer holds the keys and nobody else can reach plaintext — managed differs in who racks the hardware, not in who can read.

Every access decision is made on the server, before HTML exists. Nothing is filtered in the browser, because filtering in the browser means it was already sent.

One terminal program turns a licensed release into a running system and then gets out of the way. Licence state is re-checked at runtime, with defined grace behaviour — and expiry can never destroy knowledge.