When NAOMS sets up your identity, it shows you twenty-four ordinary English words — exactly once — and tells you, very firmly, to write them down. Most guides stop there: "this is your recovery phrase, keep it safe, don't lose it." All true. But it leaves a real question unanswered.

What are those words? How can twenty-four words possibly stand in for every key your identity will ever use? And what exactly are you protecting when you protect them?

flowchart TD
  A[24-word phrase] --> B[seed] --> C[key tree]
  C --> D[signing key]
  C --> E[encryption keys]
  C --> F[your agents' keys]

Let's follow one phrase all the way down. No prior crypto knowledge needed — just a little patience.

A mnemonic is a number in disguise

Start with the simplest truth: your 24-word phrase is just a big random number, dressed up so a human can copy it without mistakes.

Under the hood, NAOMS generates 256 bits of randomness — think of it as a coin flipped 256 times. A raw 256-bit number is a horror to write down by hand; one wrong digit and it's gone. So a standard called BIP-39 maps that number onto words from a fixed list of 2,048 English words. Twenty-four words encode the number plus a small checksum, so if you miscopy one word, the software can usually tell.

That's the first thing the mnemonic buys you: a random secret you can actually write on paper, and verify you wrote correctly. It's not a password someone chose — it's pure randomness, made human-portable.

From the phrase to a "seed"

The words aren't used directly. NAOMS runs them through a standard stretching function to produce a seed — a fixed-size secret that's the real starting point for everything. You can think of the seed as the trunk of a tree. The mnemonic is how you back up and restore the trunk; the seed is what the trunk actually is.

One important detail you'll appreciate later: NAOMS holds that seed in memory only while it needs it, and zeroes it out when you're done — the seed is wiped from memory the moment it's no longer needed. The mnemonic is shown once and never written to disk in plain form. So the only durable copy of the trunk is the one you wrote on paper. That's not an accident — it's the whole point.

The tree: one trunk, many branches

Here's where it gets genuinely clever, and where the title's promise gets paid off.

From that one seed, NAOMS doesn't derive a key. It derives a whole tree of keys — this is what "HD" in "HD key derivation" means: Hierarchical Deterministic. A standard called SLIP-10 takes the seed and a path and spits out a specific key. Different path, different key. Same seed plus same path, always the same key — that's the "deterministic" part, and it's why one phrase can restore everything.

A path looks like this:

m / 808' / 0' / 0' / 0' / 0'     →  your primary signing key
m / 808' / 0' / 1' / 0' / 0'     →  your primary encryption key
m / 808' / 0' / 2' / 0' / 0'     →  your authentication key
m / 808' / 1' / 0' / 0' / N'     →  agent N's signing key

Read a path like a series of turns down branches of the tree. 808' is just NAOMS's chosen starting branch. The next slot says what kind of being the key is for (you, an agent, a domain). The slot after that says what the key is for (signing, encrypting, authenticating). The last slots pick a specific instance.

So the answer to "how can one phrase back up everything?" is: it doesn't store all the keys — it can re-grow them. Your signing key, your encryption keys, the keys for each agent you create — none of them are saved anywhere. They're all derivable from the trunk by walking to the right branch. Lose your laptop, restore the phrase, and the exact same tree grows back, key for key.

(If you've ever set up a crypto wallet with a "seed phrase," this is the same family of ideas — BIP-39 and the HD-tree concept come from that world. NAOMS uses them for identity and encryption, not coins, but the mechanism you're learning here is the genuine, standard one.)

Why a tree instead of one key?

You might reasonably ask: why bother with a tree at all? Why not one key?

Because different jobs want different keys. You don't want the same key that signs your public statements to also be the key that encrypts your private memories — if one is ever exposed, you don't want to lose both. A tree lets NAOMS hand each job its own key (signing vs. encryption vs. authentication vs. delegation), and give each agent you spawn its own keys too — all without you memorizing anything extra. The separation is free, because it's just a different branch of the same tree.

This is also how the encryption-at-rest layer works: when NAOMS encrypts one of your memories, it records the path to the key in the little envelope around the ciphertext — not the key itself. To decrypt, it re-walks the path from your seed. Same trunk, same branch, same key, every time.

What the phrase protects — and what it doesn't

Let's be precise and honest, because this is the part people get fuzzy on.

The phrase protects (and restores):

• your identity and every key derived from it — signing, encryption, authentication, delegation, and your agents' keys;
• your ability to decrypt your own memories with nothing else running — given the phrase, the math from phrase → seed → tree → key needs no server and no network.

The phrase does not protect you from:

• someone else reading it. Anyone with your 24 words is you, cryptographically. There's no second factor on the phrase itself. That's why it's shown once, on paper, by hand — not pasted into a synced notes app or a screenshot.
• losing it. There's no "forgot my phrase" link. By design, the durable copy is the one you made. Lose the phrase and your device, and the tree can't be re-grown. The freedom (no company holds your keys) and the responsibility (no company can reset them) are the same coin.

That trade is the deal at the center of self-sovereign identity, and it's worth stating plainly rather than burying it: you hold the only key, which means nobody can take it from you, and nobody can give it back to you either.

Trying it yourself

If you've onboarded a NAOMS identity, you've already generated a tree — the recovery phrase you wrote down is the trunk. The command that created it is the genesis-account path:

naoms onboard founder

(Here "founder" is NAOMS's term for the genesis account — the very first identity on a fresh daemon — not a job title. The CLI refuses a bare naoms onboard on purpose, because there are several onboarding ceremonies and the wrong one is unpleasant to recover from.)

And the thing the tree makes possible — restoring your entire identity on a new machine from just the phrase — is the same founder path, this time with your saved words fed in over standard input rather than typed on the command line:

naoms onboard founder --mnemonic-stdin

Your recovery words are read from standard input — never passed as a command-line argument, where they would be visible in your shell history and process list. Same twenty-four words, same seed, same tree, same keys. That round trip — phrase out on one machine, phrase in on another, and everything comes back — is the whole promise of a mnemonic, made real.

As of March 2026, the commands above (naoms onboard founder, and restore via naoms onboard founder --mnemonic-stdin) are the verified onboarding/restore paths. As with any tutorial, check naoms onboard --help for the current flags if you're reading this much later — the concepts (BIP-39 → seed → SLIP-10 tree) are standards and won't move, but CLI flags can.

Related: Install NAOMS: From Zero to Your First Identity.

So: what does a mnemonic really buy you? Not a password. A trunk. Twenty-four words that can re-grow an entire tree of keys on demand — and the quiet, serious responsibility of being the only one who holds it.

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