There are two ways to decide whether someone gets in.

The first is identity: prove who you are, present the right credential, and the door opens. This is how almost everything works. It is simple, it is auditable, and it has a quiet flaw — it treats a stranger who just arrived and a person who has carried the group for a year as identical the moment they hold the same credential. Identity tells you who is at the door. It tells you nothing about what they have done.

The second way is the one this article is about: access granted by demonstrated contribution. Standing you earn by showing up, answering, helping, keeping your agreements — recorded not as a reputation score on someone's server but as structure in a trust graph. The newcomer and the year-long contributor are no longer interchangeable, because the graph remembers the difference.

We want to be careful here, because this is the kind of idea that is easy to describe and hard to ship, and the most valuable thing we can give you is an honest map of which parts are built and which parts are still drawings on the wall.

What's actually shipped: the trust graph beneath it

The foundation is real and it landed early. Trust in NAOMS is stored as directional edges between beings. An edge from Alice to Bob is a separate thing from an edge from Bob to Alice — trust is a property of a relationship, not a score stamped on a person. Edges come in flavours that carry meaning: a vouch weighs more than an endorse; creating one requires both parties to sign, so an edge is a mutual fact, not a unilateral claim; and each edge is capped by a Dunbar-style limit so that trust signals stay scarce and therefore meaningful.

On top of that sits a propagation engine. If Alice trusts Bob and Bob trusts Carol, the system can compute — with attenuation at each hop, and bounded to a short number of hops for both privacy and honesty — how much trust flows from Alice to Carol along the path. This shipped with tools to propagate trust along the graph, to ask "who is within my trust horizon," and to explain why a given trust level was computed. It deliberately chose a simple, transparent transitive model over the heavyweight network-wide reputation algorithms, precisely so that reasoning works on the part of the graph you can see rather than requiring the whole network.

There is even a reputation layer that computes a source's standing at query time from accumulated signals rather than storing a single number — weighting recent signals over old ones, and negative signals more heavily than positive ones. Reputation here is a calculation over evidence, not a score someone assigned you.

So the substrate for "access you earn" exists: relationships are first-class, directional, consent-bound, and traversable; standing can be computed from signals. That is the part we can point at and say shipped.

The honest gap: contribution doesn't meter, and merit doesn't gate

Here is where we have to be straight with you, because the title of this article promises something the running system does not yet fully do.

"Access you earn" requires two mechanisms that are designed but not built:

A contribution meter. For contribution to translate into standing, the system has to actually record contribution — who answered queries, who did the unglamorous care work of resolving conflicts and keeping a group healthy, who provided data others relied on. The design for this exists in detail. It describes a mutual-credit ledger with an earning side (responding to queries, doing care work) and a spending side (consuming others' answers), and it states the ambition out loud: demonstrated contributors earn authority. But that design sits in the backlog. There is no production code today that tracks who contributed what. The meter is drawn; it is not running.

A merit-to-access gate. Even with a meter, "earned access" needs the second half: standing has to actually open a door. There is a designed accountability system — including a genuinely interesting mechanic where if you vouch for someone who then violates an agreement, a cascading penalty flows back along the vouch and your own standing reflects the bet you made. The design is careful about scope: merit is relational and domain-scoped — your standing with me, within engineering, is a different quantity from your standing globally — which is the right shape, because reputation that is global and absolute is exactly the kind of score that becomes a weapon. But that accountability layer, too, is phase-one design without a shipped execution path. Crucially, even in the design, the contribution credits were explicitly visible but not used to restrict access. The gate that turns "you have earned standing" into "therefore you may" is the piece that is most aspirational of all.

So the honest scorecard reads:

• Earned trust — relational edges, consent-bound, directional, propagation-aware: shipped and tested.
• Earned merit — contribution tracking, cascading penalties, domain-scoped standing: designed, phase-one only, not in production.
• Earned access — standing actually gating what you may do: not built; there is no code path from contribution to permission.

Why the foundation matters even though the building isn't done

It would be easy to read that scorecard as "so it doesn't work yet" and move on. We think that misses why the order of construction is the interesting part.

The reason most systems can't offer earned access is not that nobody thought of it — it's that their trust model can't support it. If trust is a single global score on a person, then "earned standing" collapses into a leaderboard, and leaderboards get gamed, bought, and weaponised. The thing that makes earned access safe to build is having a trust substrate that is relational (standing exists between specific beings), scoped (within a domain, not in the absolute), consent-bound (edges are mutual, not imposed), and explainable (you can ask the system why). NAOMS shipped that substrate first, on purpose, before reaching for the merit layer on top of it.

That is the real claim of this piece, stated honestly. The trust graph that would let contribution earn access is built. The contribution meter and the access gate that would make it happen are designed and waiting. We have the floor and the load-bearing walls of a building whose upper storeys are still on paper — and the discipline worth respecting is that the upper storeys aren't quietly faked in the meantime. Contribution does not yet meter; merit does not yet gate; and when it does, it will be because the foundation underneath it was honest enough to hold the weight.

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