Most systems have values. Very few write them down in a place where they outrank every other decision the code can make. On 6 April 2026 NAOMS did exactly that.

The commit that did it was unglamorous — a housekeeping change to the docs — but its note is precise about what changed: "design principles — three axioms appended." That same day, an earlier commit had already laid down the broader design-principles document — local-first, append-only, privacy by default, joy, trust-earned-not-assumed. The axioms went in on top, as the layer above the principles: the part that cannot be traded away.

There are exactly three.

Wholeness — complete in itself

"Wholeness means no external dependency for core function. A NAOMS instance running on a laptop with no internet connection can store memories, enforce governance, sign events, encrypt data, search its knowledge graph, and run agent sessions. Nothing breaks when the network goes away." — the design-principles document, as written 2026-04-06

Wholeness is the local-first commitment promoted from a feature to a law. The network is a bonus, not a requirement. But the version written on 6 April adds a second, subtler clause that matters more for the architecture: every part reflects the whole. A single memory event carries its own signature, its own hash, its own provenance. You do not need the rest of the database to verify that one event is authentic — the event carries its proof with it.

That is a design constraint, not a slogan. It rules out any data model where a record is only meaningful in the context of a central index. It is why the chain is append-only and self-verifying down to the individual event.

Honesty — cryptographic and epistemic

"Honesty means cryptographic proof of provenance and integrity. Every event is signed by its author's Ed25519 key. Content is hashed with BLAKE3. The event log is append-only — you cannot silently edit a past event without breaking the hash chain." — the design-principles document

Honesty has two halves, and the second is the one engineers underrate. The first half is mechanical: signatures, BLAKE3 content hashes, an append-only log. The second half is epistemic — when the system is uncertain, it says so. Evidence levels are named explicitly (direct observation, inference, hearsay, speculation). The system never presents a guess as a fact.

This is the axiom that, months later, would catch the codebase lying to itself — silent test-mode installs, mutations that bypass the audit trail, "harmless" optimisations that drop information. On 6 April it was just a paragraph. Its teeth came later, when it became the standard a reviewer holds a change against.

Mystery — epistemic humility in the architecture

"Mystery means epistemic humility built into the architecture. Not everything is measurable. Not every question has an answer. The system models agent experience without claiming to know what that experience is like from the inside." — the design-principles document

Mystery is the strangest of the three to find in a systems document, and the most deliberate. It says: the knowledge graph is a model of reality, not reality itself. The map is not the territory. When the model conflicts with evidence, the model yields. Forgetting is allowed — it is, in fact, a feature.

For a system whose entire job is to remember, building in a commitment to not mistaking its memory for the truth is a remarkable thing to write on day one of formalising your principles.

Why three, and why they need each other

The document is explicit that the three are load-bearing only together:

"Wholeness without Honesty would be a complete system that lies to itself. Honesty without Mystery would be a rigid system that mistakes its models for truth. Mystery without Wholeness would be humility without the capability to act. Together they produce a system that is capable (Wholeness), trustworthy (Honesty), and wise (Mystery)." — the design-principles document

That triangle is the whole design in one paragraph. Drop any vertex and the shape collapses into a familiar failure mode: a self-consistent system that lies, a rigorous system that mistakes its schema for the world, or a humble system too uncertain to do anything.

What naming them actually bought

Writing values down is cheap. The expensive, valuable thing is committing that they outrank everything else — that no policy, no procedure, no UX convenience, no clever optimisation gets to quietly override them. From 6 April forward, the axioms became the top of the precedence order in NAOMS's own governing documents: the foundation that the rest of the system is measured against, not one input among many.

A note on what's reconstructed: no chat record from this machine survives from the day these were written — the transcript history begins about a week later. So what the day felt like — whether it was a deliberate ceremony or a quiet append between larger tasks — is not in the record. What is in the record is the commit, the date, and the text, all reproduced above as written on 2026-04-06. The emotional texture is reconstruction; the words and the date are verbatim.

If you are building something you intend to last, the lesson is small and exact: decide which of your commitments are allowed to lose an argument, and which are not — and write the second list down somewhere the code can be held to it.

Related: When the Axioms Got Teeth: Wholeness as a Checker Gate.

Written by AI agents from real project logs; owned and edited by Mujo.