NAOMS Devlog

Building a sovereign, local-first memory & identity system โ€” in the open, honestly.

What iroh, nostr, and atproto Taught Us About Shipping the Work

Fellow Travelers โ€” coordination, and where our axioms pulled us somewhere different

Vision Fellow Travelers free May 31, 2026ยท4 min readยทmeta
TL;DR Three projects we study and admire โ€” iroh, nostr, and atproto โ€” shaped how NAOMS moves big files, keeps a signed event simple, and treats schemas as contracts. Here's what we took from each, honestly, and where our own axioms led us elsewhere.

This is not a competitive blog. NAOMS exists in a generous neighborhood of people solving genuinely hard problems in local-first, peer-to-peer, and decentralized systems, and we are better for studying them carefully. This week our own CI system failed in a loop and took the whole fleet down โ€” so it feels honest, and a little humbling, to look outward at how others coordinate the work that ships, and to say plainly what we took, what we adapted, and where our context led us somewhere else.

We keep a working corpus of project studies โ€” 117 of them, on disk โ€” precisely so this honoring is grounded, not hand-waved. Here are three fellow travelers relevant to a week about queues, coordination, and getting work to land.

iroh โ€” content addressing and the discipline of a clean transport

What they do well: iroh has shown how clean a content-addressed, QUIC-based transport can be โ€” direct connections, hole-punching, blobs addressed by hash, with a small and legible surface. When you read iroh, you feel the care taken to keep the transport layer honest about what it is and not a kitchen sink.

What we learned / took: the instinct that big content should move on its own content-addressed path, separate from the coordination chatter โ€” a separation that shows up directly in how NAOMS keeps gossip from ever moving your large files, and how blob reads are gated at the byte boundary.

What we did differently (and why): our context puts a per-user append-only chain and an authorization decision at the byte gate โ€” a read isn't just routed, it's gated against a read-capability at the moment the bytes leave. That's not a critique of iroh; it's a consequence of our Honesty axiom (no silent reads of data you weren't granted) and our identity model, which iroh's lower layer deliberately leaves to the application. We took the transport discipline and added an authorization plane that our axioms require.

nostr โ€” coordination as the simplest possible relay

What they do well: nostr's strength is almost philosophical restraint โ€” events, signatures, relays, and not much else. The coordination story is "publish a signed event; relays carry it." It's astonishing how much community and tooling that minimalism has unlocked, and there's real wisdom in refusing to over-specify the substrate.

What we learned / took: that a signed, append-only event is a wonderfully durable primitive, and that you should resist bolting policy onto the substrate before you understand the shape of the thing.

What we did differently (and why): where nostr keeps the substrate maximally simple and pushes semantics to clients, NAOMS folds more structure into the chain itself โ€” a graph you can query across, governance as events on the same chain, and CI/CD that runs on a hive's own append-only chain-queue rather than off to the side. The week's incident is the honest footnote here: more structure means more that can go wrong (a CI loop, in our case), and nostr's restraint is a real and respectable answer to a real risk. We chose the structure because our users need queryable, governed memory โ€” but we hold nostr's minimalism as a standing reminder of what that choice costs.

atproto โ€” the federated lexicon and schema-as-contract

What they do well: atproto's lexicon system treats schemas as first-class, named contracts, and its account-portability story (your identity can move between providers) is a serious, well-engineered answer to lock-in. The federation design is thoughtful about who hosts what and how identity survives a move.

What we learned / took: the value of treating schema discovery and data shape as an explicit, named contract rather than an implicit convention โ€” an instinct that resonates with how NAOMS handles schema across hives.

What we did differently (and why): atproto federates across providers; NAOMS is local-first, with the canonical copy of your memory on your device and no required provider at all (the Wholeness axiom โ€” complete in itself, no external dependency for core function). Portability for us isn't "move between hosts," it's "you already hold it." Different axiom, different center of gravity โ€” and atproto's federation remains the better answer for the public-social shape it targets.

The honest throughline

A week where our CI took down the fleet is a good week to remember that none of us has this solved, and that the generous thing โ€” and the useful thing โ€” is to study each other's choices as choices, with their costs visible. iroh's clean transport, nostr's restraint, atproto's schema-as-contract: we took something real from each, and where we diverged it was our axioms pulling, not their work falling short.

We'll keep a standing Fellow Travelers index as these pieces accumulate. The point isn't to rank. It's to honor the neighborhood, accurately.


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

โ† more in Vision   home โœฆ   all โ†’