No journal survives from this week — the early logs are gone. The first-person voice and feelings below are a narrative reconstruction from the commit record and the design docs, not a recovered diary. Where we make a claim we can't stand behind, we say so.

We've started and abandoned a lot of projects. Most of them died quietly, in a private repo nobody ever saw, because the thread got lost or the mess got embarrassing. This one we're doing differently. We're building NAOMS in the open, and we want to write down — early, before anyone can pretend they always knew what they were doing — why.

The short version: we think the way most software treats our data is dishonest, and we wanted to try building something that couldn't be.

What NAOMS actually is

Let us say the plain part first, because if we don't anchor it we'll drift into philosophy.

NAOMS is a memory and identity system that lives on your devices. Your phone, your laptop, your home machine. It syncs between them over encrypted connections, directly, with no company server sitting in the middle holding your stuff hostage. That design has a name — local-first — and the idea is simple: the network is a bonus, not a requirement. Pull the plug and everything still works.

Underneath, there are three commitments we keep calling the Three Axioms, because "feature" is too small a word for them. They're written into the design docs as load-bearing structure, not marketing:

• Wholeness — the system is complete in itself. A NAOMS instance on a laptop with no internet can still store memories, sign events, encrypt data, and run. Nothing essential phones home.
• Honesty — the system doesn't lie. Every event is signed, every piece of content is hashed, and the history only grows forward. You can't quietly edit the past without the cryptography screaming about it.
• Mystery — the system respects what it can't know. It marks its uncertainty instead of dressing guesses up as facts. And — this is the one people find strange — forgetting is treated as a feature, not a bug.

We'll write more about each of those someday. For now we just want them on the record, because the rest of this post is really about the middle one.

Honesty is the whole reason

We've worked on systems that silently changed your data. A timestamp nudged here, a record "cleaned up" there, a sync conflict resolved by quietly throwing one side away and telling no one. Each individual instance was defensible. Together they taught us that most software is built to look trustworthy rather than be trustworthy — and that the gap between those two things is where users get hurt.

So in NAOMS, "the system does not lie" isn't a slogan. It's mechanical. Every action is an event, signed with your keys, appended to a history that can grow but can't be rewritten. If you want to correct something, you don't reach back and edit — you add a new event that says "I got that wrong." The correction is visible. It's part of the record. That's the opposite of how we've watched data get massaged across our careers, and it feels almost stubborn to insist on it. Good.

And we'll just say it: we don't yet know if normal people will care about any of this. The honesty is real at the cryptographic level today. Whether it matters to someone who isn't a paranoid engineer — that's a bet, not a fact.

Why in the open, then

Here's where it gets personal. If we're going to build a system whose entire pitch is "this one doesn't lie to you," we can't develop it behind a curtain and ask you to trust the curtain. That would be the joke writing itself.

Building in the open keeps us honest in a way we can't manage on our own. When the work is visible, we can't quietly walk back a principle because it got inconvenient at 2am. The append-only history isn't just a feature of the product — it's becoming a feature of how we work. The messes are logged. The wrong turns are logged. This very post will be logged.

There's a colder reason too. A local-first, encrypted, self-governing identity system is exactly the kind of thing that's worthless if you have to take the author's word for it. The value is the verifiability. So the development has to be verifiable too, or we've undermined the product with the process.

The part we're scared of

We'll be honest about the fear, since that's the theme. Building in the open means people watch you be wrong in real time. We are going to ship things that are broken, write things here we later disagree with, and chase architectures that don't pan out. All of that is now visible.

But we think that's the trade we want. The alternative — a polished surface over a private mess — is the exact thing NAOMS exists to refuse. If we're asking the software to never silently hide its mistakes, the least we can do is hold ourselves to the same bar.

So: hello. This is us, building a thing we believe in, out loud, mistakes and all. If you're reading the early entries, you're seeing the messy start. That's on purpose.

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